[Mono-list] Update on tasks.

[Miguel de Icaza]

Hello!

   Various people have asked me how they can contribute to Mono.  I
have updated some parts of the web site to reflect a few more
projects, and I have included some pieces of the text from the web
site in this email so you dont have to go tracking down all the
information in the web.

   We have got roughly about 250 classes implemented, and about
another 30 on the queue of various contributors.  Three people have
mailed me thinking that we ran out of classes that need to be
implemented.  This might be due to the confusing column on the web
pages (which I am about to fix).

   For your hacking pleasure, I want to let everyone know that there
are probably more than 2000 classes on the .NET Beta2, and we have got
only a small size of that.  So basically, there is a lot to be done
;-)

   As I mentioned, the web site will be updated as soon as I go
online, in the meantime, for your hacking convenience, here is a list
of tasks:

** Runtime

	We need a verifier that can be run on an executable (assembly)
	and tells whether the metadata for the executable is correct
	or not.  It should report any anomalies.

	For a list of anomalies in assemblies, check the various assertions
	that are described on the ECMA documentation. 

	This will help test our generated executables and can be also
	used as an external verifier.

TODO=gtk,Gtk+ wrappers for Mono and .NET
		* Wrap the Gtk+ API.  This is simple and can be done
		  on Windows as Gtk+ 1.3 works on Windows.

	 	  This work can also be used on Windows and will
		  enable developers on Windows to use some of Gtk+'s
		  advanced features.

		  The idea is to wrap the Gtk+ API and allow us to
		  build GUI applications using Gtk+ and in the future
		  other Gtk+-based libraries from Mono (Gal, GtkHTML).

		  There is extensive knowledge on wrapping Gtk+ in
		  other languages (this has been done this for Perl,
		  Python, Java, Scheme, Haskel and other languages in
		  the past).

TODO=guavac,Java compiler for .NET
		* You could take one of the existing Java compilers
		  (Guavac comes to mind as it is so nice) and modify
		  it to generate .NET code rather than JVM byte
		  codes. 

		  This should be a pretty straightforward task.
		  Guavac has the advantage of being written in C++ and
		  it could be compiled with the Microsoft Managed C++
		  compiler and produce a .NET executable with it.

TODO=Bonobo,Bonobo for Mono
		* Once CORBA is done, implement the Bonobo interfaces
		  to allow people to use Bonobo components in Mono and
		  Mono components with Bonobo.  The best of both worlds!

TODO=moniker,Object Naming System with Monikers
		* A naming space for Mono.  An object naming space is
		  a very powerful tool.  Bonobo implements a moniker
		  system that is more powerful than the original
		  moniker concept that was pioneered by COM/OLE in the
		  Microsoft world.

		  Our implementation builds on a concept, and we have
		  made it simpler, more powerful, more extensible and
		  a much better mechanism than the equivalent monikers
		  on Windows. 

		  Implementing Mono monikers would benefit both
		  Windows users using .NET and Mono users on Unix and
		  Windows.  

		  Here is <a
		  href="http://primates.ximian.com/~miguel/monikers.html">an
		  overview of the moniker system</a> in Bonobo.

* Tools

	We need a number of tools to make people productive using a
	Mono-based solution.  Some of these tools can be developed on
	Windows before Mono is fully finished.

	All of these tools should be written using C#.  

	For the tools that are typically command line tools: Try to
	write these as components that could load their input from
	streams or collections of streams, and implement the command
	line tools as wrappers around those classes.

	For example, we will be making the C# compiler a component
	that could be reused by applications that might have a use for
	the various bits of the compiler (either to embed the
	compiler, or reuse the code generator part of it).  

	This is important so that these components (compiler,
	assembler, linker, etc) can be integrated later into the
	visual development environment (hopefully with the help of the
	SharpDevelop hackers). 

TODO=ilasm,IL Assembler
** IL Assembler.

	This assembler should basically take as input a file
	containing IL bytecodes as specified in the `Partition II' of
	the ECMA spec, and produce a binary file.

TODO=al,Assembly Linker
** Assembly Linker.

	This tool is used to construct assemblies, which are basically
	deployment units for CLI executables.

Best wishes,
Miguel.