Monologue

Mirco Bauer: Smuxi 0.8 "Godsend" Release

Mirco_x0020_Bauer@monologue.go-mono.com — Wed, 08 Sep 2010 17:57:35 GMT

5 weeks after the 0.7.2.2 "Lovegood" release, I am very happy to announce the major feature release, 0.8 codenamed "Godsend". Major feature highlights of this release are desktop notifications (with full support of actions, icons, updates, append and sound), messaging menu / indicators (as provided by Ubuntu's Ayatana project) and working Twitter support with OAuth (basic auth was disabled by Twitter on 31st August). This version also fixes all bugs that were reported since the release of 0.7.2.2.

Desktop Notifications

Messaging Menu

Further on, Smuxi comes with the following improvements in its user interface:

More distinct nick colors by using a combination of colors
Use of nick colors for userlists
Emphasis of own nick in bold, making it easier to distinguish sent messages
Toggle-able menubar
Full screen mode support for enhanced netbook experience
Browse mode support
Remembering of tab order when reconnecting to a smuxi-server
Sound support by notification daemons which support this extension
Display of IRC network name instead of hostname in the tab
Addition of "Open Log" button for easy viewing of logs.

Smuxi provides better connectivity and security by supporting: HTTP and SOCKS proxies as well as secure connections to IRC servers by using SSL with optional certificate validation.

Last but not least, it comes with an enhanced Twitter experience by supporting the use of multiple Twitter accounts at the same time, reformatting tweets that contain newlines and showing the full retweet instead of a truncated version.

Updated languages includes: French (Cl�ment BOURGEOIS) and German (Bianca Mix)

The #smuxi IRC channel can now also be found, in addition to OFTC, on other popular IRC networks such as freenode and GIMPnet. The messages on #smuxi are automatically relayed between the 3 IRC networks.

If you like Smuxi and want to support it by making micro-donations, Smuxi is available on Flattr.

There are also many other nice FOSS projects available on Flattr, see the Flattr-FOSS project.

Smuxi is available for download from here.

Binary Packages of Smuxi 0.8 are ready to be used by Debian/Experimental, Ubuntu/Maverick, Ubuntu/Lucid (via PPA), OpenSUSE, Foresight Linux, FreeBSD, and Windows.

Andr�s G. Aragoneses: Version Tolerant Serialization with Mono

Andr�s_x0020_G._x0020_Aragoneses@monologue.go-mono.com — Wed, 08 Sep 2010 16:26:00 GMT

(Zoot Woman - Lonely By Your Syde)

During the last months I've kept working {with|on} Mono, but not working for Novell anymore.

Today I'm proud to blog about a bit of work I've done on Mono towards a better Binary Serialization experience:

mono-api-info command now can output ABI instead of API if you append the flag --abi. It has been useful for us in LindenLab while working on binary serialization compatibility between versions (already upstream!, so will be available in Mono v2.8, even with a new man page).

If you ever wondered why your .NET code is no longer capable of deserializing some old binary object you had in your servers, instead of fixing the problem in a case-by-case basis, you can now see the whole picture by just diffing the output of mono-api-info --abi from your current and old codebase! A small TODO that I haven't completed yet is to deal with automatic properties (because we still don't use them) so that would be an exercise for the reader!

Fix for upstream Mono to act as .NET in regards to Version Tolerant Serialization, a patch to which I have just added a lot more unit tests (soon to be pushed hopefully).

You can see the patch of this quite old mono bug here. Disclaimer: to be honest you will only need the previous --abi tool if you use a Mono version prior this fix, because from my testing VTS in MS.NET works as if every new field had an [OptionalField] attached! (At least the BinaryFormatter, the TODO here for the reader is to test the SoapFormatter ;) )

On a totally unrelated note: kudos to the MonoDevelop team for making such a great releases lately (and fixing the bugs I report so promptly). I've been testing it the last months on Windows and I can say it's a great experience to see your favorite IDE working cross-platform and making you not depend on VS anymore if you need to work on Windows from time to time (I know the Express versions are free, and are great! but they do not support plugins :( ). BTW, I've been lately experimenting with the C language support in this IDE, and have had some problems, but the real culprit seems to lay behind some wierd behaviour of my gdb in opensuse. Taking advantage that I'm in opensuse planet, can I do a couple of lazyweb requests?:

a) If you're quite familiar with gdb, can you take a look at these 2 bugs in case it rings any bell for you? BNC#588175, BNC#459274

b) Can you try to reproduce those bugs in openSUSE 11.3? (I haven't migrated yet from 11.2 because I fear about the HALlessness of it :) )

PS: Wondered why the video on the top? Well, I like the trend that some people have about posting random photos in their blog posts even when they may be completely unrelated, but in my case I love music so I figured this would suit better. Of course I would rather embed a WebM video or, even better, something that can preview a song (without video) in a "normally-lower-quality-than-what-you-can-buy" way, so if you have any hints, those are welcome! I especially mention the latter in this case because the Album version of the song above is much much better (synth pop FTW!).

Unity Technologies: Announcing the 2010 Unity Awards

Unity_x0020_Technologies@monologue.go-mono.com — Wed, 08 Sep 2010 09:33:22 GMT

Come get the fame and fortune that’s rightly yours at the annual awards ceremony to be held at Unite 2010. The Unity Awards is our way of honoring the best content being created with Unity. Categories We’ll be awarding a Unity Award to the winner and a runner up in each of these categories: ? Grand Prix ? Best Mobile [...]

Jackson Harper: You can call Contains with a Type as the key, but you...

Jackson_x0020_Harper@monologue.go-mono.com — Tue, 07 Sep 2010 19:54:44 GMT

You can call Contains with a Type as the key, but you can?t call Add with a Type as the key.

And for some reason apps rely on this behavior.

Jackson Harper: Simple Route Patterns in Manos

Jackson_x0020_Harper@monologue.go-mono.com — Tue, 07 Sep 2010 05:01:03 GMT

After looking at some ugly regexs I decided to implement a simple pattern matching system for routes in Manos. You can now use strings like this for your routes:

[Get ("/articles/{slug}/{page}")]
public static void Articles (ManosApp app, IManosContext ctx, string slug, int page)
{
}

[Route ("/{foo}/{bar}")]
public void Foo (IManosContext ctx)
{
}

Everything inside of the { } block is matched as a string, but can be converted to any type by the action invoker.

If you really want a { in your url string (even though its an illegal url char) you can double them up for escaping {{ or }}. Note: I might just disable this feature since its kind of pointless.

Jackson Harper: Updates to the routing system in Manos

Jackson_x0020_Harper@monologue.go-mono.com — Tue, 07 Sep 2010 01:16:15 GMT

I spent my memorial day updating the routing system in Manos to allow for parameterized actions. Originally actions in Manos were simply a delegate that returned void and took an IManosContext param. This made some things simple, but also made the API a little clunky to work with. Here?s an example of what things sometimes looked like:

[Get ("/Article/(?.*?)/(?\\d+?)")]
public void Foo (IManosContext ctx)
{
    MyManosApp app = (MyManosApp) ctx.App;

    if (app.SomePropOnMyApp) {
          // ....
    }

    string slug = ctx.Request.Data ["slug"];
    int index = Int32.Parse (ctx.Request.Data ["index"];
}

Having to cast the IManosContext::ManosApp to the applications App type is rather awkward and is something that has bothered me for awhile. Unfortunately because Actions are a static delegate and the context is a static interface, there wasn?t much I could do about it.

On top of that, the Int32.Parse is rather scary looking.

Today I came up with a system that allows me to pass an application specific ManosApp type to the actions and as a side benefit I can also pass in request data as parameters. So the updated example looks like this:

[Get ("/Article/(?.*?)/(?\\d+?)")]
public void Foo (MyManosApp app, IManosContext ctx, string slug, int index)
{
    if (app.SomePropOnMyApp) {
          // ....
    }
}

Implicit Routes

Implicit routes are still available, anything that has the correct signature will have an implicit route based on method name added for it:

public void Bar (IManosContext ctx)
{
}

public void Baz (MyManosApp app, IManosContext ctx, string foo)
{
}

I also added explicit routing for ManosModule properties:

[Route ("/Articles")]
public ArticlesModule Articles {
    get { 
        // ...
    }
}

Routing Methods

Finally, all of the routing methods are still available, you can still do stuff like this if you want:

public MyApp ()
{
    Get ("/Foobar", ctx => ctx.Response.Write ("Hello, Foobar"));

    Route ("/Admin", new AdminModule ());
}

OH GOD MY EYES!

Writing this blog entry has made me realize the need for something simpler than regex for pattern matching. Luckily Manos was designed to have a swappable matching system, so users can easily add their own matching system and I can take advantage of that system to make my new system. Expect to see something like this in Manos really soon:

[Get ("/Article/{slug}/{index}")]
public static void Foo (IManosContext ctx)
{
}

More info

Its rough, but here is my first draft on the routing docs:

http://github.com/jacksonh/manos/blob/master/docs/routing.md

Jackson Harper: More Manos Manuals: Timeouts and Object Caching and a release coming soon

Jackson_x0020_Harper@monologue.go-mono.com — Sun, 05 Sep 2010 15:30:00 GMT

Just added some more docs on Manos.

Timeouts

The first doc I added is on the timeout system for scheduling periodic tasks to be performed in the Manos pipeline. Here?s a quick example:

MyManosApp ()
{
    AddTimeout (TimeSpan.FromMinutes (5), 
                       RepeatBehavior.Forever, 
                       (app, data) => app.Cache.Clear ());
}

That will clear the application?s object cache every five minutes. You can also specifiy a number of iterations using RepeatBehavior.Iterations (count) or create a custom repeat behavior using the IRepeatBehavior interface.

Timeouts are just for simple tasks, they run in the main message loop, so there aren?t guarantees on when they will fire, and they will not fire if the application is stopped. So timeouts should not be treated as a task scheduler system like django?s Celery project. In the future I will be adding a robust task scheduling system to Manos though.

More info can be found here:

http://github.com/jacksonh/manos/blob/master/docs/timeouts.md

Object Caching

The object cache is simply a server side cache for storing objects by key. This isn?t for view/page caching, this is just for sticking objects in a temporary storage area while the app is running. Right now there is only an in-process cache, but I?m planning on adding a memcached backend this week.

Here?s a quick example:

MyManosApp ()
{
    Cache ["foobar"] = "I am the foobar string";
}

The one feature that the cache offers that?s beyond a simple dictionary interface is time based expiration. So if you want your object to go away in 15 minutes, you can just do this:

MyManosApp ()
{
    Cache.Set ("foobar",
                     "I am the foobar string", 
                     TimeSpan.FromMinutes (15));
}

The rest of the doc can be found here:

http://github.com/jacksonh/manos/blob/master/docs/object-cache.md

Coming Soon

Manos is starting to gain some interest and I?m hoping to do a stripped down release in the next couple of weeks. I?m still not happy with the templating system, so that will probably be disabled, but building things like web services should be pretty easy. And you can always build websites using a different templating system like StringTemplate.

I still haven?t done a comprehensive what/why/how document for Manos that will explain what it does, why i think its useful and how it works. I?ve been intentionally avoiding this because I don?t like announcing things that aren?t usable, but unfortunately all my ?feedback requested? blog entries lately have done that for me. This document should be out around the same time as the release.

Jim Purbrick: HTML 5 Audio Redux

Jim_x0020_Purbrick@monologue.go-mono.com — Sat, 04 Sep 2010 11:01:35 GMT

My recent experiments in to using Procssing.js and HTML5 audio to generate multimedia web applications didn’t get very far. I first tried generating a new HTML 5 audio element for each audio event, which quickly caused the browser to grind to a halt, and my attempts to reuse audio elements by resetting the playback position didn’t seem work, leading me to conclude that HTML 5 audio was only really useful for playing back long audio files, not for building sequencers that play back many short samples. When I spoke to @rem about my findings he was convinced that resetting audio elements should be possible and this weekend’s Music Hackday London has provided the perfect incentive and opportunity to dust off my experiments and start tinkering again. An hour in and sure enough I’ve managed to get audio elements to reset: it seems that the trick is to set currentTime after calling play() on the element, something that seems very counter-intuitive, but seems to work (at least in Firefox 3.6.8 and Safari 5.0.1 on OS X 10.6.4). Now I have reliable sample play back it’s time to start playing around with more interesting interfaces in Processing and there are 26 hours of hacking left: game on!

(cc-sampling+ licensed samples by vitriolix from freesound.org)

Maurits Rijk: Learning Clojure

Maurits_x0020_Rijk@monologue.go-mono.com — Fri, 03 Sep 2010 21:19:49 GMT

Recently I rediscovered an old love of mine. No, this didn’t happen at a high-school reunion. As part of my New Year’s resolution I had planned to learn two new programming languages in 2010. And somehow Clojure caught my eye. The language makes a lot of sense to me since I have always been (hence [...]

Rafael Teixeira: Managed Commons including WebM subproject is at Github

Rafael_x0020_Teixeira@monologue.go-mono.com — Fri, 03 Sep 2010 19:22:00 GMT

Sorry, forgot to update here that the Managed Commons project now resides at Github: http://github.com/monoman/Managed-Commons

It includes the WebM subproject, that will allow reading/writing WebM files/streams generally and decode/play such streams in Moonlight.

Little time to work on it, so the progress is very slow, but if you want to contribute, please do: Fork it at Github and send those fantastic Pull Requests.

Also please post issues there to help guide/prioritize development, I'm trying to first be able to read the Matroska files, them I'll start the decoder and pump some video data, and last plug it into Moonlight. Writing streams/files has low priority at this point, unless someone really want to develop a video producing app, or a slideshow-to-video converter and want to contribute code and testing to that end.

Jackson Harper: Nice doc on the resource stream locator format in Silverlight

Jackson_x0020_Harper@monologue.go-mono.com — Fri, 03 Sep 2010 17:44:00 GMT

Nice doc on the resource stream locator format in Silverlight

Jeffrey Stedfast: Microsoft Double Rainbow!

Jeffrey_x0020_Stedfast@monologue.go-mono.com — Thu, 02 Sep 2010 18:12:00 GMT

Microsoft has just created a new commercial for its Windows Live Photo Gallery software that plays on the "Double Rainbow!" stoner guy. I have to give them props for trying to be hip and cool, but I'm too busy laughing my butt off right now. You've got to see this:

What I want to know is what kind of camera is that guy using? Never seen anything like it. A friend suggested it was this antique digital camera, but I'm not convinced. If you have any idea what that camera is, let me know in the comments - it is gonna bug me for days until I know what that was!

Jordi Mas: gbrainy 1.51 for Linux and Windows

Jordi_x0020_Mas@monologue.go-mono.com — Thu, 02 Sep 2010 14:47:00 GMT

Here we have gbrainy 1.51, a minor bug fixing release. gbrainy is a game that challenges your logic, verbal, calculation and memory abilities.

What is new in version 1.51 from the NEWS file:

* 5 bug fixes
* Updated and new translations

The new translations include Vietnamese, Korean and Traditional Chinese translation (Hong Kong and Taiwan).

gbrainy 1.51 is available for download in source code from:

* http://gent.softcatala.org/jmas/gbrainy/gbrainy-1.51.tar.gz
(md5sum 09762be168973e6157263ebbc0256a26)

Additionally, gbrainy is available for all major Linux distributions.

Updated Windows version

I have also updated gbrainy for Windows installer to 1.51. I did not this for more than 10 months, I think that I had to do it since the Windows version is downloaded by an average of 100 people per day. I have used Monodevelop 2.4 to build the Windows version and it worked very well making really easy now to build gbrainy cross platform.

Jackson Harper: First draft of Manos middleware docs

Jackson_x0020_Harper@monologue.go-mono.com — Thu, 02 Sep 2010 03:43:51 GMT

I just committed my first draft of documentation for Manos?s middleware layer. Its a pretty quick and easy read and I?d appreciate any questions, comments, death threats or concerns that you may have. The doc is written in markdown so you can read is pretty easily on github here:

http://github.com/jacksonh/manos/blob/master/docs/middleware.md

Things still need to be fleshed out, especially with some examples of what methods can be called from inside the middleware hooks, but this gives you a basic idea.

The Gist

Middleware gives your application an easy way to ?do something? for every request/response transaction that goes into an application.

You get these methods to register middleware:

RegisterMiddleware (IManosMiddleware mw);
RegisterMiddleware (string name, IManosMiddleware mw);

RegisterMiddlewareBefore (IManosMiddleware mw);
RegisterMiddlewareBefore (string name, IManosMiddleware mw);
RegisterMiddlewareAfter (IManosMiddleware mw);
RegisterMiddlewareAfter (string name, IManosMiddleware mw);

ReplaceMiddleware (string name, IManosMiddleware mw);

And your middleware can override any of these methods:

ProcessRequest (IManosContext)
PreProcessAction (IManosContext, IManosTarget)
PostProcessAction (IManosContext)
ProcessError (IManosContext)

From those methods you can easily re-write parts of the request, redirect to another URL, abort the transaction, manipulate the generated html or just log something to disk. Really the sky is the limit.

Most developers will never have to write their own middleware but a lot of really important plumbing pieces of a web framework can be written using middleware. Things such as the auth system, rate limiting, url rewriting, and red/black testing are important components of a web application and will make use of the middleware layer. So its important that I get this part right.

Jackson Harper: Some cute C# tricks

Jackson_x0020_Harper@monologue.go-mono.com — Thu, 02 Sep 2010 01:18:45 GMT

Some cute C# tricks

Martin Baulig: MDB's new backend

Martin_x0020_Baulig@monologue.go-mono.com — Wed, 01 Sep 2010 18:50:00 GMT

Over the last couple of days, I did some extensive refactoring in MDB's backend and completely rewrote it.

The new backend now lives out-of-process and is written in C++ and there's a managed C# counterpart which talks to the C++ classes over a wire protocol.

One big mistake I made in MDB's old backend was abstracting things in the wrong way. The old backend was basically just wrapping C functions like ptrace() or waitpid and making them accessible from managed code. The big problem with this was that these functions have very specific calling semantics which needed to be replicated on the managed side to use them correctly.

Take ptrace() as an example - this function has to be called from one special thread and from this thread only. Or waitpid() as another example - interrupting it isn't trivial and there is no easy way of waiting for both the child process and user input. Because of this, more and more hacks where added to the managed part of MDB - hacks which were designed to work around specific calling semantics of these system calls. All this stuff made porting MDB very difficult. For instance, when you want to port it to Windows, WaitForDebugEvent must be called from the thread that created the child process - so the "wait event loop" has to be completely different than on Linux.

Primary goal of the new backend is wrapping functionality, not functions ... like "step one instruction, give me an event when done" - it doesn't matter how exactly we wait for the target to stop again, all we're interested in is getting that event.

This doesn't imply rewriting all of MDB in C++, but doing a little bit more in C++ than was previously done in C will make the C# code so much cleaner and so much more portable. As an added benefit, all the managed code will be fully debuggable by a managed debugger - something that was impossible in the old MDB :-)

The backend refactoring is now done, and we can do multi-thread single-stepping, so this afternoon, I cross-compiled Mono (trunk) from Linux to Windows, enabled mdb support in the runtime and started to play around with it ...

Unity Technologies: Introducing The Fabricator Contest!

Unity_x0020_Technologies@monologue.go-mono.com — Wed, 01 Sep 2010 18:10:43 GMT

MuseGames.com & Unity Technologies are teaming up for a new bi-monthly Unity “Prefab” based contest called The Fabricator Contest! The contest will be a regular event that will challenge members of the community to show their stuff by creating prefabs based on specific themes, and of course because it’s a contest that means winning entries [...]

Jackson Harper: Add contact profiles to gmail

Jackson_x0020_Harper@monologue.go-mono.com — Wed, 01 Sep 2010 14:00:08 GMT

Add contact profiles to gmail

Jackson Harper: Apparently this AsParallel thing works

Jackson_x0020_Harper@monologue.go-mono.com — Tue, 31 Aug 2010 22:55:00 GMT

Last night I added support to Manos to parallelize HTTP transactions.

All I did was change this code:

foreach (HttpTransaction transaction in transactions) {
    transaction.Run ();
}

To this:

transactions.AsParallel ().ForAll (t => t.Run ());

I got a chance to run apache-bench on both versions today and here are the results:

foreach loop

Concurrency Level:      200
Time taken for tests:   4.208 seconds
Complete requests:      10000
Requests per second:    2376.40 [#/sec] (mean)
Time per request:       84.161 [ms] (mean)
Time per request:       0.421 [ms] (mean, across all concurrent requests)
Transfer rate:          187.98 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0   15 200.8      0    3003
Processing:    28   68  21.8     61     819
Waiting:       28   68  21.8     61     818
Total:         30   83 202.9     61    3084

Percentage of the requests served within a certain time (ms)
  50%     61
  66%     67
  75%     75
  80%     79
  90%     87
  95%     96
  98%    205
  99%    215
 100%   3084 (longest request)

With AsParallel

Concurrency Level:      200
Time taken for tests:   2.791 seconds
Complete requests:      10000
Requests per second:    3582.49 [#/sec] (mean)
Time per request:       55.827 [ms] (mean)
Time per request:       0.279 [ms] (mean, across all concurrent requests)
Transfer rate:          283.38 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    1   4.1      0      34
Processing:    21   37   7.2     36     240
Waiting:       10   37   7.2     36     240
Total:         21   38   8.4     36     240

Percentage of the requests served within a certain time (ms)
  50%     36
  66%     38
  75%     39
  80%     40
  90%     44
  95%     50
  98%     63
  99%     73
 100%    240 (longest request)

Joseph Hill: Mono at NDDNUG Tomorrow Night

Joseph_x0020_Hill@monologue.go-mono.com — Tue, 31 Aug 2010 14:03:15 GMT

Tomorrow evening (Wednesday, September 1), I will be speaking on ?Mono, MonoTouch, and MonoDroid? at the North Dallas .NET User Group at 6p. I hope the title speaks for itself, but you can find event details and a map, as well as RSVP on Eventbrite.

Five years ago October, NDDNUG was the first .NET user group to give me the opportunity to present. I?d like to imagine that my presentation skills have improved substantially since then. More realistically, you should come anyways, simply because the evening will be action-packed with coverage of the many exciting things the Mono team are working on these days.

C�dice Software: Rename support on merge

C�dice_x0020_Software@monologue.go-mono.com — Fri, 27 Aug 2010 15:32:00 GMT

I'm going to go back to the basics today and describe how Plastic handles renames during merge with two different cases:

Rename a file, modify it in parallel in a second branch and check how the two branches are correctly merged back, which means: the result file is renamed and it contains the changes from the two branches.

Divergent merging: what if we rename a file in one branch and also in a second one to a different name and we merge back?

As simple as it might sound, renaming during merging is one of the points where most of the SCMs break... And the good news is that Plastic simply excels there.

Handling renames during merge

The scenario is very simple:

Create branch task003, rename and modify file agent.cs there

Create branch task004 (in parallel with task003) and modify agent.cs there

Merge back both branches to main
The expected result is: getting agent.cs renamed and including the changes from the two branches.

This is what Plastic does, but systems like Subversion dramatically fail: SVN will create two files as result and won't directly merge the changes...

The following screencast shows Plastic in action dealing with this example:

Divergent renaming

The scenario is the following:

Rename a file on a branch

Rename the file to a different name, in parallel, on a different branch

Merge the branches together

Plastic is able to detect the double rename and come up with a solution: choose one of the names or propose a new one. But Plastic won't end up creating two files and leaving you alone to handle further merging (changes on the files) yourself.

Interestingly this is exactly what Mercurial does: it will create two files with the two names and warn you to solve the situation somehow.

Check it in action here:

C�dice Software: Shell Extension tour

C�dice_x0020_Software@monologue.go-mono.com — Thu, 26 Aug 2010 15:58:00 GMT

One of the key features in the new Plastic SCM 3.0 is the Windows Shell Extension integration.

It's a feature that users coming from SVN or CVS were missing (the great "tortoise" family of tools, you know) so we finally cached up here, did our homework and released a very neat integration.

The really cool thing about the ShellExt is that you can use the entire Plastic GUI from it: the branch explorer, running merges and diff, the changeset browser, code reviews... everything is just there... which ends up creating a very tightly integrated and neat interface. You can access all the replication functionalities too, of course.

Here's a short screencast (remember we've a YouTube channel) here showing most of the views popping up and so on.

The ShellExt shares most of the code with the Windows GUI, which is great for maintenance. We had to do a good refactor of some pieces (not that big at the end :P) in order to be able to display "views" on standalone windows, and then also some threading considerations to integrate with Explorer, but the result, IMHO, is really good.

Enjoy!

Mario Carrion: Mono Accessibility 2.1

Mario_x0020_Carrion@monologue.go-mono.com — Thu, 26 Aug 2010 14:09:37 GMT

Last Tuesday, we presented Mono Accessibility 2.1. We worked really hard on this release. Our main goals were, among other things, to improve our UI Automation Client API implementation, polish the interaction with at-spi2, better Moonlight accessibility and to handle custom and client-side providers. The great work made by all the contributors was the reason [...]