path: root/NEWS

	* Sergey Chaban added thread-safe support to
	  System.Collections.SortedList.
	
	* Fixes to the compiler by Andrew Birkett.
	
	* Tim Coleman contributed the OleDb provider for System.Data and started
	  work on System.Web.Services.
	
	* Radek fixed a lot of problems on the PPC side. [*]
	
	* Miguel and Martin committed the new type lookup system.
	
	* Dietmar rewrote the marshalling code. [*]
	
	* Peter Williams and Martin contributed the new Makefiles, with help
	from Alp Toker as well.
	
* Contributors to this release:

	* Non-Ximian developers: Nick Drochak, Martin Baulig, Tim
	  Coleman, Mike Kestner, Alp Toker, Jonathan Pryor, Jaime
	  Anguiano, Piers Haken, Rafael Teixeira, Mark Crichton,
	  Sergey Chabon, Ajay Kumar Dwivedi, Andrew Birkett, Dennis
	  Hayes (SWF), Adam Treat, Johannes Roith and Lawrence Pit.

	* Ximian developers: Duncan, Ravi, Dick, Dietmar, Paolo,
	  Gonzalo, Rachel, Radek, Rodrigo, Jeff, Peter Williams and
	  Miguel.

Special thanks to Duncan for helping me put this release together.

Hello!

	A new version of Mono (0.12), is out.

	Mono is an open source implementation of the Microsoft.NET
	Framework, and ships with a C# compiler, a runtime engine
	(with a JIT on x86 cpus) and a set of class libraries.

	Mono is know to work on a number of platforms:
	x86/Linux, x86/Windows, x86/FreeBSD; sparc/solaris;
	linuxppc/linux; strongarm/linux.

	There have been many changes since the last release of Mono in
	late April, thanks to Duncan for assembling the list of new
	features, any omissions are my fault.

Changes since 0.11:

	It is hard to keep track of the changes, as there are 1632
	patches that were posted to the mailing list.  One third of
	the total number of patches since we opened mono-patches
	list.  I am sure I missed some stuff and probably missed some
	contributors.  I apologize in advance.

	Runtime:

		Paolo: New Reflection.Emit generation code generates
		code that can be executed in Windows.  Now binaries
		generated by Mono/MCS will run on Windows.

		Paolo got Activator.CreateInstance to work.

		Sergey's CPU-optimization for CPBLK.

		Many many bug fixes to the runtime from Dick, Dan
		Lewis, Dietmar, Gonzalo, Martin, Paolo, Radek and Sergey,

	Compiler:

		Many bug fixes: The compiler can now compile Gtk#,
		Vorbis#, System.Data assembly and System.Xml assembly
		which previously did not work (Dietmar, Miguel, Paolo,
		Piers, Ravi, Miguel).  Thanks to all the bug
		reporters.

	Class Libraries:

		Mike started work on System.Xml.XPath

		Christian, Dennis, Daniel and friends got more stubs
		for System.Windows.Forms in.

		Ajay revamped System.Xml.Schema.  And Jason and Duncan
		updated System.Xml

		Daniel also checked in a working CodeDOM
		implementation and a C# provider.

		Many bug fixes by everyone.  Thanks to Daniel, Duncan,
		Jonathan, Lawrence, Martin Mike, Nick and Piers.  I am
		missing a lot of contributors that should be listed.

	ASP.NET support

		A lot of work from Gonzalo allows some small and
		modest ASP.NET applications to run (you still need the
		unreleased XSP code though).

	System.Data:

		Integrated the MySQL provider from Brad Merryl.

		Lots of work by Dan, Rodrigo, Tim.

	Microsoft.VisualBasic runtime support

		Rafael and Chris have been working on the VisualBasic
		runtime support DLLs

Hello everyone!

	Mono 0.11 is out!

	This new version has new features:

	* Massive:

		* Ultrich Kunitz implemented the whole calendar set of
		  classes.  Yes, thats right.  The whole thing, with a
		  complete test suite.  Thanks Ultrich!

	* JIT/runtime features:

		* Martin's debugging framework is included (see web
		  site for details on how to use it). (Martin)

		* Transparent Proxy has been implemented for the
		  runtime (lets you run/debug/hack on remoting for Mono) (Dietmar)

		* Inline and constant folding/propagation support
		  in the JIT engine (Dietmar)

		* Profiling support for the JIT engine (--profile).

	* Cool runtime hacks, that made our compiler twice as fast:

		* New string rewrite: faster, speedier, leaner, cooler!

		  Paolo had been talking about a new string rewrite,
		  and super hacker Patrik Torstensson started the
		  implementation, Dietmar then switched the object
		  layout and the Mono team helped iron out a few of
		  the details.

		* New array reprensetation: Dan Lewis contributed a new
		  faster and smaller array implementation.

		* Improved Reflection.Emit: Paolo improved our
		  reflection emit code.

	* ADO.NET

		* Daniel Morgan, Rodrigo Moya have some pieces of the
		  Sql classes ready to run.  he first signs of life
		  this week (we can connect, insert rows; do transactions:
		  commit/rollback; SQL errors and exceptions work).

	* Http Runtime

		* The HTTP runtime (to be used by our ASP.NET implementation)
		  was contributed by Patrik Torstensson.  Patrik not only
		  contributed a massive ammount of classes, but he immediately
		  went on to implement ThreadPools and then helped out with the
		  new String rewrite.

	* XML improvements:

		* Kral Ferch and Duncan Mak contributed more
		  improvements to the XML implementation.

		* Work on Xml Serialization from John Donagher.
	
	* Documentation:

		* MonoDoc ships for the first time!
		  (John Barnette, Adam Treat and John Sohn)

		* New documentation stubs ready to be filled, and translated
		  included (thanks to our doc team!)

	* General fixes:

		* Piers Haken fixed many of our attributes and many
		  little problems that were exposed by his CorCompare tool

		* Many Mono C# compiler bug fixes.

	* Other improvements:

		* NUnit works on Linux! (Patrik Torstensson)

		* More NUnit tests (Nick Drochak)

		* Windows.Forms progress: Dennis Hayes and Christian
		  Meyer have been contributing stubs for the
		  Windows.Forms work.

		* Full Parse implementations and bug fixing by Gonzalo

		* Dan Lewis contributed some missing classes for the
		  Regexp implementation.

		* Jonathan's trace classes

* This Month's Mono is brought to you by:

	Adam Treat, Chris Podugriel, Christian Meyer, Daniel Lewis,
	Daniel Morgan, Dennis Hayes, Dick Porter, Dietmar Maurer,
	Duncan Mak, Guarav Vaish, Gonzalo Paniagua, Jaime Anguiano,
	Jason Diamond, Joe Shaw, John Barnette, John Donagher, John
	Sohn, Jonathan Pryor, Kral Ferch, Martin Baulig, Miguel de
	Icaza, Mike Kestner, Nick Drochak, Paolo Molaro, Patrik
	Tostensson, Piers Haken, Ravi Pratap, Rodrigo Moya, Sergey
	Chanben, Ultrich Kunitz, Wictor Wilen.

	I know that I missed some features, there is a lot of work
	that happens in a month.  I apologize in advance for any
	features I omited by accident.  

	Special thanks go to Duncan for helping out with all those
	little details in the project.  And also Nick who has been
	keeping us in good shape by maintaining and helping new
	contributors provide more test suites.

* Reporting bugs

	If you find a bug in Mono, please file a bug here:

		http://bugzilla.ximian.com

	That way we wont loose your bug report, and will be able to
	follow up properly with it.  Also try to provide simple test
	cases whenever possible and try as hard as possible to
	identify the root of a problem (compiler, runtime, class
	libraries).

* Forum

	The mono-list-request@ximian.com mailing list is open for
	those of you who want to discuss the future of Mono.

Hello everyone!  

  	Mono "Self Hosting" 0.10 is out!  (Alex insisted I used the
	<blink> tag for "Self Hosting", but was dissapointed when he
	realized most mailers dont support this).

	Too many things have happened since the the 0.9 release,
	almost an entire month.  The big news is that we are shipping
	a the self-hosting Mono C# compiler.  This has been tested on
	Linux/x86 only.

	Also, we delayed the release for one reason or other, but it
	turns out that as a extra bonus, Paolo fixed the last
	outstanding bug in the JIT engine, so the compiler now runs in
	the JIT engine instead of the interpreter.

	The mono-0.10 release includes the libraries required to run
	the compiler as well as assorted .NET programs [1].

* What is new

	There is so much stuff in this release that is hard to keep
	track of it.  

	Jason, Kral and Duncan have done an amazing job with
	System.Xml, up to the point that it is even being used by
	gtk-sharp's code generator (and it all comes with great test
	suites to verify that it works!).  Ajay's XmlSchema code is
	also shipped.

	Martin worked on our debugging infrastructure (the JIT can
	load dwarf files, and our class libraries now generate dwarf
	debugging info;  we are in the process of adding this to the
	compiler, the patch did not make it to this release though).

	For the first time the System.Web assembly has built without
	all the excludes, so you can get your hands on Gaurav and
	Lee's massive code base.

	Lots of new tests to the runtime, class libraries and compiler
	are included.  As always, big thanks go to Nick for continued
	guidance to new developers, and writing new tests.

	Dan removed the System.PAL dependency, we now have moved to an
	internalcall setup for all the System.IO calls, and dropped
	the MonoWrapper shared library.

	Porting wise: Sergey's StrongARM port is included now; Jeff's
	SPARC port and Radek's PowerPC port have been updated to
	reflect the new changes in the engine.

	Runtime wise: Dietmar also got us asyncronous delegates
	implemented.  Dick continues his work on our foundation
	classes, and has resumed his work on the IO layer.  

	Paolo is the hero behind self hosting on Linux.  Send your
	congrats (and wine) to him.

	And without the help from Mike, Duco, David, Piers, Nick,
	Sergey, Mark, Jonathan, John, Adam and Dennis this release
	would have not been possible.

	This release is mostly ECMA compatible.  I did not expect this
	to happen so soon.  I am very grateful to everyone who has
	made this happen

* The goods

	The runtime sources and binaries to the compiler/libraries:

		http://www.go-mono.com/archive/mono-0.10.tar.gz

	The class and compiler sources:

		http://www.go-mono.com/archive/mcs-0.10.tar.gz

* Requirements:

	You still need glib-2, and pkg-config.  If you plan on
	compiling large applications, getting the Boehm GC is a plus
	(we will integrate this in a future version, for now it is an
	external requirement).

	Boehm GC is available in packaged format for Debian and Red
	Hat systems.

* To compile on Linux

	Do your regular chores with mono-0.10.tar.gz, you know the
	drill.  In the end, after you reach the `make install' phase,
	now you can do some cool stuff.

	If you want to compile the compiler (just to try it out),
	untar the sources to the compiler (mcs-0.10.tar.gz) and do
	manually:
	
		cd mcs-0.10
		(cd jay; make)
		(cd mcs; make monomcs)

	Now you will end up with a nice mcs4.exe in the mcs/mcs
	directory, that is the compiler.  If you want to use that,
	replace the mcs.exe we distribute with the mcs4.exe you got.

* Gadgets

	Man pages for mcs, mono and mint are included for your
	enjoyment.  

	Particularly of interest is `mint --profile' which is awesome
	to profile your application, the output is very useful.

	Also, if you want to impress your friends, you might want to
	run the JIT with the `-d' flag, that shows you how the JITer
	compiles the code (and shows the basic blocks and the forst of
	trees as it goes).

* Next steps

	More classes are missing.  These are required so we can run
	nant and nunit natively.  Once we achieve that, we will be
	able to ship a complete environment that compiles on Linux.
	
	Currently our makefiles still use csc, as we still need
	nunit/nant to work.

[1] Of course, .NET programs that try to use classes we have not yet
implemented, will be left wondering `why did this happen to me?'.  

Hello!

	I have just uploaded Mono 0.9 to the web server, you can get
	the goodies here:

		http://www.go-mono.com/archive/mono-0.9.tar.gz
		http://www.go-mono.com/archive/mcs-0.9.tar.gz

	mono-0.9.tar.gz contains the source code to the runtime (JIT
	and interpreter) as well as a pre-compiled version of the
	compiler (mcs.exe) and the class libraries.

	To compile the compiler and the class libraries, you still
	need Windows with the .NET SDK, as our runtime can not host
	the compiler completely yet.

* Improved Build System

	You can check http://www.go-mono.com/download.html for the
	new and fresh compilation instructions.  Same requirements as
	the last version (pkg-config, glib 1.3.xx need to be
	installed). 

* What is new:

	Compiler can compile about 75% of our regression test suite
	on Linux.  Most of this work is on the class libraries and
	Paolo has been the magician behind the work here.

	JIT can run the compiler now (Dietmar)
	
	Mint works on Windows now (Dick).

	Application Domains have been implemented (Dietmar)

		* Two modes of operation are available, depending on
		  your needs: share code, or maximize speed (does not
		  share code).  This is described by the the
		  LoaderOptimization enumeration in .NET.

	Corlib no longer has references to mscorlib (Daniel Lewis)

	Ports:
		PowerPC has been updated (Radek Doulik)
		New SPARC port (Jeffrey Stedfast)

	Documentation system:
		Adam Treat has been working on finishing the Doctools
		to maintain the Mono class library documentation.  We
		still need a GUI editor though.

	Tracking progress:
		Nick's new tools to track progress are included in
		this release.

	Many new more regression tests for the class library
		(David Brandt, Mark Crichton, Nick Drochak, Bob Doan,
		 Duco Fijma).

	Lots of new code:
		Gaurav Vaish (the hacking god behind System.Web),
		Chris Podugriel (System.Data) and Mark Crichton (Crypto)

	Runtime:
		Socket layer is finished (Dick Porter)

	Compiler has full support for unsafe code now (Miguel)
		Still a few things missing: constant folding is not 
		finished everywhere and access permissions are not
		enforced yet.
	
	Many many many bug fixes everywhere from everyone on the team:

		Paolo Molaro, Daniel Lewis, Daniel Stodden, Dietmar
		Maurer, Jeff Stedfast, Nick Drochak, Duco Fijma, Ravi Pratap,
		Dick Porter, Duncan Mak, Jeff Stedfast and Miguel de Icaza.

	I am sorry if I left a major component out of the
	announcement, this were some intense 11 days of work.

* What is obviously missing

	Currently our System.Reflection.Emit is lacking array and
	pointer support, which is why many programs still do not
	compile, but this should be taken care of next week.

* How can you help

	There are many ways to help the project, check the details
	documentation in:

		http://www.go-mono.com/contributing.html

	You might also want to stop by our IRC channel on
	irc.gnome.org, channel #mono if you are interested in
	contributing.

Have a happy weekend!
Miguel.

Hey guys!

   Mono 0.7 has been released. 

   It has been a long time since the last release of Mono (almost
three weeks).  We have made an incredible ammount of work in the past
three weeks.  

* Highlights of this release:

	* The monoburg: BURS-instruction selector implemented (for our
	  portable JIT engine).

	* JIT engine works for very simple programs (Fibonacci works
	  for instance).  It is about 30% faster running than the
	  equivalent code compiled with Kaffe.

	  The interesting part is that this was accomplished with the
	  a minimum register allocator, and very simple monoburg
	  rules, so there is a *lot* of room to improve here.

	* The Interpreter has madured a lot.  Value Types are fully
	  supported now;  We dropped the FFI dependency, as we now
	  have our own code generator.

	* The runtime has been expanded and extended as to support
	  real file I/O (including console I/O).  So Hello World works
	  in there. 

	* The compiler can generate code for most statements now; It
	  also performs semantic analysis on most expressions.
	  Creation of new objects is supported, access to parameters,
	  fields and local variables works.  Method invocation works.
	  Implicit type conversions, assignments and much more.

	  Operator overloading is implemented, but broken on this
	  release, hopefully this will be fixed soon.

	  Delegates and Attributes are now declared and passed around,
	  but no code generation for those exist yet.

	* More classes (look for details).  Sergey and Paolo have been
	  working on various classes in System.Reflection.Emit to get
	  the compiler self-hosting.

	* NUnit is now part of the distribution, so it should be
	  trivial to write test cases (and if you want to help out,
	  this is one way to do it, we really need more tests cases).

    I am going to try to switch to Nick's JB for C# this week or next
week.  But the excitement of having the compiler deal with real C#
programs is too much to be contained, and I can not keep my hands of
the code generation in the compiler.

* Availability:

	  http://www.go-mono.com/archive/mono-0.7.tar.gz
	  http://www.go-mono.com/archive/mcs-0.7.tar.gz

* Details

  Class Library Changes:

  Many enumerations have been revamped to have the same value
definitions as those in .NET as those cause problems.  They were also
missing the [Flags] attributes, so we got that right too. 

    * System
	  SerializableAttribute impl			 (Miguel)
	  String updates                                 (Jeff)
	  System.Char					 (Ravi)

    * System.Configuration
	  ConfigurationSettings impl                     (Christopher Podurgiel)
	  SingleTagSectionHandler impl                   (Christopher Podurgiel)
	  DictionarySectionHandler impl                  (Christopher Podurgiel)

    * System.Collections.Specialized
	  NameObjectCollectionBase impl			 (Nick Drochak)

    * System.Diagnostics
	  StackFrame stubs				 (alexk)
	  StackTrace stubs				 (alexk)

    * System.IO
	  File stubs                                     (Jim Richardson)
	  IOException impl                               (Paolo)	
	  StreamWriter impl				 (Dietmar)
	  StreamReader stubs				 (Dietmar)

    * System.Net
	  ConnectionModes				 (Miguel)
	  ProxyUseType					 (Miguel)
	  WebStatus					 (Miguel)

    * System.Reflection
	  Assembly (stubs)				 (Paolo)
	  MethodBase					 (Paolo)
	  MethodInfo					 (Paolo)

    * System.Reflection.Emit
	  EventToken					 (Sergey)
	  FieldToken					 (Sergey)
	  FlowControl					 (Sergey)
	  ILGenerator (stubbed)				 (Paolo)
	  Label 					 (Paolo)
	  MethodToken					 (Sergey)
	  OpCode.cs					 (Sergey)
	  OpCodeType					 (Sergey)
	  OpCodes.cs					 (Sergey)
	  OperandType					 (Sergey)
	  PEFileKinds					 (Paolo)
	  PackingSize					 (Sergey)
	  ParameterToken				 (Sergey)
	  PropertyToken					 (Sergey)
	  SignatureToken				 (Sergey)
	  StackBehaviour				 (Sergey)
	  StringToken					 (Sergey)
	  TypeToken					 (Sergey)

    * System.Threading

	  Most classes stubbed out by Dick Porter        (Dick)

    * System.Web
	  HttpWorkerRequest stubs			 (Bob Smith)

    * System.Web.Hosting				 (Bob Smith)
	  AppDomainFactory stubs			 (Bob Smith)
	  ApplicationHost stubs				 (Bob Smith)
	  IAppDomainFactory stubs			 (Bob Smith)
	  IISAPIRuntime	stubs				 (Bob Smith)
	  ISAPIRuntime stubs				 (Bob Smith)
	  SimpleWorkerRequest stubs			 (Bob Smith)

    * System.Web.UI
	  LiteralControl implemented                     (Bob Smith)
	  HtmlContainerControl bugfixes                  (Bob Smith)
	  BuildMethod 
	  BuildTemplateMethod 
	  HtmlTextWriterAttribute 
	  HtmlTextWriterStyle 
	  HtmlTextWriterTag 
	  IAttributeAccessor 
	  IDataBindingsAccessor 
	  INamingContainer 
	  IParserAccessor 
	  IPostBackDataHandler 
	  IPostBackEventHandler 
	  IStateManager 
	  ITagNameToTypeMapper 
	  ITemplate 
	  IValidator 
	  ImageClickEventHandler 
	  OutputCacheLocation 
	  PersistanceMode 
	  StateItem 

    * System.Web.UI.HtmlControls
	  HtmlAnchor impl				 (Leen Teolen)
	  HtmlTextArea impl				 (Leen Teolen)

    * System.Web.UI.WebControls
	  WebControl.cs                                  (Gaurav Vaish)

    * System.XML
	  Lots of enumerations				 (Miguel)
	  (will add later)

    * Add loads of enumerations throughout 		 (Sergey)
      (will add later)

Compiler Changes:

    * Assignment					 (Miguel)

    * expression semantic analysis			 (Miguel)

    * constructor creation, chaining			 (Miguel)

    * Unified error reporting                            (Ravi)

    * initial attribute support				 (Ravi)

    * calling convention support                         (Miguel)

    * loop construct code generation                     (Miguel)

    * conditional statement code generation		 (Miguel)

    * indexer declarations				 (Ravi)

    * event declarations				 (Ravi)

    * try/catch parsing fixed				 (Ravi)

    * initial delegate support				 (Ravi)

    * operator overload                                  (Ravi)

Tools Changes:

    * Add NUnit windows binaries to distribution	 (Nick Drochak, Miguel)

Runtime Changes:

    * First JIT implementation                           (Dietmar, Paolo)

    * value type size calculation                        (Dietmar)

    * full value type support                            (Paolo)

    * frequently used types cache                        (Paolo)

    * FileStream support				 (Paolo)

    * Console input/output support			 (Dietmar)

    * print arguments and exception name in stack trace  (Paolo)

    * beginnings of virtual call support                 (Paolo)

    * reimplement pinvoke support			 (Dietmar)

    * remove libffi dependency				 (Dietmar)

    * IBURG code generator implementation		 (Dietmar)

    * new opcodes implemented: starg.s, ldobj, isinst,   (Paolo, Miguel)
      ldarg, starg, ldloc, ldloca, stloc, initobj, 
      cpblk, sizeof, conv.i, conv.i1, conv.i2, conv.i4, 
      conv.i8, conv.u1, conv.u2, conv.u4, conv.r4, 
      conv.r8, ldelema, ceq, cgt, clt.

* This list

    Parts of this list of features were compiled by Alex by following
the CVS mailing list.  My deepest thanks to Alex for helping me out
with this.  I want to apologize for the missing features that I did
not document here, Mono is moving too fast to keep track of all the
changes. 

2002-Feb-11 Miguel de Icaza  <miguel@ximian.com>

	New release, functional x86-JIT, x86 interpreter, ppc interpreter 

	Class libraries ship.

	Limited compiler ships.

	Too many changes to list

2001-07-12  Miguel de Icaza  <miguel@ximian.com>

	New XSLT file from Sergey Chaban for CIL opcodes

	Paolo got the beginning of an interpreter in.

	Further work on the dissasembler.

	Fix various parts of the metadata library

2001-05-30  Miguel de Icaza  <miguel@ximian.com>

	Project started