A new release of the Mono runtime and SDK is available for UNIX and Windows. Packages for various distributions are also available from our download page.
This is a delicious release of Mono: so many new things have been improved, implemented, fixed, and tuned from the last release that it is hard to not be excited about it.
Our contract with SourceGear has had a big impact in Mono. The team at Ximian has been working on three areas to pass the rigorous tests provided by the SourceGear team:
This includes both the SOAP support classes as well as a complete rewrite of the XmlSerializer by Lluis.
The SourceGear Vault software and its regression test suite require a much better implementation of our HTTP client so we have rewritten it completely for scalability.
Plenty of changes for robustness and tests for stability were added. The new io-layer changes from Dick remove the handle limits that we had in the past.
With this release we are able to run their Vault command line software out of the box.
The MonoDoc tool which includes API documentation for both .NET classes, Gtk# has been updated to include the contents of the Mono tutorial (thanks to Lee and Johannes for their work on the provider).
Binaries for various platforms is available from our web site from the download section:
Source code for Mono, MCS, and XSP is also available from our web site
This summary does not make justice to the hard work that has gone into this release, so this is just a high-level overview.
This release can run IKVM (http://www.ikvm.net) out of the box, and it can also run Eclipse with the add-on found at: http://www.nexus.hu/vargaz
Jackson has made a tremendous amount of work on the Mono IL assembler. All the major features in the assembler are now complete.
The big missing pieces now are: debugging support, marshalling support, better error messages and generics support and of course bug fixing.
Sebastien Pouliot reports the following changes since 0.24
System.Drawing has support for multiple-backends; Alexandre Pigolkine has added a new backend based on Xr (http://xr.xwin.org) to the repository.
This backend is particularly interesting, because Xr implements the PDF imaging system, which is exactly what is required to implement all the features in System.Drawing on multiple platforms.
Today we have three implementations of System.Drawing: XrImpl, Win32Impl and GTKImpl. XrImpl being the one we will use on UNIX systems on the long run.
Codecs for BMP and JPEG were added (they use directly the underlying system libraries).
Aleksey Ryabchuk continues to implement plenty of controls on the Win32/WineLib based implementation of it as well as improving focus, keyboard navigation, common dialog boxes and layout computation.
Joel Basson and Philip Van Hoof continued to improve the Gtk-based port of Windows.Forms.
Lluis worked on a new implementation of the XmlSerialization classes in record time. The XmlSerializer is the foundation for the Soap web services and is also one of the neatest features in the .NET Framework.
It is possibly the best way of dealing with XML documents that I have found so far, and I am kept wondering, why did I bother processing XML in any other way before.
The Web services classes support both RPC and Document, processing as well as Literal and Encoded mechanisms. We have only implemented the client side so far, but most of the infrastructure is in place for authoring the server-side web services.
Erik has written the beginning of our WSDL compiler, but this compiler has not been checked into the repository yet, so today you need to compile your WSDL files using the Microsoft framework tools.
Gonzalo rewrote our Http client to conform to HTTP 1.1, and support all the features in the .NET class library.
The .NET Framework supports also a Remoting-based SOAP implementation. Jean-Marc ANDRE has contributed a new implementation of System.Runtime.Serialization.Formatters.Soap
Joshua Tauberer has written extension object support for XSLT; these are used extensively by the new Monodoc (which will be released shortly after Mono 0.25).
Atsushi Eno continued to improve our XML support and was joined by Ben Maurer in optimizing the XML class libraries. We now allocate about one fifth as much memory while having a 20% speed gain.
Paolo has made the profiling code modular.
The user can provide new modules to perform profiling-like operations on methods at runtime (see documentation).
The existing profiler has been turned into a module on its own, and we are also shipping a sample code-coverage instrumentation tool.
This interface will be of particular interest to anyone building advanced tool, or who needs special tracing and debugging facilities in the runtime.
We now support Custom Marshallers. This allows fine-grained control over the marshalling and de-marshalling of values during P/Invoke. If the default marshalling schemes provided by Mono are not exactly what you need, you can now manually tune the marshalling to be anything you can think of.
Plenty of exciting low-level development, but the high level overview is: faster JITing and faster code generated.
Paolo and Dietmar added support for tail calls and thread-static variables and faster type checking.
Many performance enhancements have been added to the JIT: faster handling of valuetypes, faster calls to some internal helper functions, faster access to two-dimensional arrays.
Dick reworked chunks of the IO-layer to remove the hardcoded limits, and fixed multiple bugs on it.
Our head of testing, Nick Drochak reports that we have managed to get our regression test suite to run fully with .NET 1.1; Ville was responsible for getting many of our System.IO tests running on .NET, those were previously failing.
Patrik Kalkman responded brilliantly to the teams' call for more unit tests. He contributed some very nice SingleFormatter and DoubleFormatter tests.
The good news in summary: we are down to 50 tests failing down from 200+ just a few weeks ago. There are plenty of tests, but we need even more, here is the current state:
It would be nice to use Paolo's new profiling code together with NUnit tests to find out how much of the API we are currently exercising.
Nick Drochak, who typically is a C# developer has now gone into the low-level code optimization world, and implemented the optimization to improve the following pattern:(long) uinta * (long) uintb
That pattern is used all over our cryptography classes, and has increased the speed of them, and got a 20% performance increase on the regression test suite for the integer code.
Marco has been very busy with the compiler: Plenty of bug fixes in the compiler: methods without arguments do not need parentheses; Various operators fixed; Endregion fixes; Late binding support; Multi-line statements; Redim.
Rafael fixed the Mono.GetOptions and improved some bits of the compiler.
Cesar has checked in the initial code to perform semantic analysis on the JScript compiler
ADO.NET and ASP.NET got fixes from Ville Palo and Gonzalo: many more regression tests, many fixes, and many improvements. These benefit XSP directly.
This release from Ximian includes Gtk# packages for a couple of distributions.
This release also ships with MonoDoc. MonoDoc has a few new features: Joshua has redone our ECMA provider, so the documentation is nicer, it has more features, and all the links finally work.
Lee and Johannes worked to get us a new provider for MonoDoc: this new provider integrates the Mono Tutorial into the documentation browser.
We need help continuing our Gtk# documentation effort, the .NET documentation effort, and finally improving our tutorial effort as well. If you are interested, check the email@example.com mailing list.
And of course, plenty of bug fixes everywhere: class libraries, compilers, tools, documentation, runtime, and assembler.