Add NEWS file

[mono.git] / NEWS

Hello everyone!

    The Mono Team introduces the best Mono release so far we have
done.  Thanks to everyone who contributed fixes, code, ideas, and bug
reports.  

    Mono 0.20 has been released, it is available at the usual location:

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

    This is a truly heroic release of Mono.  Major architectural
chunks that were missing, or were miss-implemented have been fixed in
this release, and we are very proud of it.  Please see the list of
features, because there is no short way of introducing just how good
this release is.  A big thanks goes to Piers for setting up a
Tinderbox that monitors problems with the Mono CVS repository.

    We released packages for SuSE 8.0, Mandrake 8.2, and various
Red Hat releases.  It is also available from Red Carpet on the Mono
channel.

   Source code for Mono, MCS, the Mono Debugger, XSP is available as
well from that web page.  The sources are:

     MCS package (Class Libraries, C# and VB.NET compiler and managed tools):

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

     Mono package (Runtime engine, JIT compiler):

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

     XSP package (XSP test web server for ASP.NET webforms):

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

    This release is brought to you by: Alvaro del Castillo, Alan Tam,
Alp Toker, Alejandro Sánchez, Alexandre Pigolkin, Atsushi Enomoto,
Brian Ritchie, Christopher Bockner, Daniel Lopez, Daniel Morgan,
Dennis Hayes, Dick Porter, Dietmar Maurer, Duncan Mak, Gaurav Vaish,
Gonzalo Paniagua, Jackson Harper, Jaime Anguiano, Jeff Stedfast,
Johannes Roith, John Sohn, Jonathan Pryor, "Lee Mallabone, "Lluis
Sanchez, "Marco Ridoni, Mark Crichton, Martin Baulig, Martin Willemoes
Hansen, Miguel de Icaza, Mike Kestner, Nick Drochak, Paolo Molaro,
Patrik Torstensson, Pedro Martinez, Per Arneng, Peter Williams, Petr
Danecek, Piers Haken, Radek Doulik, Rafael Teixeira, Rodrigo Moya,
Sebastien Pouliot, Tim Coleman, Ville Palo, and Zoltan Varga.

   They commited 1810 changes to CVS patches in the past 33 days.

* New in this release

      * Zoltan and IKVM

        Zoltan's patches to run Jeroen's IKVM (the Java VM that
        translates JVM bytecodes into .NET bytecodes) are in.  

      * Remoting.

        The remoting team's patches that were held off on the previous
        release are here.  Lluis and Patrik have done a fantastic job
        in getting remoting to work.  Many low-level runtime engine
        changes, and plenty of work on the class-library stuff.
        
        Lluis has posted a couple of sample applications to the
        mailing list, you can try those out.

        The new release includes a working BinaryFormatter and
        BinaryFormatterSink.  It means that together with TcpChannel
        it is possible to make remote calls with any type of
        parameters and return values, including value types,
        MarshalByRefObject types (that are properly
        marshalled/unmarshalled), delegates, enums, etc.

        RemotingConfiguration is partially implemented. It cannot read
        from config files, but manual configuration using the api is
        fully working.

        Implemented full support for client activated types and for
        well known objects (both singleton and single call).

        Lease manager fully working (it manages the lifetime of server
        objects).

        Implemented interception of the new operator, so it is
        possible to create a remote object using "new", if the type is
        properly registered in RemotingConfiguration.

        In Lluis' words: `Basically, 0.20 will have almost all needed
        for a distributed application with Remoting'

      * New threading semantics, IO-layer

        Dick Porter in a couple of weeks has heroically redone much of
        the threading support to match the .NET behavior (details are
        on the .NET threading book as posted on the Mono site).

        He also did a lot of bug fixes in the IO/threading space.  The
        threading implementation now contains a new and faster Monitor
        implementation, as well as a correct Pulse()/Wait()
        implementation. 

        GC thread finalization has been re-enabled.  This means that
        finalizers will be ran on a separate thread, as done in the
        Microsoft.NET Framework.  This might expose some bugs on
        existing finalizer code.

      * Moved to NUnit2

        Nick and Gonzalo helped us move to the new NUnit2 platform for 
        all of our tests.   A big applause goes to them.

     * Cross Appdomain invocations work now.

        ASP.NET and NUnit2 both used cross appdomain invocations, we
        have fixed a number of problems, and they are now functional.

        The AppDomain fixes and the Remoting fixes have allowed us to
        remove a number of hacks in the ASP.NET implementation that
        were previously there.

        Implemented CrossAppDomainChannel, for calls between domains.

     * C# Compiler and Debugging.

        When generating debugging information in the compiler (with
        -debug, -g or -debug+) the compiler will embed the debugging
        information into the resulting executable instead of
        generating a separate file.  Very nice.

        Generating debugging information has also improved vastly
        performance-wise, and now it is possible to always use
        debugging builds for software development.

        A number of bugs were fixed on the compiler as well and
        by using the Mono profiler we have reduced the memory
        consumption and accelerated the compiler.

        Thanks to Jackson, Martin, Paolo and for helping here.

      * VB.NET Compiler.

        Plenty of new features are included in the compiler in our
        path to conformance.  See <FIXME:get-url-for-posting> for
        details on the status of the compiler, and the pieces missing.

      * ILasm and Mono.PEToolkit.

        Work on the IL assembler has resumed, but it is not yet ready
        for production use.  The Mono IL Assembler uses the
        Mono.PEToolkit library done by Sergey and Jackson to
        manipulate CIL image files.

      * Cryptographic work.

        Sebastien has provided a cert2spc and secutil tools for
        certificate management.  This is the first release that ships
        an assembly for System.Security

        Also a new internal assembly used only on Windows allows Mono
        users to use the unmanaged crypto providers.

      * System.XML

        Atsushi has continued to improve the work on our XML
        implementation: fixing bugs and more closely matching the
        Microsoft implementation.

      * More PowerPC/Alpha support.

        Taylor Christopher has contributed more code generation macros
        for PPC and Laramie Leavitt for Alpha.

      * System.XML.Xsl

        Gonzalo continued the implementation of our XSLT transformation
        API (custom .NET functions are still missing though).  It no
        longer uses temporary files to apply transformations.  Thanks
        to an idea from Zdravko Tashev.  Xslt Web controls work as
        part of this fix.

      * ASP.NET

        Gonzalo has cleaned up a lot the code base, and now our test
        server supports a --root and --virtual command line options
        for better control. 

        Also, now we generate a much nicer error page on errors.  We
        are looking for volunteers to improve the default look of this
        page.

        Authentication is now supported

      * Mobile Controls.

        Gaurav Vaish continues on his quest to complete the
        implementation of the Mobile controls.  These controls are
        required to run a stock IBuySpy application.

      * Class Libraries:

        New Mono.Posix class library that contains classes for working
        on a Posix systems.  Things like Unix domain sockets are here.

      * System.Windows.Forms

        Alexandre Pigolkine continues to contribute more code to our
        Windows.Forms implementation.  Currently it only runs on
        Windows (or in Linux without GC enabled, due to the
        pthread/Wine threading library mismatch.  This is being
        actively addressed as part of the Wine work due to the
        movement to the new thread implementation available in RH 8.1).

      * Database providers

        Christopher Bockner has updated his DB2 database provider (now
        with prepared statement functionality) and Tim Coleman has
        continued work on the Oracle database provider (welcome back
        Tim!)

      * Database code.

        Dan Morgan continues to develop core components in System.Data
        (and now we welcome Alan Tam to the System.Data core hackers)

        The SQL# tool now supports MySQLNet, Npgsql, DB2Client, and
        Oracle clients.

      * Runtime

        mono --profile now performs memory allocation profiling too.

      * Runtime fixes.

        We now support multi-module with external file reference
        assemblies.  

        The above in English means that we can now run Eiffel.NET code
        in Mono.

      * Monograph:

        More statistics supported now.

      * System.Web.Mail

        Per has contributed the code for this namespace.

* Bugs 

        Plenty of bugs were closed.  
-------------------------------------------------------------------------
Hello everyone!

   We have made a new release of Mono available.  Despite the fact
that we just did Mono 0.18, this release is packed with new features.

* Availability.

   Mono 0.19 is available in package format from:

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

   We released packages for SuSE 8.0, Mandrake 8.2, Debian and various
Red Hat releases.  It is also available from Red Carpet on the Mono
channel.

   Source code for Mono, MCS, the Mono Debugger, XSP is available as
well from that web page. 

* New in this release

        * Remoting news:

                Lluis has implemented and documented the Binary formatter
                Woohoo!  He has done a lot of work as well to support
                remoting.

                Patrik has also been working heavily on fixing a
                number of remoting related bugs and missing features.

                Ajay also implemented 1-d array serialization in System.Xml

        * New database provider: IBM DB2

                Christopher Bockner has contributed a DB2 data
                provider for System.Data.  We have a very complete
                range of data providers.
                
        * System.Web.Mobile

                Gaurav has started work on this assembly, this will
                allow us to run the unmodified reference ASP.NET
                applications that were designed to support Mobile
                browsing.

        * System.Data and System.XML:

                More implementation work on XmlDataDocument from Ville
                and plenty of fixes from Atsushi.

        * MacOS patches:

                Paolo integrated John Duncan's and Benjamin Reed
                patches to make Mono run on MacOS X out of the box.

        * IsolatedStorage

                The initial implementation of it was done by Jonathan
                Pryor and included in this release.

        * Compilers:

                More work on the Mono Visual Basic compiler (it is now
                included in the packages).

                Plenty of bug fixes from Jackson, Miguel to the C#
                compiler.

                Patches from Francesco and Daniel to the VB.NET
                support runtime.

        * Debugger support

                Plenty of updates to run the new Mono Debugger from Martin.

* Main missing bits:

   Some of everyone's favorite patches or code chunks have not yet
been integrated, hopefully Mono 0.20 will have them:

        * Zoltan's patch to run IKVM is not yet on this release

        * Some parts of Patrik's remoting code did not make it to the
          release either.

        * Reggie's MySQL native provider is also missing.

Enjoy!
Miguel.
-------------------------------------------------------------------------
Hello everyone!

   We have made a new release of Mono available.  Despite the fact
that we just did Mono 0.18, this release is packed with new features.

* Availability.

   Mono 0.19 is available in package format from:

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

   We released packages for SuSE 8.0, Mandrake 8.2, Debian and various
Red Hat releases.  It is also available from Red Carpet on the Mono
channel.

   Source code for Mono, MCS, the Mono Debugger, XSP is available as
well from that web page. 

* New in this release

        * Remoting news:

                Lluis has implemented and documented the Binary formatter
                Woohoo!  He has done a lot of work as well to support
                remoting.

                Patrik has also been working heavily on fixing a
                number of remoting related bugs and missing features.

                Ajay also implemented 1-d array serialization in System.Xml

        * New database provider: IBM DB2

                Christopher Bockner has contributed a DB2 data
                provider for System.Data.  We have a very complete
                range of data providers.
                
        * System.Web.Mobile

                Gaurav has started work on this assembly, this will
                allow us to run the unmodified reference ASP.NET
                applications that were designed to support Mobile
                browsing.

        * System.Data and System.XML:

                More implementation work on XmlDataDocument from Ville
                and plenty of fixes from Atsushi.

        * MacOS patches:

                Paolo integrated John Duncan's and Benjamin Reed
                patches to make Mono run on MacOS X out of the box.

        * IsolatedStorage

                The initial implementation of it was done by Jonathan
                Pryor and included in this release.

        * Compilers:

                More work on the Mono Visual Basic compiler (it is now
                included in the packages).

                Plenty of bug fixes from Jackson, Miguel to the C#
                compiler.

                Patches from Francesco and Daniel to the VB.NET
                support runtime.

        * Debugger support

                Plenty of updates to run the new Mono Debugger from Martin.

* Main missing bits:

   Some of everyone's favorite patches or code chunks have not yet
been integrated, hopefully Mono 0.20 will have them:

        * Zoltan's patch to run IKVM is not yet on this release

        * Some parts of Patrik's remoting code did not make it to the
          release either.

        * Reggie's MySQL native provider is also missing.

Enjoy!
Miguel.
------------------------------------------------------------------------------
Happy new year!

        The Mono team is proud to release Mono 0.18, with plenty of bug
        fixes and improvements.  If you are a happy 0.17 user, this
        release is a happiness extension release.  Many bugs in the
        runtime, class libraries and C# compiler have been fixed.
    
        Also, our special envoy in Japan has reported that there is
        some naming confussion about the naming of Mono, as can be
        seen in the following documentary material:
    
        Atsushi Enomoto shows the source of confussion:
    
        http://primates.ximian.com/~duncan/gallery/Duncan-in-Tokyo/DSCN0702
    
        Nick and Duncan echo it:
    
        http://primates.ximian.com/~duncan/gallery/Duncan-in-Tokyo/DSCN0703
    
* Availability

        Mono 0.18 packages and source code is available for download from:

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

        Those using Red Carpet on Linux can install Mono 0.18 from
        the Mono channel.  The packages have already been pushed for
        you.

        At release time we have packages for Red Hat 8.0, 7.3,
        7.2 and 7.1 and Mandrake 8.2.

* Contributors to this release

        This release is brought to you by:

        Alejandro Sanchez, Alp Toker, Atsushi Enomoto, Cesar Octavio
        Lopez Netaren, Daniel Lopez (mod_mono), Daniel Morgan, Dennis
        Hayes, Dick Porter, Dietmar Maurer, Duncan Mak, Eduardo
        Garcia, Gaurav Vaish, Gonzalo Paniagua, Jackson Harper, Jaime
        Anguiano, Jeroen Janssen, Johannes Roith, Jonathan Pryor, Juli
        Mallett, Lluis Sanchez, Marco Ridoni, Martin Baulig, Miguel de
        Icaza, Nick Drochak, Paolo Molaro, Patrik Torstensson, Piers
        Haken, Rachel Hestilow, Rafael Teixeira, Ravi Pratap,
        Sebastian Pouliot, Tim Coleman, Tim Hayes, Ville Palo, Zoltan
        Varga.

* New in this release

        VB.NET compiler:
        
                Many improvements to the Mono VB.NET compiler.

        ASP.NET:

                Plenty of bug fixes in ASP.NET.  Larger applications
                can now be run with it.  The authentication system has
                been deployed, most changes are from Gonzalo.

                We have a modified IBuySpy running (without Xslt)

                If you want to run ASP.NET you can run it with either
                our XSP proof-of-concept server, or with Daniel's
                Apache module that can be fetched from CVS (module
                name: mod_apache)

        Type Reflector:
                
                A Console, Gtk# and Windows.Forms tool to browse
                compiled assemblies and examine the types on it, from
                Jonathan Pryor.

        Moving to NUnit 2.0 

                Nick continues the work on moving our test suite to NUnit 2.0 

        Mobile.Controls:

                Gaurav has started work on the Mobile controls, which
                are required to run some of the reference applications
                in full-mode like IBuySpy.

        Remoting:

                The remoting infrastructure has got a big boost from
                Lluis in this release.

        System.Data/XML

                Ville has been working on improving our System.Data
                classes in the XML assembly. 

        Crypto:

                Plenty of new crypto from Sebastien as well.  A new
                web page in our site can be used to track this.

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


----------------------------------------------------------------------
Hello!

        Version 0.17 of Mono has been released.

        There are plenty of new features, bug fixes, new classes, 
        performance improvements, optimizations and much more
        available in this release.

* Stats

        2605 cvs commits to the Mono repository since October 1st, an
        average of 37 commits per day including weekends.  

        212 commits to the Mono module.
        1438 commits to the MCS module.

* Mono Improvements:

        Work has begun to make the runtime run a finalizer thread and
        invoke all the finalizers from this thread.  This is the same
        behavior as Java and the Microsoft runtime, but it is disabled
        on this build.

        Integrated the s390 work from Neale Ferguson.

        Beginning of the work for pre-compiling code (Ahead of time
        compilation) for Mono (based on the early work of Zoltan).

        New option `--noboundscheck' for benchmark purposes, it
        disables array bound checks.
        
        Uses mmap instead of SysV shared memory for the Windows API
        emulation layer.

        Plenty of bug fixes, improvements and integration with the
        upper layer class libraries.

        New exception handling code uses the GCC native support for
        stack-walking if available and gives big performance boost
        (15% on mcs bootstrap).

        A lot of the work in the new release of Mono is required for
        the Mono Debugger (which will be released separately).  The
        Mono debugger is interesting, because it can debug both
        managed and unmanaged applications, but it only supports the
        JITer for debugging.

        Dick, Dietmar, Gonzalo, Martin and Paolo were in charge of
        most of these changes.

* Compiler improvements:

        Many bug fixes as usual, better C# compliancy.

        Performance improvements.  The new release of the Mono C#
        compiler is 37% faster than the previous version (self-compile
        is down to 8 seconds).  On my P4 1.8Ghz machine, the Mono C#
        compiler compiles (342,000 lines per minute).

        Thanks to go Ravi and Martin for helping out with the bug
        fixing hunt.

* Cryptography and Security classes

        Sebastien Pouliot and Andrew Birkett were extremely busy
        during the past two months working on the cryptography
        classes, many of the crypto providers are now working

        Jackson on the other hand helped us with the security
        classes, he said about those:

        `Writing security classes is the most exciting thing I have
        ever done, I can not wait to write more of them'.

* ASP.NET:

        We have now moved the code from the XSP server (which was our
        test bed for ASP.NET) into the right classes inside
        System.Web, and now any web server that was built by using the
        System.Web hosting interfaces can be used with Mono.

        The sample XSP server still exists, but it is now just a
        simple implementation of the WorkerRequest and ApplicationHost
        classes and can be used to test drive ASP.NET.  A big thanks
        goes to Gonzalo who worked on this night and day (mostly
        night).

        Gaurav keeps helping us with the Web.Design classes, and
        improving the existing web controls. 

* ADO.NET:

        New providers are available in this release.  The relentless
        System.Data team (Brian, Dan, Rodrigo, Tim and Ville) are
        hacking non-stop on the databse code.  Improving existing
        providers, and new providers.  

        The new providers on this release:

                * Oracle
                * MS SQL 
                * ODBC
                * Sybase
                * Sqlite (for embedded use).

        Many regression tests have been added as well (Ville has been
        doing a great job here).

        Brian also created a DB provider multiplexor (The ProviderFactory)

        Stuart Caborn contributed Writing XML from a DataSet.
        Luis Fernandez contributed constraint handling code.

        Also there is new a Gtk# GUI tool from Dan that can be used to
        try out various providers.

* System.XML:

        Atsushi has taken the lead in fixing and plugging the missing
        parts of the System.XML namespace, many fixes, many
        improvements.

* CodeDom and the C# provider.

        Jackson Harper has been helping us with the various interface
        classes from the CodeDOM to the C# compiler, in this release
        a new assembly joins us: Cscompmgd.  It is a simple assembly,
        and hence Microsoft decided not to waste an entire "System"
        "dot" on it.  

* Testing

        Nick Drochak has integrated the new NUnit 2.0 system.

* Monograph:

        Monograph now has a --stats option to get statistics on
        assembly code.
        

CVS Contributors to this release:

        Alejandro Sanchez, Alp Toker, Andrew Birkett, Atsushi Enomoto,
        Brian Ritchie, Cesar Octavio Lopez Nataren, Chris Toshok,
        Daniel Morgan, Daniel Stodden, Dennis Hayes, Dick Porter,
        Diego Sevilla, Dietmar Maurer, Duncan Mak, Eduardo Garcia,
        Ettore Perazzoli, Gaurav Vaish, Gonzalo Paniagua, Jackson
        Harper, Jaime Anguiano, Johannes Roith, John Sohn, Jonathan
        Pryor, Kristian Rietveld, Mads Pultz, Mark Crichton, Martin
        Baulig, Martin Willemoes Hansen, Miguel de Icaza, Mike
        Kestner, Nick Drochak, Nick Zigarovich, Paolo Molaro, Patrik
        Torstensson, Phillip Pearson, Piers Haken, Rachel Hestilow,
        Radek Doulik, Rafael Teixeira, Ravi Pratap, Rodrigo Moya,
        Sebastien Pouliot, Tim Coleman, Tim Haynes, Ville Palo,
        Vladimir Vukicevic, and Zoltan Varga.

        (Am sorry, I could not track everyone from the ChangeLog
        messages, I apologize in advance for the missing
        contributors).

------------------------------------------------------------------------

Hello!

        Version 0.16 of Mono has been released!  This is mostly a bug
        fix release, a lot of work has been going on to make existing
        features more robust and less buggy.   Also, contributions are
        too varied, so it is hard to classify them in groups.

* Stats

        795 commits to mono and mcs since August 23rd.

* News

        The changes that got in this releases are mostly
        bugfixes.  Miguel, Martin and Ravi attacked lots of bugs in the
        compiler, Dick fixed a bunch of bugs related to processes and
        threads.  Mark Crichton resumed his work on the SPARC port and
        made lots of progress there.  Juli Mallett has been working on
        making sure Mono also builds on BSD systems.  As usual, Dietmar
        and Paolo supplied their continuous stream of fixes to the
        runtime.

        Dietmar has completed the work on the runtime side for
        remoting support and we ship now with a sample channel, the
        System.Runtime.Remoting.Sample.  This can be used as a
        reference implementation for anyone interested in implementing
        other channels (like a CORBA channel).  

        Duncan got preliminary XSLT support done by using
        libxslt.  

        Gonzalo (with some help from Patrik) has been working hard
        making our ASP.NET implementation work on both Mono and MS by
        migrating the existing xsp code to the class library.  Gaurav
        started working on the classes in System.Design.dll and Chris
        Toshok checked in Mono.Directory.LDAP, which will be the
        foundation to implement the System.DirectoryServices assembly.

        Various fixes from Kral, Jason, Piers and Gonzalo were
        committed to System.Xml; Martin Algiers reports that the
        upcoming NAnt release will be fully compatible with Mono.

        Miguel imported Sergey Chaban's Mono.PEToolkit and ilasm code
        to CVS.  Nick, as always, continues to refine our testing
        framework by improving our tests.  Andrew Birkett continues to
        improve the implementation of our security/cryptographic
        classes.  Jonathan Pryor contributed type-reflector the our
        list of tools.

* Other News From Behind de Curtain.

        While the above is pretty impressive on its own, various other
        non-released portions of Mono have been undergoing: Adam Treat
        has been leading the effort to document our class libraries
        and produce the tools required for it.

        Martin Baulig has been working on the Mono Debugger which is
        not being released yet.  This debugger allows both native
        Linux application as well as CIL applications to be debugged
        at the same time (and in fact, you can use this to debug the
        JIT engine).  The debugger is written in C# with some C glue

        In the meant A new JIT engine is under development, focused on
        adding more of the high-end optimizations which will be
        integrated on an ahead-of-time-compiler.   Dietmar and Paolo
        have been working on this.

* Contributors to this release

      * Non-Ximian developers: Adam Treat, Andrew Birkett, Dennis
        Hayes, Diego Sevilla, Franklin Wise, Gaurav Vaish ,Jason
        Diamond, Johannes Roith, John Sohn, Jonathan Pryor, Juli
        Mallett, Kral Ferch, Mike Crichton, Nick Drochak, Nick
        Zigarovich, Piers Haken, Rafael Teixeira, Ricardo Fernandez
        Pascual, Sergey Chaban, Tim Coleman.

      * Ximian developers: Dietmar, Paolo, Dick, Duncan, Ravi,
        Miguel, Martin, Chris, Joe, Gonzalo, Rodrigo.


---------------------------------------------------------------------------------
        * 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