The Sao Paulo Telecentros provide service to 150,000 users. Each Telecentro is running a small cluster of computers: a high-end server and 20 diskless workstations (Pentium class machines).

The diskless Linux workstations are hooked up to the server with a 100mb network, and each workstation boots in 20 to 30 seconds (this is from memory). Very fast. All applications run on a pretty big server, and OpenOffice is pre-loaded, so it starts in no time.

Each Telecentro offers service to about 3,000 users; People schedule time on the workstations in slots of half an hour or an hour.

They have written lots of tutorials in Portuguese in each of the Telecentros and cover the basics: the Gnome desktop, Star Writer, Star Calc, Galeon and Gnome Paint.

Today there are 72 telecentros open for a total of 107 planned. The cost of setting up a telecentro is 10,000 dollars.

During my visit to the Telecentro's headquarters, I heard a few new arguments I had not heard before about the advantages of free software:

• Cost-wise: They were able to deploy 80 tele-centros instead of 20.
• The government initiative of Digital-inclusion means that users that use the software setups today can take the software home and replicate *the exact* functionality.
• Number of applications: There are 1,700 software programs available as part of the Debian Linux distribution which are both free and legal for the users to copy.

Martin reports: * baulig just compiled his first "Hello Generic World" :-)

The Mono C# compiler today compiled it first generics program (see the various generic tests on CVS). It is still lacking support for method overloading. All the goodies are in mcs/gmcs (the special tree for our generics compiler).

Paolo had previously added the Generics support to our class libraries (System.Reflection and System.Reflection.Emit) and added the code to JIT generics code. This was helped enormously by Jackson's earlier work on the IL Assembler which was already generics aware.

In .NET 2.0, Generics are part of the instruction set, and the metadata in an executable. Some of the advantages of this approach vs the C++ mechanism of having the templates defines in .h files is that we keep getting the performance increase from having the generics information "pre-compiled". Those of us with a Turbo Pascal background, cant help but think `These are like the Turbo Pascal Units (TPUs): they were just so much better than C libraries and header files'.

Its surprising how a good idea like TPUs did not take over the industry, and instead the C libraries and headers was kept on use for so long. GC was also around a long time ago, and it is surprising that today C and C++ are still the standard for software production.

Monodoc progres

Even more progress on Monodoc. Ben now got an `error messages provider', and we have included all the errors mcs produces (all 311 of them) with sample files in the documentation. Mandatory screenshot

Zoltan Varga has removed the big locks we had on the Mono runtime, and has replaced them with fine-grained locks using a lattice to describe the order in which the locks are to be obtained to avoid dead-lock situations. This was part of the thread safety audit on the Mono runtime engine.

Alp improved the UI of Monodoc, so it now looks a lot prettier:

Other changes in Monodoc during the past week include the display of extra information for matches, in this case, I selected the "ToString" method from the incremental search window, and a list of matches is displayed:

Johannes today contributed a patch to Mono's Windows.Forms that makes it track the Gtk theme colors; His new patch will also pick the default font settings. You can see it here.

Gonzalo in the meantime made me very happy with the changes to XSP (our ASP.NET server) that allow for multiple applications to be hosted on a single server. This finally will let me run all my web apps and web services under Apache.

The SharpWT team has a full C#-based version of SWT ready to run, and they have made tremendous progress on the toolkit in the last two weeks (working both on Windows and on Gtk+).

The Mono Brazil site is Up. It is TWiki based, but the content is there now.

Hip stuff

Today's hip thing is of course the text-mode Gtk+. I love this hack, and am puzzled by their effort to build a Midnight Commander-like program using it, but the pages are in Czech.

Chris Brumme's last post on his blog is also fascinating: many internal details about the CLR are exposed, but also, I am still quite surprised by the layering done by NT on their low-level loading interfaces, it seems too complicated when you contrast it with ELF file loading (seems to me like a backwards compatibility feature). Mono happily can avoid a lot of this, but for a price: they are today executing C++ code out of the box, we cant yet.

Michael Meeks is also showing off what seems to the uninformed viewer like a Gtk-like layout system for Open Office.

Guadec, and Linux at Work?

There are various cities in Europe that want to host the Guadec, and we can only host it in one place. I was thinking that maybe after Guadec, or before Guadec, the tutorial speakers for Guadec could tour Europe for a week or two, delivering tutorials on the various subjects: not really a tour aimed at Gnome developers, but aimed at users and developers interested in using the Gnome platform. Very much like what the Linux at Work folks do.

That has the advantage of getting Gnome better known in various places in Europe, but focusing our Guadec effort in a single city. What do you think? Mail me your thoughts.

Don: what is that cell phone of yours?

Don is going around with an absolutely hip SmartPhone running the .NET Framework, which am in love with. But after using all my internet browsing powers, I have failed to locate the model and provider for it. It seems to be available only in Europe.

If you run into Don, get him to mail me the information ;-)

Sao Paolo

Maria Laura and myself arrived to Sao Paolo. Tomorrow we will be visiting the Joao at the telecentros in the Favelas where they are using Gnome, Debian and Linux to operate those centers.

During the free softwaremeeting in Brasilia, we launched the Mono Brazil effort: a community of Brazilian hackers is creating a Portuguese community around Mono. This is an important step for the local community, just like the creation of Mono Hispano was.

In the meantime in Mono-land things keep moving, I logged into IRC recently, only to be bombarded with news about the progress in Mono-land: Windows.Forms widget rendering was re-structured to better match the rendering model. Plenty of bug fixes in this area, so you might want to get your mono-wine packages from the Mono site.

Duncan also contributed our Cairo bindings to System.Drawing (we previously were using Xr, and we have finally migrated to the new API). For those who want to use Cairo directly, we do provide a nice Cairo binding as well without using System.Drawing.

Atsushi Enomoto continues his work on the XML Schema validation. After watching the XML editor demo after Don's presentation, I am quite interested in seeing more smart XML editors based on this code. Although Conglomerate looks a lot nicer, it is very fragile (due to its C heritage ;-) and whatever is the language use to describe the graphical rendering is not simple.

Microsoft instead chose a different approach: instead of making a mapping from the XML schema to describe the rendering using the 2 or 3 level system used by Conglomerate, they have pluggable renderers into Visual Studio. So it is possible to provide custom editors or renderers for SVG files or well-known XML configuration files.

Lluis has got all the SourceGear regression tests running with Mono now, so I am sure Eric will be very pleased to see his product running on Linux (and soon on the Mac, as Paolo has been busily hacking on it)

Vladimir has been busily implementing a .NET version of the Internet Communications Engine: the new hip OO-RPC protocol in the world. Several of the people involved with CORBA contributed to the design of this vastly simplified and high-performance RPC system.

Gonzalo has got XSP to support multiple-applications. This means one thing: I am migrating my blog finally to ASP.NET, running side-by-side with the ASP.NET-based online Mono docs

Martin and Zoltan continue their bug hunting on the compiler, class libraries and runtime. Martin's debugger is also becoming more and more stable, but he wont get to work on it too much, as C# Generics await him ;-)

Yuri Astrakhan discovered Open Internationalization effort to create a data-base of all the things localizable/internationalizable that a framework needs to provide. Dick has been working on this based on some empty skeletons we created, but having real data files to work with will make our effort more interesting

Piers again impressed everyone with his Javascript skills: he implemented a lighter, more portable, less buggy Javascript dynamic tree, which can be seen on the mono docs site. Ben in the meantime helped me fix a few issues in Monodoc, in particular now we get a better hint on multiple matches for the same entry on the index, and he also implemented method grouping.

Porto Alegre

Been spending most of my time visiting friends and family of Laura in Porto Alegre. Also we have visited Marcelo and Suzana a few times at their place.

Today am flying to Brazil. First stop will be Brasilia, for the Congress-sponsored event on Free Software. Then am off to Porto Alegre to marry Maria Laura

After months of keeping on my TODO list `write a blog system', I gave up and wrote a small C# program to pull the existing messy files massage them and upload them to the site. Part of the problem is that I need something that will work in disconnected mode and let me use Emacs to compose these entries.

I also gave up waiting for BlogX to be released: I like it, but the GotDotNet workspaces software is just horrible to use. Even with Windows its horrible.

Microsoft still has some things to learn from the existing open source tools.

The next step is to write my own ASP.NET-based weblog system, but I have to overcome the the feeling of guilt everytime am not working on the core of Mono.

I love C# very much, and the new extensions that are being added to C# will improve the language in many areas:

• Iterators: they simplify authoring the IEnumerable/IEnumerator interfaces in a class. Very nice.
• Anonymous methods: reduce the glue required for small use cases. For large cases, you dont want to use them anyways, as they make your code look ugly (remember: if a function does not fit on the screen, its probably buggy).

Those will reduce the amount of coding required in some scenarios, but they do not address some of the most common problems that programmers face: strings and regular expressions.

.NET ships with a very powerful regex engine. The engine is so powerful, that it is possible to use it to implement very advanced regexp-based applications. Its as easy to use as the POSIX regex API is: slightly more verbose due to its OO heritage, but in general, very similar.

The problem is that there is no simple way of using this API from a language like C#: the developer is stuck with this low-level API. Perl and Python both bundle powerful regular expression engines that are bound in a fairly usable way in the language.

Its a shame that C# does not have any simple way, or a nice syntactic sugar to manipulate this common idiom.

Strings manipulation in C# falls on the same category: some work was done, but it was not really completed. Adding a few overloads to the class libraries would make C# a sweet language for string processing.

A two parameter indexer: string this [int start, int end] would clear a lot of the confussion with Substring arguments (a previous log entry has more details).

Although we could add this to Mono, the result would not be portable to .NET.

Finally, there is the Stream problem. Reading a file in .NET involves two steps: opening the stream, and then creating a streamreader to read from it. The code looks a bit like this:

	Stream st = File.OpenRead ("notes.txt");
	StreamReader re = new StreamReader (st);
        string line;
			
	while ((line = re.ReadLine ()) != null)
		Console.WriteLine (line);

Wouldn't it be nicer, if you could just do:

	string line;
	while ((line = File.OpenRead ("notes.txt")) != null){
		Console.WriteLine (line);
	}

The above could be easily implemented by having the FileStream implement IEnumerator as Guido does in Python.

A new version of Mono has hit the streets. This version is obviously the best Mono release ever. A roadmap to Mono 1.0 is also being prepared as we speak, for the joy of all the Mono users.

Duncan surprised me on Sunday with a C# Cairo binding. This was fast, and am really glad to see it happen so quickly.

Duncan and myself left the office early today to attend Don's keynote at the XML web services conference.

It was good to see Don, despite having taking a red eye the day before, he did an outstanding presentation on web services and showed some of the new features in C#.

Went to Provo today to do a small presentation about Mono in an open session to Novell engineers. It went pretty well, and I also got to talk with various developers about Novell's existing product line.

Of particular interest are iFolder and NetMail

I signed my lease for my new apartment, which will be just a few blocks away from my current place. Nat will be my neighbor.

A fresh new chapter begins.

More updates at Nat's site

Two fantastic movies this weekend. I just finished watching Was tun, wenn's brennt? which Laura recommended. Yesterday Alex, Nat and myself went to see L'Auberge Espagnole.

Maria Laura in Mexico: