-Q: .NET is evil, it will give Microsoft too much control over every desktop?
-Q: If you implement .NET, wont I depend on Microsoft Passport to run my software?
+<a href="#basics">Basics</a><br>
+<a href="#ximian">The Ximian Role in the Mono project</a><br>
+<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="#portability">Portability</a><br>
+<a href="#reuse">Reusing Existing Code</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: You are a bit confused. It is easy to be confused, as Microsoft
- has been naming anything they have produced recently with `.NET'.
+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: So what are you doing with .NET?
+Q: What is Mono exactly?
-A: We are implementing the .NET Framework: a new development platform
- specified by Microsoft. It contains a number of components:
+A: The Mono Project is an open development initiative sponsored by
+ Ximian that is working to develop an open source, Unix
+ version of the Microsoft .NET development platform. Its objective
+ 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.
- * A Common Language Runtime (CLR) system that contains a class loader,
- Just-in-time compiler, and a garbage collection aware
- runtime.
+Q: What is the difference between Mono and the .NET Initiative?
- * A .NET-compatible class library.
+A: The ".NET Initiative" is a somewhat nebulous company-wide effort by
+ Microsoft, one part of which is a cross-platform development
+ 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 re-branding.
- * A compiler for the C# language, in the future we might work
- on other compilers that target .NET.
+Q: What technologies are included in Mono?
+
+A: Mono contains a number of components useful for building new
+ software:
+
+ <ul>
+ * A Common Language Infrastructure (CLI) virtual
+ machine that contains a class loader, Just-in-time
+ compiler, and a garbage collecting runtime.
+
+ * A class library that can work with any language
+ which works on the CLR.
+
+ * A compiler for the C# language. In the future we
+ might work on other compilers that target the Common
+ Language Runtime.
+ </ul>
+
+
+ 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, Perl, Python, Scheme,
+ Smalltalk, Standard ML, Haskell, Mercury and Oberon.
The CLR and the Common Type System (CTS) enables applications and
libraries to be written in a collection of different languages that
- target the byte code
+ target the byte code
+
+ This means for example that if you define a class to do algebraic
+ manipulation in C#, that class can be reused from any other
+ language that supports the CLI. You could create a class in C#,
+ subclass it in C++ and instantiate it in an Eiffel program.
+
+ A single object system, threading system, class libraries, and
+ garbage collection system can be shared across all these languages.
+
+Q: Where can I find the specification for these technologies?
+
+A: You can find the information here:
+
+
+ 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?
+
+A: Yes, we will be implementing the APIs of 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 inter-operating
+ with the Microsoft SDK, but we will also offer an ECMA compliant
+ set of libraries.
+
+Q: What does the name "Mono" mean?
+
+A: Mono is the word for `monkey' in Spanish. We like monkeys.
+
+Q: Is Mono usable?
+
+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 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: 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?
+
+A: Check the <a href="contributing.html">contributing</a> section.
+
+Q: Aren't you just copying someone else's work?
+
+A: We are interested in providing the best tools for programmers to
+ develop applications for Free Operating Systems. We also want to help
+ provide the interoperability that will allow those systems to fit in
+ with other standards.
+
+ For more background, read the <a href="http://www.go-mono.com/rationale.html">Mono
+ 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>
+
+** The Ximian Role in the Mono Project
+
+Q: Why is Ximian working on .NET?
+
+A: Ximian is interested in providing the best tools for programmers to
+ develop applications for Free Operating Systems.
+
+ For more information, read the project <a
+ href="rationale.html">rationale</a> page.
+
+Q: Will Ximian be able to take on a project of this size?
+
+A: Of course not. Ximian a supporter of the Mono project, but the only way
+ to implement something of this size is for the entire free software
+ community to get involved. Visit the <a href="contributing.html">contributing</a>
+ page if you'd like to help out.
+
+Q: What pieces will Ximian be working on?
+
+A: We will devote most of our resources to work on the pieces which are
+ on the critical path to release a development and execution
+ environment. Once the project is at a stage where it is useful in
+ the real world, it will achieve a critical mass of developers to
+ improve it further.
+
+Q: Will Ximian offer Mono commercially?
+
+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
+ time line will be available in June 2002.
+
+<a name="gnome"></a>
+** Mono and GNOME
+
+Q: How is Mono related to GNOME?
+
+A: In a number of ways. This project was born out of the need of
+ providing improved tools for the GNOME community, and will use
+ existing components that have been developed for GNOME when they
+ are available. For example, we plan to use Gtk+ and Libart to
+ implement Winforms and the Drawing2D API and are considering
+ GObject support.
+
+Q: Has the GNOME Foundation or the GNOME team adopted Mono?
+
+A: Mono is too new to be adopted by those groups. We hope that the
+ tools that we will provide will be adopted by free software
+ programmers including the GNOME Foundation members and the GNOME
+ project generally.
+
+Q: Should GNOME programmers switch over to Mono now?
+
+A: It is still far to early for discussions of "switching over." No
+ pieces of Mono will be ready within the next six months, and a
+ complete implementation is roughly one year away.
+
+ 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 "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 provide a set of classes for implementing and using
+ Bonobo components from within Mono. Mono should allow you to write
+ Bonobo components more easily, just like .NET on Windows allows you
+ to export .NET components to COM.
+
+Q: Does Mono depend on GNOME?
+
+A: No, Mono does not depend on GNOME. We use a few packages produced by
+ the GNOME team like the `glib' library.
+
+Q: But will I be able to build GNOME applications?
+
+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# API.
+
+Q: What is the difference between Gtk# and System.Windows.Forms?
+
+A: Gtk# is a set of bindings for the Gtk+ toolkit for C# (and other
+ CIL-enabled languages). System.Windows.Forms is an API defined
+ by Microsoft to build GUI applications.
+
+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: 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 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.
+
+Q: Do you fear that Microsoft will change the spec and render Mono
+ useless?
+
+A: No. Microsoft proved with the CLI and the C# language that it was
+ possible to create a powerful foundation for many languages to
+ 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.
+
+Q: Are you writing Mono from the ECMA specs?
+
+A: Yes, we are writing them from the ECMA specs and the published
+ materials in print about .NET.
+
+Q: If my applications use Mono, will I have to pay a service fee?
+
+A: No. Mono is not related to Microsoft's initiative of
+ software-as-a-service.
+
+Q: Is the Mono Project is related to the Microsoft Hailstorm effort? Is
+ Ximian endorsing Hailstorm?
+
+A: No. The Mono Project is focused on providing a compatible set of
+ tools for the Microsoft .NET development platform. It does not
+ address, require, or otherwise endorse the MS Passport-based
+ Hailstorm single sign-on system that is part of Windows XP and
+ other services.
+
+Q: Will Mono or .NET applications depend on Microsoft Passport?
+
+A: No. MS Passport is unrelated to running .NET compatible applications
+ produced with the Mono tools. The only thing you will need is a
+ just-in-time compiler (JIT).
+
+Q: What is a 100% .NET application?
+
+A: A `100% .NET application' is one that only uses the APIs defined
+ under the System namespace and does not use PInvoke. These
+ applications would in theory run unmodified on Windows, Linux,
+ HP-UX, Solaris, MacOS X and others.
+
+Q: If Microsoft will release a port of their .NET platform under the
+ `Shared Source' license, why should I bother with anything else?
+
+A: The Shared Source implementation will be expensive and its uses
+ will be tightly restricted, especially for commercial use. We are
+ working towards an implementation that will grant a number of
+ important rights to recipients: use for any purpose,
+ redistribution, modification, and redistribution of modifications.
+
+ This is what we call <a
+ href="http://www.gnu.org/philosophy/free-sw.html">Free Software</a>
+
+Q: Is Mono a free implementation of Passport?
+
+A: No. Mono is just a runtime, a compiler and a set of class
+ libraries.
+
+Q: Will the System.Web.Security.PassportIdentity class mean
+ that my software will depend on Passport?
+
+A: No. Applications may use that API to contact a Passport site, but
+ are not required to do so.
+
+ As long as your application does not use Passport, you will not
+ need Passport.
+
+Q: Will Mono running on Linux make Passport available for Linux?
+
+A: No. However, the Passport toolkit for Linux-based web servers is
+ available from Microsoft.
+
+Q: Will Mono allow me to run Microsoft Office on Linux?
+
+A: No, it will not. Microsoft Office is a Windows application. To
+ 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
+
+Q: What are the differences between 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).
+
+ It is easier to describe what is unique about Mono:
+ <ul>
+ <li> A Just-in-Time compiler engine. This is important for
+ making your applications fast.
+
+ <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.
+
+ <li> Supports Linux, Windows and Solaris at this point.
+
+ <li> The JIT engine is written using a portable instruction
+ selector which not only generates good code (we are told
+ that we are faster than Rotor, but it is hard to tell) but
+ is also the foundation to re-target the JIT engine to other
+ systems.
+
+ The system employed is described in various compiler
+ books and it is very similar to what is described in the
+ book that covers LCC, the ANSI C retargetable C compiler.
+
+ <li> The JIT engine supports in-lining, constant folding and propagation,
+
+ <li> Full support for remoting in the runtime, but the class
+ libraries are still behind.
+
+ <li> The C# compiler, the JIT engine and the class libraries are
+ mature enough that the whole system is self-hosting. This means that
+ we develop Mono completely with itself at this point.
+
+ <li> We are not yet done, and there is a lot of work left to be
+ done
+
+ <li> We have a great community of developers, without which Mono
+ would not be possible.
+
+ <li> We are working on an ahead of time compilation mode to
+ pre-compile code for the target architecture (this is part
+ of our new code generation effort).
+ </ul>
+
+<a name="webservices"></a>
+** Web Services
+
+Q: How is Mono related to Web Services?
+
+A: Mono is only related to Web Services in that it will implement the
+ same set of classes that have been authored in the .NET Framework
+ to simplify and streamline the process of building Web Services.
+
+ But most importantly, Mono is an Open Source implementation of the
+ .NET Framework.
+
+Q: Can I author Web Services with Mono?
+
+A: You will be able to write Web Services on .NET that run on Mono and
+ vice-versa.
+
+Q: If Mono implements the SDK classes, will I be able to write and
+ execute .NET Web Services with it?
+
+A: Yes. When the project is finished, you will be able to use the
+ same technologies that are available through the .NET Framework SDK
+ on Windows to write Web Services.
+
+Q: What about Soup? Can I use Soup without Mono?
+
+A: Soup is a library for GNOME applications to create SOAP servers and
+ SOAP clients, and can be used without Mono. You can browse the
+ source code for soup using <a
+ href="http://cvs.gnome.org/bonsai">GNOME's Bonsai</a>.
+
+Q: Can I use CORBA?
+
+A: Yes. The CLI contains enough information about a class that
+ exposing it to other RPC systems (like CORBA) is really simple, and
+ does not even require support from an object.
+
+ <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.
+
+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 editor and viewer. Currently, MonoDoc
+ consists of a Gtk# application and is in heavy development. There is also a
+ Qt# version of it.
+
+
+<a name="devel"></a>
+** Development Tools and Issues
+
+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 integrate with their applications if
+ they wish to do so.
+
+Q: Will you have new development tools?
+
+A: With any luck, Free Software enthusiasts will contribute tools to
+ improve the developer environment. These tools could be developed
+ initially using the Microsoft implementation of the CLI and then
+ executed later with Mono.
+
+Q: What kind of rules make the Common Intermediate Language useful for
+ JITers?
+
+A: The main rule is that the stack in the CLI is not a general purpose
+ stack. You are not allowed to use it for other purposes than
+ computing values and passing arguments to functions or return
+ values.
+
+ At any given call or return instruction, the types on the stack
+ have to be the same independently of the flow of execution of your
+ code.
+
+Q: Is it true that the CIL is ideal for JITing and not efficient for
+ interpreters?
+
+A: The CIL is better suited to be JITed than JVM byte codes, but you
+ 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
+
+Q: Why don't you use Java? After all, there are many languages that
+ target the Java VM.
+
+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">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;
+ Intel also has a Java VM called <a
+ href="http://www.intel.com/research/mrl/orp">ORP</a>.
+
+ The JVM is not designed to be a general purpose virtual machine.
+ The Common Intermediate Language (CIL), on the other hand, is
+ designed to be a target for a
+ wide variety of programming languages, and has a set of rules
+ designed to be optimal for JITers.
+
+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.
+
+ Microsoft has an implementation of the Java language called J# that
+ can target the CIL execution engine.
+
+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>
+
+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. Eto Demerzal has started a Rhino port to C#.
+ After this is completed, we will begin developing
+ the JavaScript compiler.
+
+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
+
+Q: Would you allow other classes other than those in the
+ specification?
+
+A: Yes. The Microsoft class collection is very big, but it is by no
+ means complete. It would be nice to have a port of `Camel' (the
+ Mail API used by Evolution inspired by Java Mail) for Mono
+ applications.
+
+ You might also want to look into implementing CORBA for Mono. Not
+ only because it would be useful, but because it sounds like a fun
+ thing to do, given the fact that the CLI is such a type rich
+ system.
+
+ For more information on extending Mono, see our <a
+ href="ideas.html">ideas</a> page.
+
+Q: Do you plan to Embrace and Extend .NET?
+
+A: Embracing a good technology is good. Extending technologies in
+ incompatible ways is bad for the users, so we do not plan on
+ extending the technologies.
+
+ 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.
+
+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.
+
+
+<a name="portability"></a>
+** Portability
+
+Q: Will Mono only work on Linux?
+
+A: Currently, we are doing our work on Linux-based systems and
+ 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 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 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: 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: 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?
+
+A: It will depend only if you are using a particular assembly (for
+ example, for doing GUI applications). If you are just interested
+ 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
+
+Q: What projects will you reuse or build upon?
+
+A: We want to get Mono in the hands of programmers soon. We are
+ interested in reusing existing open source software.
+
+Q: What about Intel's research JIT framework, ORP?
+
+A: At this time, we are investigating whether we can use elements of
+ ORP for Mono. ORP is a research JIT engine that has a clearly
+ 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 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 back-end that will
+ generate CIL images? What about making a front-end to GCC that
+ takes CIL images and generates native code?
+
+A: We are currently seeking volunteers for those projects.
+ Visit the <a href="contributing.html">contributing</a> section if
+ you are interested.
+
+Q: But would this work around the GPL in the GCC compiler and allow
+ people to work on non-free front-ends?
+
+A: People can already do this by targeting the JVM byte codes (there
+ are about 130 compilers for various languages that target the JVM).
+
+Q: Why are you writing a JIT engine instead of a front-end to GCC?
+
+A: We want the JIT engine and runtime engine because they will be able
+ to execute CIL executables generated on Windows, and so no recompilation
+ will be necessary.
+
+<a name="performance"></a>
+** Performance
+
+Q: How fast will Mono be?
+
+A: We can not predict the future, but a conservative estimate is that
+ it would be at least `as fast as other JIT engines'.
+
+ We would like to ship various JIT engines with Mono, just like
+ Microsoft has done with their .NET development platform. We could
+ provide a faster, JIT for fast load times but lower performance,
+ and an and an optimizing JIT that would be slower at generating
+ code but produce more optimal output.
+
+ The CIL has some advantages over the Java byte code: it is really
+ an intermediate representation and there are a number of
+ restrictions on how you can emit CIL code that simplify creating
+ better JIT engines.
+
+ For example, on the CIL, the stack is not really an abstraction
+ available for the code generator to use at will. Rather, it is a
+ way of creating a postfix representation of the parsed tree. At
+ any given call point or return point, the contents of the stack are
+ expected to contain the same object types independently of how the
+ instruction was reached.
+
+<a name="licensing"></a>
+** Licensing
+
+Q: Will I be able to write proprietary applications that run with
+ Mono?
+
+A: Yes. The licensing scheme is planned to allow proprietary
+ developers to write applications with Mono.
+
+Q: What license or licenses are you using for the Mono Project?
+
+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.
+
+ 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.
+
+ For licensing details, contact <a
+ href="mailto:mono-licensing@ximian.com">mono-licensing@ximian.com</a>
+
+
+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 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: No. First, its basic functional capabilities have pre-existed too
+ long to be held up by patents. The basic components of Mono are
+ technologically equivalent to Sun's Java technology, which has been
+ around for years.
+
+ Mono will also implement multi-language and
+ multi-architecture support, but there are previous technologies
+ such as UCSD p-code and ANDF that also support multiple languages
+ using a common intermediate language. The libraries are similar
+ to other language's libraries, so again, they're too similar to
+ be patentable in large measure.
+
+ However, if Microsoft does patent some technology, then our plan is
+ to either (1) work around it, (2) chop out patented pieces, (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.
+
+ There is also a statement from Jim Miller at Microsoft, one of the
+ inventors listed in the patent: <a href="https://mailserver.di.unipi.it/pipermail/dotnet-sscli/msg00218.html">here</a>.
+
+ For Linux desktop use, we only need the ECMA components, and things that
+ we have developed (like Gtk#).
+
+<a name="etc"></a>
+** Miscellaneous Questions
+
+Q: You say that the CLI allows multiple languages to execute on the
+ same environment. Isn't this the purpose of CORBA?
+
+A: The key difference between CORBA (and COM) and the CLI is that 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 data types that someone
+ else provides, without having to go via their interfaces. It also
+ 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 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: Well, It's possible to run VC++ generated apps under Mono though.
+
+<a name="problems"></a>
+** Mono Common Problems
- multiple languages to share the same code
- (through the CLS specification
+ 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.
-Q:
-A:
\ No newline at end of file