<a href="#gnome">Mono and GNOME</a><br>
<a href="#gui">Building GUI applications with Mono</a><br>
<a href="#msft">Mono and Microsoft</a><br>
+<a href="#platforms">Mono platforms</a><br>
<a href="#pnpproject">Mono and the Portable.NET Project</a><br>
<a href="#webservices">Web Services</a><br>
+<a href="#asp">Mono and ASP.NET</a><br>
+<a href="#ado">Mono and ADO.NET</a><br>
+<a href="#monodoc">MonoDoc</a><br>
<a href="#devel">Development Tools and Issues</a><br>
<a href="#java">Mono and Java</a><br>
<a href="#extending">Extending Mono</a><br>
<a href="#gcc">Mono and GCC</a><br>
<a href="#performance">Performance</a><br>
<a href="#licensing">Licensing</a><br>
+<a href="#patents">Patents</a><br>
<a href="#etc">Miscellaneous Questions</a><br>
+<a href="#problems">Mono Common Problems</a><br>
+A <a
+href="http://www.es.gnome.org/documentacion/articulos/mono-puf/mono-puf/">Spanish
+translation</a> is also available
<a name="basics"></a>
** Basics
Q: What is Mono exactly?
A: The Mono Project is an open development initiative sponsored by
- Ximian that is working to develop an open source, Linux-based
+ Ximian that is working to develop an open source, Unix
version of the Microsoft .NET development platform. Its objective
- is to enable Linux developers to build and
+ is to enable Unix developers to build and
deploy cross-platform .NET Applications. The project will
implement various technologies developed by Microsoft that have now
been submitted to the ECMA for standardization.
framework. Mono is an implementation of the development framework,
but not an implementation of anything else related to the .NET
Initiative, such as Passport, software-as-a-service, or
- corporate rebranding.
+ corporate re-branding.
Q: What technologies are included in Mono?
Windows has compilers that target the virtual machine from <a
href="http://msdn.microsoft.com/net/thirdparty/default.asp#lang">a
number of languages:</a> Managed C++, Java Script, Eiffel,
- Component Pascal, APL, Cobol, Oberon, Perl, Python, Scheme,
+ Component Pascal, APL, Cobol, Perl, Python, Scheme,
Smalltalk, Standard ML, Haskell, Mercury and Oberon.
The CLR and the Common Type System (CTS) enables applications and
Q: Where can I find the specification for these technologies?
-A: You can find the work-in-progress documentation from the T3G ECMA
- group here:
+A: You can find the information here:
- <a href="http://www.dotnetexperts.com">http://www.dotnetexperts.com</a>
+
+ C# <a href="http://www.ecma.ch/ecma1/STAND/ecma-334.htm">http://www.ecma.ch/ecma1/STAND/ecma-334.htm</a>
+
+ CLI <a href="http://www.ecma.ch/ecma1/STAND/ecma-335.htm">http://www.ecma.ch/ecma1/STAND/ecma-335.htm</a>
Q: Will you implement the .NET Framework SDK class libraries?
Q: Will you offer an ECMA-compliant set of class libraries?
-A: Eventually we will. Our current focus is on interoperating
+A: Eventually we will. Our current focus is on inter-operating
with the Microsoft SDK, but we will also offer an ECMA compliant
set of libraries.
A: The JIT engine is usable on Intel x86 machines. An interpreter
can be used on other non-Intel x86 machines.
- The class libraries are not yet mature enough to run real applications,
- but if you are interested in trying out Mono, you can definetly start
- testing things out as many programs run.
-
- The C# compiler has made significant progress, it can even compile
- itself now, but it can not yet be ran with our class libraries as
- they are missing some features.
+ The class libraries are mature enough to run some real applications
+ (the compiler for instance, and every day more and more applications
+ are natively developed with Mono).
Q: When will you ship it?
-A: It is premature to target a shipdate for the code, but we
- anticipate that it will be available some time in the middle of
- 2002.
+A: Different parts of Mono will achieve usability at different stages,
+ once we are comfortable with the compiler, we will release "Mono Core",
+ which contains everything needed to develop applications with the base
+ class libraries, this will happen soon and in the meantime you can
+ download daily snapshots of our work. Also the full ASP.NET support is
+ close to completion.
+
+ Other higher level class libraries (ASP.NET, ADO.NET, WinForms) will
+ be released when they become stable.
+
+Q: What major components will you include in Mono?
+
+A: Hopefully everything that Microsoft ships on their Framework
+ (ADO.NET, ASP.NET, WinForms), and we encourage third party developers to
+ create reusable components that work on both Mono and Windows.
Q: How can I contribute?
Project white paper</a>.
the project.
+Q: Miguel said once that Mono was being implemented in COBOL. Is that true?.
+
+A: No. It was a joke.
+
<a name="ximian"></a>
A: When Mono is ready to be shipped Ximian will offer a commercial
support and services for Mono.
+Q: Does Ximian provide consulting services around Mono?
+
+A: Yes, Ximian does provide consulting services around Mono to
+ make it suitable to your needs. Porting the runtime engine,
+ customizing it, working on specific classes or tuning the code
+ for your particular needs.
+
Q: Will you wait until Mono is finished?
A: Mono will ship on various stages as they mature. Some people
require only a subset of the technologies, those will ship first.
More advanced features will take more time to develop. A support
- timeline will be available in June 2002.
+ time line will be available in June 2002.
<a name="gnome"></a>
** Mono and GNOME
We encourage GNOME developers to continue using the existing tools,
libraries and components. Improvements made to GNOME will have an
- impact on Mono, as they would be the "backend" for various classes.
+ impact on Mono, as they would be the "back-end" for various classes.
Q: Will Mono include compatibility with Bonobo components? What is the
relationship between Mono and Bonobo?
A: Yes, we will enable people to write GNOME applications using Mono.
+Q: Do you have C# bindings for GNOME?.
+
+A: Yes, we currently bind libgnome, libgnomecanvas, and libgnomeui --
+ although I dare say I have no idea how functional the bindings are
+ outside of what I tested in the sample app. I imagine other libraries
+ under the GNOME framework will be added on an as-needed (and as-requested)
+ basis...although a truly good bonobo binding will have to wait on the CORBA
+ remoting support which has been started recently.
+
<a name="gui"></a>
** GUI applications
Q: Will Mono enable GUI applications to be authored?
A: Yes, you will be able to build GUI applications. Indeed, that is our
- main focus. We will provide both the Windows.Forms API and the Gtk# AP(I.
+ main focus. We will provide both the Windows.Forms API and the Gtk# API.
Q: What is the difference between Gtk# and System.Windows.Forms?
CIL-enabled languages). System.Windows.Forms is an API defined
by Microsoft to build GUI applications.
+Q: Why not implement System.Windows.Forms on top of Gtk# or Qt#?
+
+A: There are several reasons for this.
+
+ First of all, Gtk+ and Qt are standard toolkits on Linux, and their
+ proponents want to use their favorite toolkits when writing
+ applications.
+
+ Related to this is the idea that System.Windows.Forms is
+ brain-dead in certain areas, such as internationalization.
+ System.Windows.Forms uses explicit sizes for all controls, as opposed
+ to Gtk+ and Qt which use a box/packing model, which can better deal with
+ the different string lengths different languages will have.
+
+ Next is compatibility. It is not possible to implement
+ System.Windows.Forms on top of Gtk+/Qt and have 100% compatibility,
+ because System.Windows.Forms exposes <i>lots</i> of Win32-isms, such as the
+ Win32 message loop. In order to maintain compatibility, Wine must be used,
+ and this is being done; see the
+ <a href="/winforms.html">System.Windows.Forms effort page</a>.
+
+ Additionally, Wine apps don't currently fit in -- visually -- with
+ Gtk+ or Qt apps.
+
Q: Will I be able to run my smart clients on systems powered by Mono?
A: As long as your applications are 100% .NET and do not make use
of P/Invoke to call Win32 functions, your smart client applications
will run on Mono platforms.
+Q: Where can I learn more about Gtk#?
+
+A: The following <a href="http://gtk-sharp.sourceforge.net>link</a> sends you to the page of the project.
+
+Q: What can I do with Gtk#?.
+
+A: Gtk# is becoming very usable and you can create applications and
+ applets like those you see in a GNOME desktop environment. It's
+ easy to install so it's worth a try.
+
+Q: How can I compile my HelloWorld.cs which uses Gtk#?.
+
+A: Try: mcs --unsafe -o HelloWorld.exe -r glib-sharp -r pango-sharp -r
+ atk-sharp -r gdk-sharp -r gtk-sharp -r gdk-imaging-sharp
+ HelloWorld.cs
+
+Q: Is there any way how to connect DataAdapter to some GTK# controls?
+
+A: There is a sample file called `DbClient' in gtk-sharp/samples that you
+ might to look at. It is a sample program in Gtk# that adds/updates/deletes
+ information on a Postgress database. When we have the new table/tree widgets,
+ I am sure someone would write an adapter for System.Data (in Gtk2 the
+ tree/list widgets are written using a view/model, so you only need to write
+ a model that maps to the database). You can have a look at
+ gtk-sharp/sample/DbClient, where there is a GTK# application that uses
+ System.Data. It does not use DataAdapter, but DataReader though.
+
+Q: Do you have an estimate for when Windows.Forms will be released?
+
+A: We do not know, volunteers are working on this, but there is no set
+ date yet. The current approach is using the Wine Library to implement
+ it.
+
<a name="msft"></a>
** Mono and Microsoft
Q: Is Microsoft helping Ximian with this project?
-A: No. Ximian CTO Miguel de Icaza had a friendly conversation with
- Microsoft software architect David Stutz, but that's about the
- extent of the contact. Microsoft is interested in other
- implementations of .NET and are willing to help make the ECMA spec
- more accurate for this purpose.
+A: There is no high level communication between Ximian and Microsoft
+ at this point, but engineers who work on .NET or the ECMA groups
+ have been very friendly, and very nice to answer our questions, or
+ clarify part of the specification for us.
+
+ Microsoft is interested in other implementations of .NET and are
+ willing to help make the ECMA spec more accurate for this purpose.
- Ximian representatives have also spoken with Sam Ruby at the ECMA
- TG3 committee to discuss the same issues.
+ Ximian was also invited to participate in the ECMA committee
+ meetings for C# and the CLI.
Q: Is Microsoft or Corel paying Ximian to do this?
A: No. Microsoft proved with the CLI and the C# language that it was
possible to create a powerful foundation for many languages to
- interoperate. We will always have that.
+ inter-operate. We will always have that.
Even if changes happened in the platform which were undocumented,
the existing platform would a value on its own.
learn more about running Windows applications on Intel Unix systems
refer to <a href="http://www.winehq.com">the Wine Project</a>.
+Q: Will I be able to compile a Microsoft VB.NET application and execute
+ the resultant MSIL file under MONO on Linux without converting to C#
+ and recompiling?
+
+A: Once we have a complete VisualBasic runtime, yes.
+
+Q: Can mono run the WebMatrix?
+
+A: No. That requires System.Windows.Forms support which is not
+ currently implemented.
+
+Q: Does mono have something like Passport?
+ Will mono have a server side Passport/Similar framework for XSP as well as client classes?
+
+A: Not yet, but the client side API for authentication is not the problem.
+ We will likely have a lot of other authentication APIs, like the Liberty
+ Alliance APIs. The problem is people on the web provider end that might use
+ this for authentication.
+
+<a name="platforms"></a>
+** Mono Platforms
+
+Q: What operating systems does Mono run on?
+
+A: Mono is known to run on Linux, Unix and Windows systems.
+
+Q: What architectures does Mono support?
+
+A: Mono today ships with a Just-in-Time compiler for x86-based
+ systems. It is tested regularly on Linux, FreeBSD and Windows
+ (with the XP/NT core).
+
+ There is also an interpreter, which is slower that runs on the
+ s390, SPARC and PowerPC architectures.
+
+Q: Can Mono run on Windows 9x, or ME editions?
+
+A: Mono requires Unicode versions of Win32 APIs to run,
+ and only a handful of *W functions is supported under Win9x.
+
+ There is Microsoft Layer for Unicode that provides implementation
+ of these APIs on 9x systems.
+
+ Unfortunately it uses linker trick for delayed load that is not
+ supported by ld, so some sort of adapter is necessary.
+
+ You will need MSLU and one of the following libs to link Mono to
+ unicows.dll <a
+ href="http://mono.eurosoft.od.ua/files/unimono.zip">http://mono.eurosoft.od.ua/files/unimono.zip</a>
+ or alternatively search the net for "libunicows".
+
+ No changes to Mono source code required, the only thing is to make
+ sure that linker will resolve imports to adapter library instead of
+ Win32 libs. This is achieved by inserting -lunimono before
+ -lkerner32/user32 in the linker's specs file.
+
+
<a name="pnpproject"></a>
** Mono and Portable.NET
A: Most of Mono is being written using C#, with only
a few parts written in C (The JIT engine, the runtime, the
- interfaces to the garbage collection system). The Portable.NET
- Project is using C for development.
+ interfaces to the garbage collection system).
+
+ It is easier to describe what is unique about Mono:
+ <ul>
+ <li> An advanced native-code compilation engine: Both
+ just-in-time compilation (JIT) and pre-compilation of CIL
+ bytecodes into native code are supported.
+
+ <li> A foundation for code optimization: The new code generator in
+ Mono builds on the experience of our first JIT engine, and enables
+ us to implement various advanced compiler optimization
+ tricks. With an SSA-framework, plenty of new optimizations are possible.
+
+ The current list of optimizations are: Peephole postpass,
+ Branch optimizations, Inline method calls, Constant folding, Constant
+ propagation, Copy propagation, Dead code elimination, Linear scan
+ global reg allocation, Conditional moves, Emit per-domain code,
+ Instruction scheduling, Intrinsic method implementations, Tail
+ recursion and tail calls, Loop related optimizations, Fast x86 FP
+ compares, Leaf procedures optimizations
+
+ <li> A self-hosting C# compiler written in C#, which is clean, easy
+ to maintain.
+
+ <li> Focus on the .NET Framework: we are tracking down the .NET
+ Framework API definition, as we believe it is the API people
+ will be most familiar with.
+
+ <li> A multi-platform runtime engine: both a JIT engine and an
+ interpreter exist. The JIT engine runs currently on x86
+ systems, while the interpreter works on SPARC, StrongARM,
+ s390 and PowerPC systems.
+
+ Our new compilation engine is being ported to the PowerPC.
+
+ <li> Supports Linux, BSD, Windows and Solaris at this point.
+
+ <li> The JIT engine is written using a portable instruction
+ selector which not only generates good code but
+ is also the foundation to re-target the JIT engine to other
+ systems.
+
+ <li> Full support for remoting in the runtime.
+
+ <li> The C# compiler, the JIT engine and the class libraries are
+ mature enough that the whole system has been self-hosting
+ since April 2002. This means that we develop Mono
+ completely with itself at this point.
+
+ By forcing ourselves to use our own code to develop our
+ tools, we bug fix problems rapidly, and the system is
+ overall more robust and tested than if we did not.
+
+ <li> We have a great community of developers, without which Mono
+ would not be possible.
+ </ul>
<a name="webservices"></a>
** Web Services
Q: Can I author Web Services with Mono?
A: You will be able to write Web Services on .NET that run on Mono and
- viceversa.
+ vice-versa.
Q: If Mono implements the SDK classes, will I be able to write and
execute .NET Web Services with it?
exposing it to other RPC systems (like CORBA) is really simple, and
does not even require support from an object.
- We will be implementing CORBA interoperation as an extension to the
- Mono classes so that we can integrate with Bonobo, just like
- Microsoft provides COM interoperation classes and support
- mechanisms.
+ <a href="http://remoting-corba.sourceforge.net/">Remoting.CORBA</a> is
+ a CORBA implementation that is gaining momentum.
+
+ Building an implementation of the Bonobo interfaces once this is ready
+ should be relatively simple.
Q: Can I serialize my objects to other things other than XML?
A: Yes, although the serializing tools have not yet been planned, and
-you would probably have to implement them yourself.
+ you would probably have to implement them yourself.
+
+Q: Will Mono use ORBit?
+
+A: There are a few advantages in using ORBit, like reusing existing code
+ and leveraging all the work done on it. Michael Meeks has posted
+ a few <a href="http://lists.ximian.com/archives/public/mono-list/2002-September/008592.html">reasons</a>,
+ as well as some <a href="http://lists.ximian.com/archives/public/mono-list/2002-September/008657.html">ideas</a>
+ that could be used to reuse ORBit.
+
+ Most users are likely to choose a native .NET solution, like <a href="http://cvs.gnome.org/bonsai">Remoting.CORBA</a>
+
+
+<a name="monodoc"></a>
+** MonoDoc
+
+Q: What is MonoDoc?
+
+A: MonoDoc is a graphical documentation browser for the Mono class
+ libraries. Currently, monodoc consists of a Gtk# application and is
+ in heavy development.
<a name="devel"></a>
** Development Tools and Issues
-Q: Will it be possible to use the CLI features without using bytecodes
+Q: I am having trouble compiling a new version of Mono from CVS, it
+ complains about my runtime being out of sync.
+
+A: Jonathan Pryor has provided the following answer:
+
+ To upgrade your class libraries and compiler, see the See
+ README.building in the MCS directory.
+
+ The single biggest source of confusion seems to be the "Your
+ runtime is out of sync" messages. Realize that this is *normal*
+ while BUILDING. Think about it: you're building a new class
+ library with the old runtime. If the new class library references
+ a function that the old runtime knows nothing about, the runtime
+ system issues this warning.
+
+ Basically what needs to happen is for a new mono runtime to be
+ compiled, then the corlib class library be compiled, and once this
+ is done, install the new runtime, followed by corlib.
+
+ Once this is done, you can continue building your entire
+ environment.
+
+Q: Will it be possible to use the CLI features without using byte codes
or the JIT?
A: Yes. The CLI engine will be made available as a shared library.
The garbage collection engine, the threading abstraction, the
object system, the dynamic type code system and the JIT will be
- available for C developers to integreate with their applications if
+ available for C developers to integrate with their applications if
they wish to do so.
Q: Will you have new development tools?
can interpret them as trivially as you can interpret JVM byte
codes.
+Q: Isn't it a little bit confusing to have the name of "XSP" (the same
+ as in the Apache Project) for the ASP.NET support in Mono?.
+
+A: In Mono, xsp is just the name of the C# code generator for ASP.NET
+ pages. In the Apache Project, it is a term for the "eXtensible Server
+ Pages" technology so as they are very different things, they don't
+ conflict.
+
+Q: What about using something like Jabber instead of the System.Messaging
+ namespace?.
+
+A: In short, MSMQ is not something like Jabber, but asynchronous messaging
+ through queues. Useful queues do more than serialize messages, they are
+ also platform bridges.
+
+Q: Are you supporting XMLDocument and relatives?.
+
+A: Currently, we aren't implementing them yet. It would require updates to
+ most of the XmlNode derivatives so it's not a trivial task. We are
+ currently focusing on getting XPath support working.
+
+Q: Is there any plan to develop an aspx server for Mono?.
+
+A: The web server turned out to be very simple compared to the rest of the
+ work. Gonzalo has got the page generator mostly done (a module called
+ xsp, who has nothing to do with the XSP term used in the Apache Project).
+ Patrik has done a lot of the work to get the ProcessRequest to work.
+ You can try to help in the final touches to the System.Web classes and
+ writing regression tests for the widgets we have.
+
+Q: Is there any way I can develop the class libraries using Linux yet?
+
+A: Yes. Some class libraries can be developed on Linux. Search for
+ Paolo's post (he lists which classes can be compiled fine now).
+
+Q: Is there any way I can install a known working copy of mono in /usr,
+ and an experimental copy somewhere else, and have both copies use
+ their own libraries? (I'm still not very good at library paths in
+ Linux)
+
+A: Yes. Just use two installation prefixes.
+
+Q: How should I write tests or a tests suite?
+
+A: If you do a test suite for C#, you might want to keep it
+ independent of the Mono C# compiler, so that other compiler
+ implementations can later use it.
+
+Q: Would it be too terrible to have another corlib signed as mscorlib?
+
+A: We rename corlib to mscorlib also when saving the PE files, in fact,
+ the runtime can execute program created by mono just fine.
+
+Q: Is there a relatively straightforward way to repeat the steps taken
+ by Paolo to get Mono completely self-hosted on Linux?
+
+A: To build the compiler and class libraries in Linux, run:
+ <ul><li>make -f makefile.gnu. To install them, run: </li>
+ <li>make -f makefile.gnu install prefix=/opt/mono</li>
+ </ul>
+
+ If you want to produce and distribute a monocharge tarball, run:
+ make -f makefile.gnu dist
+ Of course you have to run these in the top level mcs directory.
+
+Q: Is it possible to build a C# file to some sort of intermediate format which
+ can linked into a final module, like the traditional .c -> .o -> .so path?
+
+A: You could do: mcs /target:module file1.cs, mcs /target:module file2.cs,
+ mcs /target:exe file1.dll file2.dll /out:mybin.exe
+
+Q: Is there any plans for implementing remoting in the near future?, When will
+ work in System.Runtime.Remoting.dll start?
+
+A: The remoting infrastructure is in place. Some of the channels and
+ formatters are not.
+
+Q: I'm wondering if there are any plans to start using nant to build the
+ class lib + test lib. i think that every project need/should use an
+ automated build process and nant + a couple of tools enables this. is
+ the problem that the compiler can't run nant yet?
+
+A: Maybe well be doing some sort of automated build process + testing when
+ the summer finish.
+
+Q: My C code uses the __stdcall which is not availble on Linux, how can I
+ make the code portable Windows/Unix across platforms?
+
+A: Replace the __stdcall attribute with the STDCALL macro, and include this
+ in your C code for newer gcc versions:
+
+ #ifndef STDCALL
+ #define STDCALL __attribute__((stdcall))
+ #endif
+
+<a name="asp">
+** Mono and ASP.NET
+
+Q: Does Mono support ASP.NET?
+
+A: Yes.
+
+ Mono supports ASP.NET, we have shown an unmodified IBuySpy
+ installation running on Mono as well as various other programs. You can
+ try it yourself downloading the XSP server.
+
+Q: Do I need install cygwin to work on ASP.NET in mono or Linux is enough since
+ it is self host right now.
+
+A: Linux is enough.
+
+Q: How can I run ASP.NET-based applications with Mono?
+
+A: You need the Mono runtime and a hosting web server. Currently we distribute a
+ small web server called `xsp' which is used to debug applications, or you can choose
+ to use Daniel's Apache 2 module.
+
+Q: Any plan to make ASP.NET in mono works with Apache in Linux?.
+
+A: Daniel has authored an Apache2 Module for Mono that hosts the ASP.NET runtime
+ and is available here: <a
+ href="http://apacheworld.org/modmono/">http://apacheworld.org/modmono/</a>
+
+Q: Will you support Apache 1?
+
+A: Modules developed for Apache 2 are not compatible with Apache 1.3
+ Daniel plans to support Apache 1.3 in the future but the current focus is on
+ Apache 2, because of the better support for threading and Windows.
+
+Q: Can I run Apache 1 and Apache 2 on the same machine?
+
+ You can always keep a copy of Apache 2 running in paralell with your Apache
+ 1.3 (either different port or using a reverse proxy).
+
+ You can also bind the two servers to different IP addresses on the
+ same physical machine.
+
+<a name="ado">
+** Mono and ADO.NET
+
+Q: What is the status of ADO.NET support?. Could I start migrating
+ applications from MS.NET to Mono?.
+
+A: You could start right now using the ADO.NET support in mono, of course,
+ if you want to help filling the missing gaps while you develop your app
+ :-) Well, what I mean is that we're not that far to having full ADO.NET
+ support in Mono, and we've got a lot of working things, so if we could
+ get more help, we'd finish it really soon :-)
+
+Q: In developing the data architecture for the application are there and
+ objects I should stay away from in order to insure the smoothest possible
+ transition (minimum code rewrite) to Mono's ADO.NET implementation? (For
+ example, strongly typed datasets versus untyped datasets, etc...)
+
+A: We are implementing all the classes in Microsoft .NET's System.Data, so
+ you can be sure that things will work the same in Mono as with the Microsoft
+ implementation.
+
+Q: Does Mono can to connect to Sybase by using Mono.Data.*?
+
+A: Yes. use Mono.Data.SybaseClient. First of all you have to create a
+ SybaseConnection, and then, from it, use it as any other
+ IDbConnection-based class.
+
<a name="java">
** Mono and Java
A: You can get very good tools for doing Java development on free
systems right now. <a href="http://www.redhat.com">Red Hat</a> has
contributed a <a href="http://gcc.gnu.org">GCC</a> <a
- href="http://gcc.gnu.org/java">frontend for Java</a> that can take
+ href="http://gcc.gnu.org/java">front-end for Java</a> that can take
Java sources or Java byte codes and generate native executables; <a
href="http://www.transvirtual.com">Transvirtual</a> has implemented
<a href="http://www.kaffe.org">Kaffe</a> a JIT engine for Java;
Q: Could Java target the CLI?
-A: Yes, Java could target the CLI. We have details on a <a
- href="ideas.html#guavac">project</a> that someone could take on to
- make this happen.
+A: Yes, Java could target the CLI, Microsoft's J# compiler does that.
- Microsoft has an implemenation of the Java language called J# that
- can target the CIL execution engine.
+ The <a href="http://weblog.ikvm.net/">IKVM</a> project builds a
+ Java runtime that works on top of .NET and on top of Mono. IKVM is
+ essentially a JIT compiler that translates from JVM bytecodes into
+ CIL instructions, and then lets the native JIT engine take over.
+
+Q: Is it possible to write a JVM byte code to CIL converter?
+
+A: Yes, it is possible. Here are a few starting point:
+
+ <ul>
+ * A byte code representation is really a flattened forest of
+ trees. Look at the Mono JIT engine to see how we compute
+ the basic blocks (this is used to figure out the "trees").
+
+ The forest is just an array of trees.
+
+ Indeed, run the JIT engine with -d (mono -d prog.exe) and
+ you will see how these trees look like.
+
+ You will have to do something similar for Java.
+
+ * Each "forest of trees" has a meaning. This meaning can now
+ be translated into the equivalent "meaning" in CLR-land.
+ </ul>
+
+ See also the <a href="http://weblog.ikvm.net/">IKVM project</a>
+
+Q: Could mono become a hybrid CIL/java platform?
+
+A: No. It is quite far from the philosophy of the project. The idea of Mono
+ is, to have only _one_ VM, on which all can run. And if there existing a
+ binary-converter from Java-.class to IL and if there existing something
+ like J-Sharp on Mono, you can write programs in Java, which than can run
+ on Mono. You do not need two bindings (like your example: GTK-Sharp _and_
+ Java-Gnome). You need only _one_ of it (GTK-Sharp). Thats the idea of Mono.
+ An other point is, that there are no people, who use Open Source-JVMs. They
+ all prefer Suns original. But for Unix there don't exist a .NET-Framework.
+ So it is possible, that in the future Mono is the standard .NET for Unixes.
+
+Q: Do you plan to implement a Javascript compiler?
+
+A: Yes. The beginnings of the JScript compiler can be found on CVS.
+ Cesar coordinates this effort.
+
+Q: Can Mono or .NET share system classes (loaded from mscore.dll and other
+ libs) or will it behave like Sun's Java VM?
+
+A: What you can do with mono is to load different applications in their own
+ application domain: this is a feature of the CLR that allows sandboxing
+ applications inside a single process space. This is usualy exploited to
+ compartmentalize different parts of the same app, but it can also be
+ effectively used to reduce the startup and memory overhead.
+ Using different appdomains the runtime representation of types and
+ methods is shared across applications.
<a name="extending"></a>
** Extending Mono
If you have innovative ideas, and want to create new classes, we
encourage you to make those classes operate correctly well in both
- Mono and .NET
+ Mono and .NET.
+
+ Today Mono ships with a number of extra libraries that were
+ developed either by members of the Mono community, or other
+ groups.
+
+Q: Is there any way I can develop the class libraries using Linux yet?
+
+A: Yes. Mono has been selfhosting since March 2002.
+
+Q: Is there any way I can install a known working copy of mono in /usr,
+ and an experimental copy somewhere else, and have both copies use
+ their own libraries? (I'm still not very good at library paths in
+ Linux)
+
+A: Yes. Just use two installation prefixes.
+
<a name="portability"></a>
** Portability
Windows. We do not expect many Linux-isms in the code, so it
should be easy to port Mono to other UNIX variants.
-Q: What about Mono on non X-based systems?
+Q: What about Mono on non Linux-based systems?
A: Our main intention at Ximian is to be able to develop GNOME
applications with Mono, but if you are interested in providing a
- port of the Winform classes to other platforms (frame buffer or
+ port of the Winforms classes to other platforms (frame buffer or
MacOS X for example), we would gladly integrate them, as long
they are under an open source license.
-Q: Will Mono run on Windows?
+Q: What operating systems/CPUs do you support
+
+A: Mono currently runs on Linux, Windows, Solaris and FreeBSD.
+ There is a JIT engine available for x86 processors that can
+ generate code and optimizations tailored for a particular CPU.
+
+ Interpreters exist for the SPARC, PowerPC and StrongARM CPUs.
+
+Q: Does Mono run on Windows?
+
+A: Yes. You can get pre-compiled
+ binaries from <a href="http://www.go-mono.com/download.html">http://www.go-mono.com/download.html</a>
+
+Q: Does Mono run on Linux?
-A: We hope so. Currently some parts of Mono only run on Windows
- (the C# compiler is a .NET executable) and other parts have only
- been compiled on Linux, but work on Windows with Cygwin.
+A: Yes. You can get pre-compiled
+ binaries from <a href="http://www.go-mono.com/download.html">http://www.go-mono.com/download.html</a>
+
+Q: Will I require Cygwin to run mono?
+
+A: No. Cygwin is only required to build Mono.
Q: Will Mono depend on GNOME?
in Mono for implementing a `Hello World Enterprise P2P Web
Service', you will not need any GNOME components.
+Q: Is anyone working on porting Mono to IA-64?
+
+A: Nobody is working on such port.
+
+Q: If I were about to start a Mono port to IA-64,would the same lburg code
+ generator work for IA-64 also? or anything else need to be used for code
+ generation(as the processor architecture is totally different from IA32)
+
+A: The lburg approach can be use for any processor architecture. But you might
+ think in another better approach.
+
+Q: Do you plan to port Rhino to C#?.
+
+A: Eto Demerzal has started a Rhino port to C#.
+
+Q: Has anyone succeeded in building a Mac version of the C# environment.
+ If so can you explain how?
+
+A: You could try to check with the Darwin people, or the Fink people.
+ Mono/C# is self hosting on Linux/PPC which is the hard part, so it
+ should be relatively simple to get it to work on MacOS
+
<a name="reuse"></a>
** Reusing Existing Code
defined API that splits the JIT from the GC system and the actual
byte code implementation.
+ We are using some pieces of ORP (Their code generation interface)
+ and we use it as a source of inspiration for optimizations. Paolo
+ and Dietmar consider ORP as being one of the best JIT engines out
+ there (and their research work and papers are very useful if you are
+ interested in JIT technology).
+
Q: What about using GNU Lightning?
-A: We are also researching <a
- href="http://www.gnu.org/software/lightning/lightning.html">GNU
- Lightning</a>.
+A: We are not using GNU Lightning. Our JIT is using an instruction
+ selector based on tree-pattern matching, and a code generation
+ interface that is very tied to the current architecture.
+
+Q: Will I be able to use Microsoft SQL Server 2000 or will I need to switch
+ to a specific Open Source Database. Will I need to recode?
+
+A: There should not be any need to recode.
+
+Q: What do I need to watch out for when programming in VB.NET so that I'm
+ sure to be able to run those apps on Linux?
+
+A: Not making any PInvoke or DLL calls should and not using anything in
+ the Microsoft.* namespaces should suffice. Also do not use any
+ Methods/Classes marked as "This type/method supports the .NET Framework
+ infrastructure and is not intended to be used directly from your code."
+ even if you know what these classes/methods do.
+
+Q: Will built-in reporting be supported for crystal reports? This is a
+ heavily used part of our system.
+
+A: Probably not. Crystal Reports are propriety. Someone may try to emulate
+ the behavior, but no-one has yet volunteered.
+
+Q: Who about writing to the registry? As I understand it, Linux does not have
+ a counterpart to the registry. Should I avoid relying on that feature?
+
+A: Try to avoid it. Although there would be a emulation for registry in
+ Mono too. GNOME does have a registry like mechanism for configuration. But
+ Even if gnome has a configuration system similar to the registry, the keys
+ will not be equal, so you will probably end up having to do some runtime
+ detection, and depending on this load an assembly that has your
+ platform-specific hacks.
+
+Q: System.Data.SqlClient with FreeTDS, will you port parts of these to C# and
+ use them?
+
+A: if their license is compatible with mono's, yes, we'd think about porting
+ them. If not, we'll continue with the plan of using FreeTDS.
<a name="gcc"></a>
** Mono and GCC
-Q: Are you working on a GCC front-end to C#? A GCC backend that will
+Q: Are you working on a GCC front-end to C#? A GCC back-end that will
generate CIL images? What about making a front-end to GCC that
takes CIL images and generates native code?
Q: What license or licenses are you using for the Mono Project?
-A: The C# Compiler is released under the terms of the GPL. The class
- libraries will be under the LGPL or the GPL with a special
- exception. The runtime libraries are under the LGPL.
-
- Since the LGPL is not suitable for embedded systems development, we
- are also licensing the libraries under the GPL with the following exception:
+A: The C# Compiler is released under the terms of the <a
+ href="http://www.opensource.org/licenses/gpl-license.html">GNU GPL</a>. The runtime
+ libraries are under the <a
+ href="http://www.opensource.org/licenses/lgpl-license.html">GNU
+ Library GPL</a>. And the class libraries are released
+ under the terms of the <a
+ href="http://www.opensource.org/licenses/mit-license.html">MIT X11</a>
+ license.
- If you link this library against your own program, then you do not
- need to release the source code for that program. However, any
- changes that you make to the library itself, or to any native
- methods upon which the library relies, must be re-distributed in
- accordance with the terms of the GPL.
+ The Mono runtime and the Mono C# Compiler are also available under
+ a proprietary license for those who can not use the LGPL and the
+ GPL in their code.
- This is similar in spirit to <a
- href="http://www.gnu.org/software/classpath/classpath.html">GNU
- Classpath.</a>
+ For licensing details, contact <a
+ href="mailto:mono-licensing@ximian.com">mono-licensing@ximian.com</a>
-Q: Can I subclass objects within the LGPL licensed Mono code and still release
- the resulting software under a closed license?
-
-A: Yes. Subclassing does not "count" as a modification to GPL'ed code.
- This means that you may use subclasses when developing proprietary
- code with Mono.
Q: I would like to contribute code to Mono under a particular
license. What licenses will you accept?
A: We will have to evaluate the licenses for compatibility first,
- but as a general rule, we will accept all GPL and LGPL-compatible
- licenses. If you want to use the BSD
- license, make sure you use the BSD license without the
- advertisement clause (The `Ousterhout License').
+ but as a general rule, we will accept the code under the same
+ terms of the "container" module.
+
+<a name="patents"></a>
+** Patents
+
+Q: Could patents be used to completely disable Mono (either submarine
+ patents filed now, or changes made by Microsoft specifically to
+ create patent problems)?
+
+A: First some background information.
+
+ The .NET Framework is divided in two parts: the ECMA/ISO covered
+ technologies and the other technologies developed on top of it like
+ ADO.NET, ASP.NET and Windows.Forms.
+
+ Mono implements the ECMA/ISO covered parts, as well as being a
+ project that aims to implement the higher level blocks like
+ ASP.NET, ADO.NET and Windows.Forms.
+
+ The Mono project has gone beyond both of those components and has
+ developed and integrated third party class libraries, the most
+ important being: Debugging APIs, integration with the Gnome
+ platform (Accessibility, Pango rendering, Gdk/Gtk, Glade, GnomeUI),
+ Mozilla, OpenGL, extensive database support (Microsoft only
+ supports a couple of providers out of the box, while Mono has
+ support for 11 different providers), our POSIX integration
+ libraries and finally the embedded API (used to add scripting to
+ applications and host the CLI, or for example as an embedded
+ runtime in Apache).
+
+ The core of the .NET Framework, and what has been patented by
+ Microsoft falls under the ECMA/ISO submission. Jim Miller at
+ Microsoft has made a statement on the patents covering ISO/ECMA,
+ (he is one of the inventors listed in the patent): <a
+ href="https://mailserver.di.unipi.it/pipermail/dotnet-sscli/msg00218.html">here</a>.
+
+ Basically a grant is given to anyone who want to implement those
+ components for free and for any purpose.
+
+ The controversial elements are the ASP.NET, ADO.NET and
+ Windows.Forms subsets. Those are convenient for people who need
+ full compatibility with the Windows platform, but are not required
+ for the open source Mono platform, nor integration with today's
+ Mono's rich support of Linux.
+
+ The Mono strategy for dealing with these tehcnologies is as
+ follows: (1) work around the patent by using a different
+ implementation techinque that retains the API, but changes the
+ mechanism; if that is not possible, we would (2) remove the pieces
+ of code that were covered by those patents, and also (3) find prior
+ art that would render the patent useless.
+
+ Not providing a patented capability would weaken the
+ interoperability, but it would still provide the free software /
+ open source software community with good development tools, which
+ is the primary reason for developing Mono.
+
+ The patents do not apply in countries where software patents are
+ not allowed.
-<a name="etc"></a>
+ For Linux server and desktop development, we only need the ECMA
+ components, and things that we have developed (like Gtk#) or Apache
+ integration.
+
+<a name="etc"></a>
** Miscellaneous Questions
Q: You say that the CLI allows multiple languages to execute on the
CLI allows "data-level interoperability" because every
language/component uses the same data layout and memory management.
- This means you can operate directly upon the datatypes that someone
+ This means you can operate directly upon the data types that someone
else provides, without having to go via their interfaces. It also
- means you don't have to "marshall" (convert) parameters (data
+ means you don't have to "marshal" (convert) parameters (data
layouts are the same, so you can just pass components directly) and
- you don't have to worry about memory managment, because all
+ you don't have to worry about memory management, because all
languages/components share the same garbage collector and address
space. This means much less copying and no need for reference
counting.
+Q: Will you support COM?
+
+A: The runtime will support XPCOM on Unix systems and COM on Windows.
+ Most of the code for dynamic trampolines exists already.
+
+Q: Will Ximian offer certifications on Mono or related technologies?.
+
+A: It's possible. But there is no plan about this. So the short answer is no.
+
+Q: Are there any Boehm's GC binaries?
+
+A: Yes. You can find RPMs <a href="http://java.thn.htu.se/~toor/">here</a>, though
+ if your distribution provides the correct packages, you should use those.
+ The suggested version of the Boehm GC is 6.1.
+
+Q: How can I report a bug?
+
+A: The best thing is to track down the bug and provide a simple test to
+ reproduce the bug. You can then add the bug to the
+ <a href="http://bugzilla.ximian.com/enter_bug.cgi">bugtracking system</a>.
+
+ Please provide information about what version of mono you're using
+ and any relevant details to be able to reproduce the bug. Note that
+ bugs reported on the mailing-list may be easily forgotten, so it's
+ better to file them in the <a href="http://bugzilla.ximian.com/enter_bug.cgi">bug tracking system</a>.
+
+Q: Does mcs support the same command line options as the MS C#
+ compiler?
+
+A: The Mono C# compiler now supports the same command line
+ arguments as the Microsoft C# compiler does.
+
+Q: How about getting searchable archives on lists.ximian.com?
+
+A: You can perform a search on the mono-related mailing lists
+ <a href="http://www.go-mono.com/mailing-lists.html">here</a>.
+
+Q: When using mono from cvs or from a snapshot, I get an error messaage
+ saying that Mono and the runtime are out of sync. How do I fix that?
+
+A: If you use mono from cvs, you need to be prepared for changes in the
+ runtime internals. This means that you should keep a working setup
+ before blindling updating (a working setup may just be the last released
+ tarball or a recent binary snapshot).
+ Usually, compiling corlib with mcs before recompiling the C runtime does
+ the right thing (but occasionally you may need to do it the other
+ way around).
+
+Q: Why are you going for a GtkHtml implementation?
+
+A: GtkHTML is just a lightweight HTML rendering engine that does not
+ support CSS, so we need it to look decent for those of us that will
+ be using the documentation in our day-to-day work on Linux. The
+ Web-based interfaces lack the agility that you get from a native GUI
+ tool to browse your documentation. Probably later on, we will write
+ scripts and generate a full documentation set that is web-browsable,
+ but we need a command-line and GUI tools that we can use natively on
+ Linux when disconnected from the Web (and that has better
+ interactions than a web page).
+
+Q: Is there a command-line tool that allows me to access .NET interactively?
+
+A: There are several but one that is free software and uses MCS is the one
+ Dennis Lu from Rice University is working on; a REPL C# interpreter.
+
+Q: Is it possible to use Visual C++ with Mono?.
+
+A: It's possible to run VC++ generated apps under Mono, but we do not
+ provide a Manager C++ compiler ourselves.
+
+<a name="problems"></a>
+** Mono Common Problems
+
+ If you are having problems compiling or running Mono software
+ or if you think that you found a bug, etc. Please visit the
+ <a href="http://geneura.ugr.es/~jaime/deploy/mono-common-problems.html">Mono Common Problems</a> document and try there.
+
projects / mono.git / blobdiff