Email: miguel@ximian.com
Docs:
Linux Developers Ben Maurer Cesar Nataren Duncan Mak Gonzalo Paniagua
Jackson Harper Lluis Sanchez Martin Baulig Mike Kestner Sebastien Pouliot
Novell
just hired Niels
Bornstein, the co-author of Mono: A Developer's
Notebook. The O'Reilly best-seller. Niel will be working on the Linux and
Open Source practice group.
Also Tor Lilqvist, the developers who brought GIMP and Gtk+ to Windows has been hired to work full time on Gtk+ on Windows and to assist us porting various Gtk+ based applications to Windows. Nat's blog has more details.
Tor will initially be helping Frederik port our new Desktop Search tool Beagle to Windows:
Later he will take on the final step to make the world a safer place: bring Evolution (our email and calendar client) to Windows. Even Windows users deserve an email program instead of a petri dish of worms and viruses.
David Reveman one of two developers behind Glitz also joined Novell. He will be working full-time on completing and tuning Glitz as well as contributing to the Cairo imaging library (the framework that will become the foundation for most open source projects to do graphics rendering).
Glitz brings OpenGL-based acceleration to Cairo rendering (Cairo is Mono's substrate for implementing the System.Drawing namespace). Screenshots of Glitz rendering are availble here.
And finally
Robert O'Callahan has joined the
Novell desktop team to work full time on various Mozilla improvements. Robert is
working on some pretty exciting things: Multi-column layout for web pages,
improving Mozilla's SVG support and continuing Mike Shaver's work on MonoConnect.
A few of my favorite articles from CommonDreams in the last few days:
Tracking Performance: Tomas's team in Charles University has published the results from speed benchmarking on Mono to track potential performance regressions. On the graph you can clearly see Lluis' fix to the remoting channels (the large drop in the Tcp tests). These have caused quite a lot of excitement in the Mono team:
Following up on Zac's port of Gecko# to Windows (which is now used in the Windows Beagle port), we now have patches to run Monodoc with Gecko# instead of GtkHTML.
By Mono 1.2 I want to switch Monodoc to use Gecko, to let us use CSS instead of tables in our documentation rendering.
Mono Windows.Forms implementation is rapidly advancing, it is now capable of running Winforms NPlot, as opposed to my Gtk# port:
The Windows.Forms team has started a blog to track the major developments, it is available here.
DotRay: A ray tracer written in C# for .NET and Mono was recently announced. It will become a nice test for the performance tuning going into Mono (Mono's Arrays Bounds Check Elimination code was recently updated to eliminate some checks it was missing and the AMD64 bit port has support for the SSE instructions set, which we are going to backport to the x86 backend):
In the last couple of days people have been using Ben Maurer's Mono heap profiler:
Various improvements have been based on the tool: from System.XML memory reduction (1.5 megabytes shaved with a relatively small patch when loading a 25 megabyte file) to improvements to F-Spot memory usage.
Paolo also did some micro-tuning for P/Invoke hungry libraries; It shaved about 50k-60k of memory for Gtk# based applications on startup.
F-Spot also went through some performance tuning optimizations: Larry greatly improved the rendering speed when switching pictures and in particular when rotating photographies (F-Spot automatically rotates pictures based on the EXIF metadata of the image).
Robert Love (here shown in his natural habitat) just got the second edition of his book "Linux Kernel Development" published. It now comes with a cute Novell cover. Get your copy today.
I keep churning through Chomsky's Fateful Triangle book (he now has a blog!)
Partly the book is a good complement to "Pity the Nation". Pity the Nation tells the story from Robert Fisk's standpoint a journalist in Beirut that covers the events on a daily basis. Chomsky's book on the other hand breaks up the various elements of the civil war by topic, so the actors and events are easier to identify in his book. Chomky's book lacks the sense of a story that Pity the Nation has though.
Keith Packard has a Blog. And I love it!
I like to watch this video every six months, Larry Lessig's presentation at OSCON.
A trascript is available: here
One of my favorite quotes from this presentation is this:
In an interview two days ago, Watts said, Here's the problem with Washington: "If you are explaining, you are losing." If you are explaining, you're losing. It's a bumper sticker culture. People have to get it like that, and if they don't, if it takes three seconds to make them understand, you're off their radar screen. Three seconds to understand, or you lose. This is our problem. Six years after this battle began, we're still explaining. We're still explaining and we are losing.
Havoc and Elijah, you might be interested in What Every Computer Scientist Should Know About Floating Point.
Love, Miguel.
I will be in Seattle from the 23rd to the 28th of January. If you are in the area and would like to meet, have dinner, discuss free software, Mono, Gnome or debate interesting topics, drop me an email (miguel@ximian.com).
Today a friend of mine asked me if I bought music from the Apple iTunes Store and whether she should. I explained to her that the music she purchases will be locked into the iPod and iTunes and she wont be able to play it on other MP3 players unless she hacks her music.
As for myself, I have been using FairKeys to copy the music to my Linux running laptop.
Today a timely article from the Register discusses some of the details.
As Cory Doctorow likes to point out about Digital Rights Management: Its not about what you can do today, its about they will allow you to do tomorrow.
Joe points to an article on spyware that exploits security holes to install itself on people's computers. An interesting read.
I have recommended my friends to use Macs or Linux in the past (If she can use Linux so can you). The only downside of Apple is that it creates a powerful distortion field.
This coming March I will be at the Free Software and Open Source days in Istanbul.
Once I have traveled that far, the question is whether I should visit something else while am that far. The options are doing a technical stop in Paris, or doing more middle-eastish trips.
After reading Pity the NationI am left with a desire to visit Lebanon. Most likely I will have little time to spend in the Middle East though.
Paco from the Mono team will be doing a presentation on January 18th at the Dallas Forth Worth .NET users group, details are here
Lovely tool for starting apps in Gnome from the fine folks at Imendio: LauncBox.
Jb Evain check his Cecil library into the Mono SVN repository (module name `cecil').
Cecil is a library that can be used to consume and produce CIL libraries. We are planning on using it for writing a "diet" program that will act as a "garbage collector" for assemblies (Paolo has written one already with the low-level C interface), allowing developers to create arbitrary profiles of the Mono class libraries given a starting root set. This will be handy addition to our bundles
In addition to that, there are various other things that we have in mind for Cecil: writing a new verifier, writing a bug-finder, writing a CLS and style compliance tool (like FxCop) and Jb's own work on his Aspect weaver.
I first found out about "Confessions of an Economic Hit Man" from this article on CommonDreams.
My copy of the book arrived yesterday and I have not been able to put it down. The book tells the story of a man that is trained to convince third-world countries to accept large loans for developing infrastructure. This is done by creating models and projections of the prosperity that such projects would bring to their countries.
The book tells a story of money being funneled from the World Bank loans into various corporations in the United States as well as the resulting unpayable debt that remains in the country. This debt can never be canceled and it is later exchanged by land, military bases, or favoring votes in the UN. In exchange politicians who accept these terms get a popularity boost from bringing infrastructure into the country.
The trick is to predict growth in terms of the gross national product. Even if the benefit goes to a single individual and the rest of the country is impoverished as a result.
There are three stages described in the book to ensure that a country gets the debt. The first step is to convince the country leaders of the benefits that it will bring to the population and the economic growth of the country. If the leaders refuse, then a second team referred to as "the jackals" perform targeted assassinations and if this fails, then the army is sent.
Any latin american has been a witness of these loans, the constructions and the special favors going to a few companies in the past twenty years. This book offers an insight into the inner workings of this process.
John Perkins tried to write this book four times, and four times he was convinced not to. This book is the fifth encarnation.
You always suspect something is fishy when living in Latin America, and the opposition typically blames large corporations for the sketchy deals. Sometimes the stories are so incredible that you can not believe them until you find documents like The Church Report.
Jakub points out that a company who is heavily borrowing GNOME's GPLed icons for its products and its web page has some strongs words about software piracy.
An interesting an succint look at administration mistakes
Thanks to the work of Zac Bowling the Mozilla bindings for Mono and Gtk# (Gecko#) are now working on Windows, see screenshot here.
This is using the standard Mozilla DLLs. His code is available here
There are plenty of updates from the land of Mono, I will write about those later. The most important things is that the new Windows.Forms implementation has replaced the old version on our repository, and that Geoff has implemented native MacOS X support for it.
On the JIT world Zoltan has completed the work to produce Position independent code (PIC) for our ahead-of-time compiled programs which will reduce the memory usage for long-running Mono applications.
In the meantime Massi continues to improve our SSAPRE and is going to be adding elements from GVNPRE to SSAPRE which in a single pass will give us some nice performance numbers for computationally intensive tasks.
I finished reading Robert Fisk's Pity The Nation a book that recounts the last 20 years of the story of Lebanon from the point of view of a war journalist. The book is gripping and its hard to put it down. Robert Fisk weaves plenty of different stories, anecdotes and interviews to produce a detailed tale of life in Lebanond during the civil war.
I have not read fiction for a long time, partially because books like this one tell a more vivid and interesting story than fiction does.
This book goes into the living standards, the traditions and the sources of various conflicts as well as covering the mistakes that every army makes in their search for conquest or liberation.
Of particular interest was watching the news with the reports from Iraq by the time I was reading the second half of the book, as it seems that the more we live and the more documented humanity mistakes are, the less we learn from them. Those who planned the latest war would have benefitted tremendously from reading Robert's account of the Lebanese conflict as they repeated the same mistakes the large armies did twenty years ago.
Its only 12 dollars for 700 pages of stories.
Christian Hergert has written a tutorial on how to use the Monodoc tools to maintain the documentation for your Mono/.NET-based library.
On Saturday we will go for a week to Cancun on vacations. We are flying tomorrow to Mexico City and will be working from there for a couple of days and will take a chance to visit some friends.
Laura
An article talking about Low Bug Counts on Linux. Another take on the same announcement.
A new Study on Linux vs Windows TCO by CyberSource.
Alp has updated the Mono C binding generator cilc to
support Gtk#.
The cilc tool is used to produce C bindings from Mono and .NET assemblies. The new Gtk+ support extends this to provide object inheritance of Gtk#-based widgets. So it is now possible to consume Gtk# widgets from C easily.
The code lives in CVS as part of mcs/tools/cilc
Nat
used to sleep a lot on airplanes.
Michael Meeks has been contributing to OpenOffice for a couple of years now. Initially he made it simple to start contributing to the effort, and wrote the OpenOfficeOrg Hacking guide, and setup a site at Ximian to get open source developers to contribute, you can see it here:
http://ooo.ximian.com/
With all the tools for newcomers to contribute to OpenOffice: Source Code Cross Reference, Bug Tracking System, Tinderbox Status and ready-to-hack source packages.
One of the best features is the Hackers Guide.
Yesterday he posted his slides on OpenOffice hacking here, I found some of them fascinating:
Edd, I agree that there is not much action on the IronPython development front, and we would be willing to host a hackable repository for maintaining IronPython.
We could then provide all these patches to Jim for when he has the cycles to do its upcoming release.
Logistically-wise, my hands are tied until January as Cancun is taking precedence over hacking in the upcoming weeks, but the new year is a good time to pick this up.
We released the latest two versions of Mono 1.0.5 (production) and 1.1.3 (development) both with a long list of goodies.
In the Windows.Forms world, Geoff wrote a native Quartz driver for our Windows.Forms implementation, which you can see here. Geoff reports that we have feature parity with Windows.Forms
Also, ran into IronPHP the same concept of IronPython, but for PHP.
Also Duncan learned today that the University of California Irvine is teaching one of its compiler classes with Mono on MacOS X.
Over the weekend I checked into the repository a tool to easily create Mono bundles. A mono bundle allows you to ship your Mono application as a single binary: no runtime necessary: everything is "statically linked", there are no external dependencies on a Mono installation of any kind.
To use, just type:
mono$ mkbundle --deps sample.exe -o mcs
Sources: 1 Auto-dependencies: True
embedding: /home/cvs/mcs/mcs/mcs.exe
embedding: /mono/lib/mono/1.0/mscorlib.dll
embedding: /mono/lib/mono/1.0/System.dll
embedding: /mono/lib/mono/1.0/System.Xml.dll
Compiling:
as -o /tmp/tmp7aa740ad.o temp.s
cc -o demo -Wall temp.c `pkg-config --cflags --libs mono-static` /tmp/tmp7aa740ad.o
Done
mono$
In the example above the resulting binary is a healty 7.5 megabyte file, but it contains the Mono C# compiler and three of the system libraries as well as the Mono VM embedded into it:
mono$ ls -l demo -rwxr-xr-x 1 miguel users 7575630 2004-12-01 02:21 demo*
I then tuned the compilation to use a few shared libraries from the system, in this particular sample, I only want to avoid taking a Mono dependency:
mono$ mono$ ldd demo linux-gate.so.1 => (0xffffe000) libpthread.so.0 => /lib/tls/libpthread.so.0 (0x4002c000) libm.so.6 => /lib/tls/libm.so.6 (0x4003c000) libgmodule-2.0.so.0 => /opt/gnome/lib/libgmodule-2.0.so.0 (0x4005e000) libdl.so.2 => /lib/libdl.so.2 (0x40062000) libgthread-2.0.so.0 => /opt/gnome/lib/libgthread-2.0.so.0 (0x40066000) libglib-2.0.so.0 => /opt/gnome/lib/libglib-2.0.so.0 (0x4006b000) libc.so.6 => /lib/tls/libc.so.6 (0x409e6000) librt.so.1 => /lib/tls/librt.so.1 (0x40afa000) /lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x40000000) libgcc_s.so.1 => /lib/libgcc_s.so.1 (0x40c68000)
This is just a productification of a feature that Paolo had developed for Mono.
The next step is to write an assembly "linker", so that only the functions necessary to run mcs.exe are included as opposed to the whole three assemblies.
The main problem is that we need a good library for dealing with CIL images, the contenders:
Sebastien for a while has been working on all-things-security in the Mono stack, in today's blog entry he describes how to write an SSL server in 3 simple steps.
He uses that to showcase the Mono.Security assembly and the excellent work that Carlos Guzman Alvarez has done on the TLS/SSL stack in Mono (Carlos is also the man behind the Firebird database provider for .NET).
In any case, Sebastien's blog is packed with technical information on a wide range of cryptographic and security topics (specially related to Mono).
At ApacheCon today, just finished my keynote, there is a video and audio of it here.
The slides of my presentation are here.
F-Spot failed during the demo, the problem was that on CVS Geoff just made Mono.Data.Sqlite support both the old Sqlite and the new Sqlite3, a tiny logic error gets the autodetection wrong (which is now fixed).
Dmitry Robsman, myself, Scott Guthrie, Daniel López
With the creators of ASP.NET (Dmitry and Scott) and the original author mod_mono (Daniel).
Daniel is at the conference demostrating at the conference is BitRock installer for Unix which is an Install-Shield like installer for Linux, BSD, Solaris and Windows and works with in GUI, text or unattended modes.
As a proof of his installer, he has a sample Mono installer for Linux that includes XSP and Apache for folks that want to get a quick head-start on Mono. The simplest Mono installation on Unix so far.
There is a lot of Java presence, and some PHP presence at the conference.
In other news: am running IBM's Derby in Mono, without having to write a line of Java. Love!
We completed the migration of the Mono repository from CVS to SVN. We did a few dry runs of the whole migration to verify that nothing would go wrong.
We are happy to report that the migration went as planned and we only had a small service interruption of a few hours while we did the final migration.
The repository had 635 megs of data in 34,831 files checked-in. We are using the file system backend, and things went very smoothly.
Details on the migration process for Mono users are here.
Lluis has been working on a new Dynamic Code Generation API for Mono. A detailed blog post with source code, examples and rationale is available here.
Lluis' new code generation API is a medium-level API and sits happily between the CIL (too low level for certain tasks) and generating C# source code (too high level and slow to produce, compile and dynamically load for certain tasks).
Notice the interesting model for the code generation.
The Novell Linux Desktop has been released, a web page with information (and various flash demos) is available here.
Congratulations to the desktop folks for this release.
They have a starter's page in Novell's Cool Solutions with an overview for those new to NLD.
Joseph has been running http://www.gotmono.net/ for a while, and today I discovered his blog. What I found interesting is that he has been maintaining ASP.NET applications and ports of Mono (here) and his blog talks about his experiences.
It is an interesting read for those interested in Mono deployment and performance.
Although he is beta testing some new ASP.NET-based forums, the current forums are very active.
An Interview with Alan on the recent Desktop Release is here
Joshua Tauberer (Monodoc hacker extraordinaire and of GovtTrackUs fame) has ported Perl's Algorithm::Diff to C#, lovely tool available here.
It is not limited to strings or characters, it can operate on anything comparable.
Massimiliano just posted his implementation of the SSA-based Partial Redundance Elimination (for an explanation, see Massi's presentation).
This is an important milestone in Mono's runtime to improve the performance of computationally intensive tasks. The patch is only 2069 lines of code.
Massi previously implemented the Arrays Bound Check eliminination in the Mono VM. Congratulations Massi!
Am now using GPWS to share files from my computer at
home.
Hasan has a blog where he talks about his Gtk# experiences.
I have updated NPlot to version 0.9.7 and improved the widget performance. You still need to use CVS mcs and libgdiplus to get it to work.
Code drop is here. Now with a spicy makefile.
Matt (the maintainer of NPlot) said that he wanted to distribute the Gtk# moving forward.
An interesting presentation from Ariel Faigon on usability and another one on testing
Being the optimist that I am, I will go to sleep thinking that the count is not complete, and that the Electoral College will fix the world for us. If the supreme court made some hand tuning to democracy last time, I will hope some other hand tuning can still happen.
Slashdot browsed at +5 has some very interesting comments
Harper has a guide for those who want to Leave the Country and there is a list of reasons not to move to Canada.
To me, its like an adventure, like in the Timeline movie: we get to go back to the middle age and explore a world where science and intelligence are a liability.
Nixon got impeached on his second term, there is hope ;-).
In the paste few days I had been doing a Gtk# facade for NPLot: a wonderful library to do plots.
There was not much in the way of porting. NPlot alredy supported two front-ends: an ASP.NET one and a Windows.Forms one, so this is only an addition. The engine is completely independent of the presentation layer, which is good.
NPlot exposed bugs in our C# compiler and in System.Drawing, they are both fixed on CVS HEAD and the 1-0 branches. Sadly these fixes came after Mono 1.0.4 and 1.1.2 were built, so to use it you will need to get CVS.
The sources are available here. And here it is in action:
Erik discovered NPlot a few weeks after Nat and myself were talking about widgetry that we would like to see available for developers. We were talking about scientific (2D plots, 3D plots, animations) and business widgetry (validating data entries, Gnumeric-like data entry, database-bound widgets).
NPlot fills the 2D plotting gap quite nicely. We had looked at some Gtk+ solutions, but this solution requires no bindings at all and can also work in batch mode or to produce plots for web applications.
I want a music player that will play nicely with Linux and from a company that will not try to sabotage me at their will. When I buy music from the Apple Music Store, I can not play it on Linux.
I know about FairKeys, but this is not a product that could be shipped by Linux distributions that are afraid of getting into a lawsuit. So it effectively can not enter the mass market of free software users.
I have always been annoyed at this, and today I found this on BoingBoing: iTunes upgrade used to remove more features (disguissed as an "upgrade") and a follow up (through Dave Winer).
Luckly Slashdot has pointers to a bunch of new iPod Killers: Part 1, Part 2, Part 3 and Part 4.
Certainly Apple has a couple of years of advantage in terms of improving their product compared to their competition, but am going to spend my money into funding products and companies that are not out to screw me or limit what I can do with the device I purchased.
If people have good experiences on a good portable player, let me know. Am looking for something with 20 gigs of space and possibly ogg support. FM and recording are pluses, but not very important.
New
song from Eminem is out. lyrics, plus
video in Real
and Windows
Media are available.
Loved the video.
Commentary and lyrics at common dreams
Greg Palast on Harper magazine this month on the new touch-screen computers in Florida's election or how Florida is learning one or two tricks from Mexico's IFE.
A great read from Nat's blog: Getting nothing wrong is for the uninspired
Today my laptop was left on while I walked to work, and this is what happens when you walk by MIT:
The anonymous method support has been checked into CVS in the HEAD branch.
Autopano-sift is an application to assist in the creation of panoramic images from a series of pictures.
From DevCon are available.
Last week we had
a Mono Summit in Cambridge, notes from the various discussions and developments
are available here: http://www.go-mono.com/summit-notes.html
John Pilger documents the Story of Diego Garcia and the cleaning of the native population in the 60's.
The story has a happy ending, those expelled from Diego Garcia received 3,000 pounds (each).
There is more information on Pilger's site.
Duncan has done some work to bring the NodeStore/NodeView to life, simplifying the life of those using the TreeView, here is a screenshot from his blog entry:
Interesting article: 100 facts, 1 opinion.
Btw, you can not use `Fox News' as your fact check source ;-)
Yahoo picked up on the removal of transcripts of the from the White House web site. The removals include some priceless gems.
For those running to the wayback machine to look for the originals the Whitehouse web site has been updated with a robots.txt file to avoid it.
Thanks for all the e-mail on the Gnome Notifier. Am not interested in turning this prototype into a working product, there are better efforts underway. The point I was trying to make on my last post was that early on I realized that we needed the notification system to do more than just show a message: it is important to be able to have a list of actions associated with it that I can click on.
My toy Gnome Notifier was written a few years ago as a sample program that I wanted the Gnome people to productize. It was not meant to be a real or completed program.
Nicholas Petreley has a Security Report on Windows vs Linux.
Jamin, you might want to read the news articles posted from Enjoy the Draft's FAQ. I was particularly interested in question (5).
Rico
Mariani has a blog on .NET
performance. An interesting read is his Performance
TidBits post.
A good companion is: Improving .NET Application Performance and Scalability.
Calum writes his feelings about notifications: they should not have options. And here lies a problems with the view on notifications: am personally not interested in the equivalent to `tail -f some_log'. I want my notifications to be interactive, and hence those options seems awesome.
I am personally interested in a notification framework to the desktop to avoid things like GAIM popping up a dialog box in the middle of writing an email that asks me if I want to accept a buddy or not. In this particular case having a default button makes things worse, because I do not know which people I have accepted or not accidentally. I literally have this problem every day.
In fact, I want to have a log not only of notifications but of actions to follow up to. So some notifications should not go away, they should stick around, and when I have the time I can go and click the appropriate buttons `accept', `accept', `reject', `reject'.
Some other notifications can just go away: if I have not responded to the CD insertion action, it can likely go away from my screen.
Longhorn keeps track of notifications that the user has not seen.
My old gnome-notifier does exactly this, and supports a special kind of url `run:' that you could use to run programs in response to actions.
Elijah Gaim is one of the applications that have this behavior. But even if you do not steal focus, I do not want a window popping up in the middle of the screen for GAIM. I want these kind of notifications to go elsewhere (Windows uses a baloon and the proposals so far are along the same lines: notifications are out of your current work area).
An educational website: Enjoy the Draft Dot Com.
The FAQ is a must-read.
A lighter, more positive side of the draft.
I am the last
one to notice monoForge a site that
allows you to test your Web-based Mono application on Linux. During the beta
period the service is free.
An
implementation of the
Desktop Notification. Fredrik is working to get a notification that looks
like Tuomas mockups.
Another version is MonkeyPop which uses Mozilla. MonkeyPop uses a set of tools for developing desktop applications called the Chicken Framework. One nice thing about the Chicken Framework is that its distributed with documentation.
It would be nice for the authors to work together.
Tomorrow the 21st I
will be participating on the Evolution
E-Plugin hackfest. The hackfest will take place in the #evolution IRC
channel on irc.gnome.org.
We will be learning the E-Plugin interface that Michael Zucchi designed for Evolution. Now Evolution 2.x can be extended with user code to implement your favorite missing feature or your favorite aberration.
Plugins are typically built with C but there is a Mono interface so any Mono supported language can be used to extend evolution.
This blog entry has some demos of the E-Plugin from August, it will give you a few ideas of what can be done.
Mark has Gecko-sharp running on Windows (this is the Gecko binding for Gtk# running on Windows).
Gecko# on Windows.
Echoing Nat's post on the fifth anniversary of the incorporation of Helix Code.
Edd has written an article on Seven Cool Mono Apps built for Linux using Gtk#.
After the above article from Edd, Eugenia posted a list of another twelve applications written in Mono/Gtk# here and today I also noticed MonkeyPop and Word of the Day Applet
A lot of cool innovation on top of Mono/Gtk#.
An interesting article studying Microsoft as a citizen, based on the ideas from the movie "The Corporation".
The author wrote a very interesting follow-up to it.
Update: Nat has posted his thought on Microsoft. A must read.
Jon Stewart is my hero. His appearance on CNN this Friday was unbelievable. He showed the world the state of journalism in the country.
You can read the script, but I recommend watching it (BitTorrent).
Garret has updated the F-Spot Product Design Wiki with many screenshots as a foundation for ideas to F-Spot
This week all the Novell Mono developers came to town for our semi-annual meeting.
Vasu has posted a description of the events on the Mono Day at Novell Bangalore. It describes some pretty cool demos that they did.
If you were looking for information about the now extinct Dodo, look no further than here. The first match in Google is not about the Dodo, its about some Internet provided in Australia.
We learned from Dare that XML 2 was going to get some features cut, which is a good thing for us, as there is less to implement. Kind of a shame, since Atsushi has a good foundation for XQuery already on the Mono tree. Until XQuery is added back to the Framework, we will likely distribute a Mono.XML assembly that contains our implementation of XQuery for those interested in using it before the next major revision of the .NET Framework.
Atsushi had been working on our XQuery implementation for Mono, and has some insight on its current design and limitations.
From Todd's blog I see that Sean has decided to shoot Gaim in the foot: look at this this monstrosity.
To add humor to this, Nat found the the ChangeLog entry for it:
Modified Files: gtkprefs.c Log Message: Simplified the prefs dialog by replacing the tree with tabs. You may think this is a bad idea, but it"s not.
John Luke blogged about Lazlo. Lazlo is very similar in spirit to Macromedia's Flex: it is a server-side XML markup for creating applications with JavaScript as the programming language for it.
Like Flex it produces Flash files dynamically, and it is implemented using Java. An adorable project, worth helping those guys out.
A demo of Lazlo can be seen here.
Jordi Mas (from our Windows.Forms team) has written an article in Spanish about Mono: Beyond .NET.
Jackson has been with the Mono team at Novell now for a year.
Someone had the patience to do it: here. This one is particuarly packed with jewels.
And for healthcare, there is this one.
Since am linking, a new Mark Fiore episode: The Few, The Contractors.
Got my Farenheit 9/11 DVD yesterday and I watched the beginning of the movie again. As awesome as it was when I first watched it, and comes with some extra footage and complimentary material.
Watching it for the second time, I felt that there was so much more that could be added to the movie and spice it more with what we know since the movie was released. It is still a very powerful movie.
Peter
Sestoft and Henrik Hansen have published their new book `C#
Precisely', a pretty concise book from MIT Press and it covers the C# 2.0
language including generics, iterators and anonymous methods.
Peter is one of the developers of the of the C5 class library: a library of generic classes for C# (We package this for Mono as the Mono.C5 assembly).
I mentioned a few days ago Joshua's GovtTrack.us web site. This web site is data intensive and was ported from Perl to Mono, according to Joshua the porting experience was a joy.
Joshua is one of the XSLT magicians in the Mono project, the man who turned 3,000 lines of C# code for pretty-printing our documentation into 300 lines of XSLT macros.
But Joshua did not use ASP.NET to write the new site, Joshua rolled out his own processing model using Mono and the low-level hooks of System.Web, he discusses the porting process on a recent article:
Websites have some of the same design issues as programs. One common issue is how to avoid duplication, but while software developers have solved this issue with functions, website developers are still struggling for a solution. GovTrack.us, my new website, solves this problem using XSL transformations and the Mono framework.
The article is interesting for anyone interested in extending and hooking up to the HTTP processing pipeline in Mono and also discusses how to extend Mono's XSLT with C#-coded functions.
Joshua has a blog.
Users of Linex can download packages for Mono from here. The rumor on the street is that Alo himself packaged Mono. Maybe he has finally reached enlightenment.
While watching the debate, president Bush made a statement about how spreading freedom was the right thing to do. And how eventually freedom will help fix things in the world. The CNN blog had a funny remark:
I love the way Bush talks about "spreading" liberty and "spreading" freedom. Like they're this peanut butter and jelly that can just be piled on top of slices of other countries.
A point that I think people have been missing is that the major source of the problems around the globe have to do with quality of life, freedom comes in a distant second place.
The focus on the war on terror I believe is completely missguided. Dropping bombs or shooting people will only exacerbate the dislike for an invasion. On the other hand, if social programs to reactivate the economy, to improve health-care, to improve schools, to create jobs, you will increase the number of happy people and minimize the discontent.
There is a whole debate about what "freedom" means, and it probably means different things to different people. Every once in a while I ran into people who miss the days of living under a dictatorship: from the Franquistas in Spain who think the country was better off with dictator Franco, to chileans that believe that dictador Pinochet was the best thing to happen to Chile since sliced bread. These people were enjoying their lives and hence had no problem with the imperfect states of government they had.
My point is that some people did not care about their freedom rights as long as they themselves were doing fine. Another example are some americans today. They seem to be just happy to reduce their own rights and freedoms for the sake of security (Patriot Act) or the sake of capitalism (The DMCA).
A better strategy to fight terror around the globe would be to revisit US foreign economic policy, to help organizations like the FAO, give economic relief and revisit the free trade agreements to level the standard of living around the globe.
The subject is explored from an economist point of view: here and here.
And of course, at the core of the problem I believe strongly is ultra-capitalism: companies and practices which are only concerned in increasing shareholder value with no social compromise (The movie "The Corporation" digs into this issue more).
On Korea's nuclear proliferation.
Enjoyed pretty much the debate, I was surprised at Kerry's articulate intervention. Bush did try the whole show to point out Kerry as changing opinions, I wish Kerry had pointed to Record Shows Bush Shifting on Iraq War.
Alex (of Tomboy fame told me today on IM:
Alex: ya, he was damn good Alex: if he had been able to speak that way throughout the campaign he'd be winning Alex: the problem is that bush's progeny is much better at spin Alex: so by this time tomorrow the people will be convinced that bush won the debate
Joshua is a long time contributor to Mono and on his copious spare time he works maintaining the GovTrack.US web site. He has just completed his port from Perl to Mono.
Let me quote Joshua:
So now if you go to www.govtrack.us, you get my new and improved Mono-powered site. I probably said this last email, but using Mono has been unbelievably easy and helpful.
Congratulations to Joshua! And we will keep an eye on Monologue for his comments.
Edd reports that his Mono book was the top seller at the XML Open conference:
O'Reilly had a book stall at XML Open, and I was very glad to hear that Mono: A Developer's Notebook was the best-selling book during the conference. Very amusing, for an XML conference!...
The way that people can help best is to ask for the book in their local stores and get them to order it. If lots of requests show up from stores, then it really helps make a case to the central buyers for ordering it.
In the last couple of years I attended a couple of talks from Noam at MIT and Harvard. Excellent talks, if you were not able to attend these, you might want to get the DVD.
It comes with the presentation at Harvard and a Q&A section from both events.
Duncan sent me a link to The Life of Joe Republican, very funny, excerpt:
All but $10 of his medications are paid for by his employer's medical plan because some liberal union workers fought their employers for paid medical insurance - now Joe gets it too.
On the other end of the spectrum, multi-billionaire George Soros gives his opinion on Why We Must Not Re-elect President Bush.
Follow up: Bruce Springstein interview detailing why he had to take a position on this election.
Mikael is the founder of Imendio, there is an interview with him at OSnews on the subject of Gtk+/Gnome commercial support.
I read with alarm the discussion between the Solaris kernel engineer and some Linux dude. I have to say that it is a bit sad that the Linux dude did not understand the points of the Solaris kernel developer.
It was a bit embarassing to read the arguments from the Linux dude. And I found myself agreeing more with the Solaris engineer which clearly articulated the rationale for his decision. On the other hand or Linux friend just launched a long tirade of fanboyism and flames.
This is the wrong way of advocating Linux. I have always maintained that to effectively compete you should never compare the downsides of your competitor with your advantages, that just leads to the placebo effect you can see from the Linux guy: "everyting we do is fine, there is no need to improve". He got defensive. But this is exactly the wrong attitude to take because in this mode of operation you do not react and do not take steps to improve. What the Linux community should do is compare the strengths of Solaris and the weaknesses of Linux. Maybe there are things that can improve, maybe there are cultural changes that can take place but dissing someone else on these grounds is not going to improve our loved kernel.
When Sun decided to adopt Gnome as their desktop environment there was a big discussion about API stability, an issue that many of us although peripherally aware of, did not take as seriously as Sun did. We have to thank Sun for bringing that culture into Gnome, and I wish that the same culture spead further to other projects.
The slashdot thread at +5 has some very interesting insight on the latest Get the Wrong Facts campaign from Microsoft. The best responses: one, two but in general everything at +5 is worth reading.
Awesome Interview Transcript: Jon Stewart being extremely classy in his replies to the ad-hominem comments from O'Reilly.
According to O'Reilly viewers of the Daily Show are stoned slackers, research apparently proved the opposite: the audience of the Daily Show is more likely to have completed four years of college as opposed to the O'Reilly audience. Me not having completed college probably puts me on the `stoned slacker' category.
In other news:
Jackson just posted an update on Mono's new managed implementation of Windows.Forms.
Cesar has posted an update on his work on the JavaScript compiler for Mono, it is here
I own it now.
Mandatory link to Jon's blog. His software page has various C# programs.
Todo list getting shorter: parameters missing, fix iterators (which I broke), switch statement, write rationale and author ChangeLogs:
Test passes: a-call.cs
Test passes: a-capture1.cs
Test passes: a-capture2.cs
Test passes: a-capture3.cs
Test passes: a-capture4.cs
Test passes: a-capture5.cs
Test passes: a-capture6.cs
Test passes: a-capture7.cs
Test passes: a-capture8.cs
Test passes: a-event.cs
Test passes: a-instance.cs
Test passes: a-nested-anon2.cs
Test passes: a-nested-anon3.cs
Test passes: a-nested-anon4.cs
Test passes: a-nested-anon.cs
Test passes: a-nested.cs
Test passes: a-parameter2.cs
Test passes: a-parameter3.cs
Test fails: a-parameter4.cs
Test passes: a-parameter.cs
Test passes: a-simple.cs
Code drop
I will be
talking to some Novell customers in Mexico City about Novell Linux initiatives
and some of the Novell offerings on Thursday September 20th, if you want to
come, register here.
I found
this link from Jon Udell's blog: Valdis
Krebs has graphed the books purchased in online retailers and has come up
with a pretty interesting view of the nation based on the book purchasing
patterns.
It begins in 2003 continues in early 2004 and there is a recent update
Super-hacker Atsushi Enomoto is on the move. He will be at the XMLOpen conference in the UK representing the Mono team, and later will land in Boston for couple of weeks to do some local hacking and consume lobster sushi.
Evolution 2.0 has been released.
Shame about the shortcut bar being gone, I never use the folder list, I have my life organized using shortcut bars.
Sebastien has posted his thoughts on the MD5 vulnerability. Check it out!
I always find Robert Cringely engaging on his articles, and his last installment follows this tradition. Some would say its nothing short of insanely great.
Anyways, a couple of thoughts:
It is clear from Chris Anderson's last post that it is an ongoing strategy to come up with schemes that will lock Linux out (even if they are highly inadequate for the world where scams are the rule of the day).
Avalon's feature set is one of these creative things they come up with. I am convinced that they see Avalon as the tool that will replace the Web (the marketing folks will step in and claim that they `augment the user experience').
Maybe we are reaching a point where we need government regulations on the software industry or in some of its components. An explicit acknowledgment of Linux and open source players as an important player in consumer choice.
Ah, not only had I suggested that when Slashdot posts a link to the MS lobbying efforts.
Speaking of augmenting the user experience. It is clear that plenty of work can be done today to augment the user experience of the web: GMail and Google Local services is leading the pack in smooth user interfaces. Everyone is raving about the keyboard navigation, the clean look and the good interaction of GMail, while am delighted to see the clever hacks to explore maps without doing page reloads.
And finally there is A9 who also sports a great user interface on the Web.
Firefox reached one million downloads ahead of schedule. Congratulations to the Mozilla hackers!
Someone else also thinks that Java APIs got too academic: here
Alex has released into the world his tomboy software. Check it out. Am addicted to it.
Another reason to vote for Kerry: to avoid more de-regulation.
Been enjoying reading Stiglitz's new book: The Roaring Nineties.
John list of reasons to vote for Kerry was zero, so I figured I could cook up a few interesting links:
I guess am biased being the son of a scientist and all that.
A new piece from Chomsky.
I also found his blog. Wonder if Chomsky uses Emacs being from MIT. I have always wondered how approachable Chomsky would be to have dinner with my friends. Anyone have his email address?
A new publication: Gnome Journal to keep up-to-date on interesting bits from the Gnome world.
Gnome 2.8 was released: fancier, simpler, cleaner and more hip than ever.
I had dinner with the Fluendo guys in Barcelona last week at Thomas' place days after they had released their Theora Java applet. The quality is very good, and the best thing is: you do not need to install any software on any machine to watch live video streams from Theora servers. They will be happy to sell you a streaming server.
The Gnome Summit announced its dates; this year in Boston will be held in the Stata Center in MIT, the new gorgeous buliding across the street from the Cambridge Novell offices where we work from: Mark your claendars.
Jeff's company launched their new distribution: Ubuntu. Not only they picked a great name for their company, but they are adding timed releases to Debian, I would say the major problem for Debian's adoption (please do not send me email saying `just use sid/whatever' or `Debian testing is great for me').
Evolution 2.0 is finally out according to the state page. But I can not find the official announcement. An overview of some of the new features is here
When I started using C# on the early preview days of .NET, one of the first things I noticed is that the compiler did quite a lot of work to produce helpful error messages.
While implementing MCS, we noticed that it went beyond the obvious internal checks of the compiler: the MS C# team actively had to add extra work to produce a more meaningful error. This is in addition to C#'s definite assignment requirements which by itself catch plenty of errors that are commonly introduced in C.
Recently Marek Safar has been on a quest to refine our error and warnings to produce as many as the MS compiler does and to fine tune our reports. We are not there yet: today we catch 617 errors/warnings, we fail to report 18, and we report differently in 136 cases.
The parsing errors are the most difficult to cope with our compiler as we used Yacc to build the parser and the parser recovery is a lot harder than if you do your own top-down parser (something that we might do in the future).
I did a presentation on Mono last week at the Universidad Oberta de Catalunya, here is the: video.
I was exhausted when I did the presentation, having slept only four hours for the past fourty-eight due to the jetlag, the dinner following up was excellent, I had a chance to talk to a few folks afterwards.
Noticed that Matthew MacLaurin from MS research weight in on Nat's work on the dashboard, WinFS and metadata.
Paco has posted a nice update for those who want to use Gtk# on Windows: simple installers and integration into Visual Studio as well as videos to see for yourself how to use it.
Nat's keynote presentation this morning was excellent: plenty of content packed in the fifteen minutes they had allocated, and they showed some Groupwise integration, F-Spot and collaboration features using iFolder.
The best feature of iFolder in my opinion? Being able to share the folder with myself in different computers: my laptop, my Windows box at work, my Mac at work and my two computers at home. The idea is simple: now all the data gets replicated and I no longer have to worry about which machine has the latest version of a draft.
Massimiliano explains his SSAPRE implementation for Mono. Massi has been working on implementing the large optimizations for the Mono JIT engine.
Gonzalo and Ben have been working on making Mono's ASP.NET implementation scale and perform better. The upcoming 1.1.1 release will contain all the goodies. Get ready to be impressed.
I will be in Mexico City on Tuesday. To reach me, call my US cell phone number, I doubt my local phone works anymore.
Hanging out at the Paris airport, it was about time they had wireless access. Waiting for my plane to Barcelona.
Chris Anderson from the Avalon team replied to some of my points that I made last week
First, let me stress again that I think that the guys over at the Avalon team are doing some fantastic work and probably have had to make some hard decisions and have a lot on their plate.
Cris, As I said in my previous post, if Avalon really takes off, we might look into bringing that API to Mono as well.
My concerns stem from the fact that we do not want to waste our time with dead-end APIs as we are vastly under-resourced, so we must choose carefully. With that in mind, and keeping in mind my bias.
Bruce Schneier has a good introduction to attack trees. The core is that in any system that is to be secured an attacker only needs to choose the weakest link. In this case, Avalon's ClickOnce just seems like a disaster waiting to happen. Imagine Outlook viruses gone wild.
Solving this is extremely simple, the answer is well known: do not allow ClickOnce-like technologies.
My guess is that the problem is that this goes against the fundamental reason for the existence of Avalon.
Joel's latest piece has some good points on the role of software in societies. It seem that engineering organizations are too much in contact with the technical details of how to make things happen, without looking at where and how the software is going to be consumed.
Certain things in the Gnome world have been hard explicitly to avoid problems of this nature (the never-shipped and luckily-defunct executable-mime-type handler is one example).
Anyways, my problem is that it seems that Avalon is trying to do too much too soon. It seems to be following the over-designed footsteps of Java's Swing: it avoids the over model-view-controller-itis, but it introduces its own pains and has the elements of a second system
The surface area is just of gargantuan proportions, sure, if you are dealing with a `Button' you will be fine. But hey, it was relatively simple to build buttons with Motif and Swing too.
You are right that it is unfair to comment on a product that is not even beta, but if you guys are shipping in 2006, I do not see a lot of room to maneuver there. I can only hope I am wrong.
Tk and XView are nice examples toolkits that hide the complexity from the user each on their own ways. These toolkits encapsulated the complexity and exposed only the basics to the user: they provided fairly high-level building blocks and the rest was tucked-in behind the scenes. On the other side, we have things like Avalon where the implementation details transpire at every level: not only is the developer going to use the high-level building blocks, but he will be exposed and will face the internals.
Am not arguing that it is necessarily bad, but it is easier to expose as little as possible and add features on an as-needed-basis than it is to come up with a large framework and maintain every implementation decision made today.
By exposing as little as possible you have a choice when it comes to architecting the internals, and most importantly to re-architect the internals in the future if you must. A clean separate between the exposed API and its implementation. But Avalon does not have this luxury: the API is the implementation and the API transpires very much of the implementation (mind you, this is very convenient for people interested in re-implementing it, while tying their hands to an existing design).
It can only make sense in a world of only-Microsoft technologies, but even there, you are shooting yourself in the foot: collaboration with others might be initially difficult, but it has always paid off in nature.
Collaboration of Microsoft with competitors tends to be difficult. Maybe there are ways we can improve this.
As for missing features, there are ways of driving the standards forward. For example the whatwg group is finally moving the web forward again.
In any case, thanks for listening Chris, and lets hope that you guys can improve Avalon, but in the meantime some folks are considering the options, Joel has two good articles: API war and his call to arms to improve the Web with some followups. Update: Fixed a few typos.
Sebastien has posted an update on CAS.
Our XQuery implementation was born on August 20. Atsushi has posted an update on System.XML 2. You can also see his prototype to call CIL from XQuery.
Due to some other commitments it seems unwise to attend the TG2/TG3 ECMA meetings in Redmon on the week of the 20th.
Am wondering if I should fly in on Sunday to attend the Tuesday meeting. If there are people from Microsoft interested in meeting on Sunday for dinner and Monday (nothing formal, just chilling out and debating software things). That might make for two useful days: one ECMA and one of chilling out.
Thoughts? miguel at novell dot com is the address.
Have to make a decision on the next 48 hours.
Molly Ivins can write very well.
Greg Palast on Choice Point and the DNA database of every citizen:
These guys are in the Fear Industry. Secret danger lurks everywhere. Al Qaeda's just the tip of the iceberg. What about the pizza delivery boy? ChoicePoint hunted through a sampling of them and announced that 25 percent had only recently come out of prison. "What pizza do you like?" asks CEO Smith. "At what price? Are you willing to take the risk?..."
Oh my god! Good thing I get my Pizza from the frozen section at the minimart. I feel safer now.
Some great animations.
I have been using a laptop with 1400x1050 for more than a year, probably two years. Recently I have been considering getting something more hip, to go with my hip nature. Something like the IBM X40.
The only problem I have is that anything below 1400x1050 now feels to me like this:
Associated Press: Beating the last year record of 375 billion dollars, this year the projected deficit is going to be 422 billion.
Taylor just sent this note:
Budget Deficit $442,000,000,000 divided by Workers 141,700,000 (Census Bureau) ---------------- Equals $3119 per worker I hope you all are ready to work extra hard next year. Flak Jackets don't grow on trees.
Economic girlie men with a twist.
Update 2: Am sorry for updating this so many times, but I could not help but make a reflection. The `do not be a girlie man' defense of economic and tax policies sounds as idiotic to me as the defense of the internet boom business models. I can not help but think back at how a few people warned of the coming catastrophe and people laughed at those who were wondering where the profits were and how those things would be sustained.
It seems that the current economic and tax policies are rooted not on careful economic research but in punch lines. That bubble is going to burst.
I will be going to Barcelona on Saturday for the Novell Brainshare conference.
Jordi has also organized a public Mono/Gnome presentation at the University Oberta de Catalunya on Tuesday (September 14th).
Update: The location is: UOC, Avgda. Drassanes, 3-5, Barcelona at 7pm. I will try to drag Nat Friedman along.
Nat in Barcelona last year.
Guardian: On Sunday, the military placed Ms Fahima in detention without trial using a law applied to thousands of Palestinians over the past four years of intifada but rarely to Israelis.
Last week's announcement of the changes in Longhorn were interesting: the backporting of Avalon and the removal of WinFS from the mix.
It was clear that the only way to get Avalon adopted was by backporting it in
some capacity to older operating systems. By June 2004 XP 
had 51%
of the market while 40% of the market was still held by Windows 95, 98, ME, 2000
and NT. This is after three years of XP having being available to the public.
If Longhorn was going to ship in 2006, developers could not target Avalon as their UI for at least another three years, Microsoft's recommendation was just as disheartening. Of course this is assuming that Longhorn would have the same adoption rate as Windows XP.
Incidentally, this was the reason why we decided to redo our Windows.Forms implementation: if Avalon was not going to be common platform for development until 2009 people would continue to target the Windows.Forms API. The announcement from last week closes the gap.
As I have discussed earlier, Avalon is the latest edition of developer lock-in to the Microsoft platforms and the decision making process is driven by this more than technically. If the need arises, it can be implemented in open source as an interop measure, but it is an effort that will take time.
Avalon has a few problems, the following is from my impressions from the latest code that has been made available to the public:
Security: Although Avalon and .NET address the high-tech problem of secure sandbox execution, it fails to provide a low-tech solution for impersonation, and other forms of tricking a user into providing personal information (credit card numbers, Social Security).
These scams are a serious problem today in the Web but we at least have the url bar. But rich clients make this harder for and end-user to distinguish. Of course some simple solutions exist, but nothing comprehensive enough to guarantee that novice users will not be tricked.
The issue at stake here is that the feature (in this case a large API, feature-full and hard to reproduce) is driving the project, with security being cooked as an after-thought. As I said: the high-tech solution has been dealt with (the sandboxed execution environment) but not the low-tech problems. And the low-tech problems are resposible for most of the viruses affecting the Windows world today.
As we have seen, education of the user base is not really a solution and leaving security as an after-thought has proved very dangerous so far.
Complexity: The Avalon API has a very large surface area. To get
an idea, the Button class is number 11 on the inheritance chain with ButtonBase,
ContentControl, Control, FrameworkElement, UIElement, RetainedVisual, Visual,
DependencyObject, UIContextObject and Object as its base classes.
The implementation details transpire everywhere, and approach that I believe is a bad idea: there is little or no encapsulation of things.
Avalon is clearly not fully cooked, at least it was not a few months ago when simple things like keyboard manipulation were not fleshed out. My feeling is that large changes are still required.
Ignoring Standards: I understand why someone would invent their own version of SVG or their own version of CSS: those standards can be difficult to implement, and growing your own version is a lot simpler than having to adapt an existing model to a new model.
I would have probably done the same if I had been in their position: its easy. But I would think that Microsoft has a higher responsibility towards the developer base that must create tools that interop with third party components: creating a new standard for graphics just because its `easy' is not really a good answer.
Implementing SVG might have problems and limitations, but the advantages outweight these problems: there are plenty of tools today to produce and consume it and it fits better with the rest of the industry. A benefit that Avalon users will not have and will just partition the industry again for a fairly poor reason.
Canvas model: Avalon's canvas model suffers from the same problem every other retained system suffers: they are hard to scale in the general case. We know this because Gnome has such system and its the basis for a couple of widgets and controls in applications like Evolution, Gnumeric.
The model is fantastic until you have to scale it; And when you have to scale it, you have to fall back to the traditional programming model where you have to roll your own repaint and handle all the low-level details yourself.
In general, I think its a great idea, but it is a limitation on which the rest of the system is built on.
Lack of a GUI designer: Avalon today lacks a GUI designer, an effort that so far people have not noticed, because developers have been told that XAML is the new way of doing things and declarative programming is hip.
Declarative programming is a cute idea (not new: its just the XML version of the old Windows resource files; or Gnome's glade files or MacOS X NIB files). The reality is that XAML is a serialization format that could be manipulated by tools, but the tools so far have been missing.
My prediction is that Avalon v1 will be a throw-away: it is not really the foundation on which you will build applications: V2 will likely not be backwards compatible, they will have to re-architect bits of it: which means that people will end up with two frameworks running side-by-side: Avalon V1 and Avalon V2.
The above problem is compounded with the fact that the CLR has not really sorted out a good model for sharing components across versions of the framework: the GAC solution today is a bit of a hack to keep things separate and allow for multiple installations, but falls short.
This is like cooking, you can not rush a good steak, or a cake or an omelette by cranking the heat. Some things just take time.
In a way the .NET Framework was like this: it was slowly cooked and it reached a great point (it could still be improved) but some of the new code is just not ready.
In Gnome for example we ship immature APIs but we do not make them part of the developer platform: they have to simmer and marinate for a while before they make it into the official SDK.
When I read Dave Winer's comment on Avalon and the Death March, I realized that the Avalon folks now must do two products instead of one: they need to build an Avalon for Longhorn, and another Avalon that will run on XP. It seems that they just added a pile of work to a team that was not ready to release their software.
I watched Allchin's interview over at Channel9, and he looks nervous: he is addressing two audiences at once the winners and the losers: the external developers who get Avalon on XP, and the internal developers that have just been dumped a new set of tasks and challenges. He is walking a fine line.
I do not think I could have solved a problem of this magnitude, am sure the complexity is huge and the Microsoft folks are doing their best, but maybe a change in the way that features are interlocked and how those are delivered to users must be rethought.
When it comes to operating system releases, I believe that Apple has found the sweet spot: a combination of best practices from the industry and best practices from the open source world. In addition to this, the versioning setup that Apple ships for the Frameworks seems to be pretty good on the surface. Update: I fixed some embarassing typos.
Microsoft comparing, apples to oranges when measuring itself against Linux.
Best quote, from a footnote in the advertisement: "Results may vary outside the United States"
Plenty of Mono activity in the past two weeks in the development branch (1.1.xx: we are using the same numbering scheme as the Linux kernel).
The new managed implementation of Windows.Forms is moving along (internally it uses Win32 messages and codes to help applications that hook up to Wndproc or use CreateParams), the hack-a-thon in Provo, Utah seems to have been a success.
Documentation of Gtk# is continuing at a rapid pace, and we will soon update the online version of the documentation.
Progress is underway on a few major components: Code Access Security (CAS) and the security related infrastructure for .NET 1.x and 2.x by Sebastien. Atsushi has been busy working on our XQuery implementation: a fairly large task but progress is advancing rapidly.
On the JIT side of things, the most important development are the s390 port morphing into s390x (to support the 64 bit machines of this kind) as well as the record-time port of Mono to the AMD64 platform. The AMD64 port was done by Zoltan and is the second 64-bit port of Mono (his SPARC v9 port being the first).
During my vacation plenty of micro optimizations were done to the JIT and Paolo has fixed the exception bug that made throwing exceptions several orders of magnitude slower than it should have (exposed by IronPython). Also Paolo is working on a new trampoline setup that will help the dynamic nature of IronPython as well as enabling some clever recompilation strategies. Also Massi continues work on our SSAPRE implementation, an effort that is on hold while he goes on a two week vacation.
Paolo has also checked in a few plans on changes that we want to make to our register allocator, you can find this on the Mono CVS repository in the mono module.
Martin continues to improve our generics compiler: just when he thought he was done, we received the C5 generics class libraries (which seems to be the largest body of generics code out there) and he is now fixing the bugs exposed by this.
The team in Bangalore continues work on the Basic compiler for Mono, and it is now possible to run simple ASP.NET applications with it. A Basic compiler is more important for ASP.NET 1.x as it does not support "pre-compiled" sites, so a compiler is required on the deployment machine. With ASP.NET 2.x we could eliminate this problem by having people pre-compile their sites and just deploy binaries on the target site.
Chris Toshok from the Evolution team (thanks JP!) will be assisting us with the debugger core in the next few months.
Induce Act: Just learned about the INDUCE Act another retarded law (plenty of coverage here.
Venezuela: Various readers raised an issue with my post about the Venezuelan election and said that if I do not document myself better I should not post to my blog about Chavez. That seems relatively fair, but it misses two points: Greg Palast is a man I respect for his investigative journalism.
But my readers missed a larger point: In fact I do not know enough to advocate a `yes' or `no' vote on the Chavez election (which I did not advocate), but that was not the point of my post. The point of my post was the fishyness of foreign intervention through ChoicePoint in the Venezuelan election. ChoicePoint was the same company involved in removing black-voters from the Florida elections in 2000 (documented also in the great book `The Best Democracy Money Can Buy').
One of my readers in the US claims that the oil production facilities in Venezuela are in the government power, Greg Palast disagrees.
I found out about the results of Chavez election while on vacation. And Greg Palast has a great follow up article.
Right now, the oil majors - like PhillipsConoco - keep 84% of the proceeds of the sale of Venezuela oil; the nation gets only 16%.Chavez wanted to double his Treasury's take to 30%. [...]
But to feed and house the darker folk in those bread and brick lines, Chavez would need funds, and the 16% slice of the oil pie wouldn't do it. So the President of Venezuela demanded 30%, leaving Big Oil only 70%. Suddenly, Bill Clinton's ally in Caracas became Mr. Cheney's -- and therefore, Mr. Bush's -- enemy.
So began the Bush-Cheney campaign to "Floridate" the will of the Venezuela electorate. It didn't matter that Chavez had twice won election. Winning most of the votes, said a White House spokesman, did not make Chavez' government "legitimate." Hmmm. Secret contracts were awarded by our Homeland Security spooks to steal official Venezuela voter lists. Cash passed discreetly from the US taxpayer, via the so-called 'Endowment for Democracy,' to the Chavez-haters running today's "recall" election.
In Mexico at least, it is illegal to receiving funds from an external country to influence the political process. The SI people might be right or wrong, but the whole thing leaves a bad taste in the mouth.
That being said, in Mexico there is an ongoing debate over the monies that funded Vicente's Fox election: a clever setup to bring funds from abroad into his political campaign is under scrutiny.
Dimona: A nice animation of the Dimona Nuclear Complex in Israel. Based on the pictures taken by Mordechai Vanunu and revealed in 1986.
Greg Palast has another detective piece. This time is about "fixing" the Venezuela Election results.
Palast describes a document which landed on his desk:
[Dept of] Justice offered up to $67 million, of our taxpayer money, to ChoicePoint in a no-bid deal, for computer profiles with private information on every citizen of half a dozen nations. The choice of which nation's citizens to spy on caught my eye. While the September 11th highjackers came from Saudi Arabia, Egypt, Lebanon and the Arab Emirates, ChoicePoint's menu offered records on Venezuelans, Brazilians, Nicaraguans, Mexicans and Argentines. How odd. Had the CIA uncovered a Latin plot to sneak suicide tango dancers across the border with exploding enchiladas?What do these nations have in common besides a lack of involvement in the September 11th attacks? Coincidentally, each is in the throes of major electoral contests in which the leading candidates -- presidents Lula Ignacio da Silva of Brazil, Nestor Kirschner of Argentina, Mexico City mayor Andres Lopez Obrador and Venezuela's Chavez -- have the nerve to challenge the globalization demands of George W. Bush.
The last time ChoicePoint sold voter files to our government it was to help Governor Jeb Bush locate and purge felons on Florida voter rolls. Turns out ChoicePoint's felons were merely Democrats guilty only of V.W.B., Voting While Black. That little 'error' cost Al Gore the White House.
An interesting document, worth a read.
In Mexico every effort and dirty trick is being thrown at Andres Manuel López Obrador with overwhelming support from the Media. Currently Mexico City's governor and the man with the popular backup.
This past week to protest the dirty war waged by the federal government against López Obrador a 42-kilometer (26 miles) human wall was constructed running from the South to the North of the Mexico City.
Mexico's federal policies on economy have been a disaster as well. The government is a blind follower of all the recommendations (mandates) from the International Money Fund and World Bank (polices well known to be a recipe for social disaster). Also the government managed to extend our foreign debt, just when you thought that the platform of Vicente Fox on an "Enterprise Government" would be able to keep the budget on track. Seems like running the economy is not the forte of the right-wing economic policies anywhere in the world.
Government's reply to the human chain run from funny to hillarious: `we need production chains, not human chains' stated Sonora's governor (in lieu of the president, which is known for his lack of verbal articulation power and being a master of sticking his foot on his mouth). Humor wise, you can not beat Vicente Fox's own justification for keeping the disastrous economic policies (notice that he criticized his predecesor for keeping these policies, policies that today he defends, follow the link for all the humor ;-)
I will be in Madrid from the 11th to the 13th, then will spend a week in Cadiz.
The next step is Paris, roughly from the 17-20 (depending on weather) to the 22nd.
Great Daily Show last night with Bill Clinton. Clinton had great insight into
Nat has been fairly active this morning replying to e-mail even if he should be enjoying himself outside on this gorgeous day in Boston.
Happy birthday dude!
Duncan sent me this excellent post from Tim Bray on Patents and Linux.
Edd's book on Mono today is #8 on the Internet section in Amazon.
The new Real Player and Helix Player are out, with OGG support. Loving it.
On Thursday I will be on the Dot Net Rocks show with Rory and Carl.
I ran into Rory the other day at the airport. He later came to OSCON to hang out.
Seems hard to believe:
The Department of Justice has called for these five public documents, two of which are texts of federal statutes, to be removed from depository libraries and destroyed, making their content available only to those with access to a law office or law library.
The topics addressed in the named documents include information on how citizens can retrieve items that may have been confiscated by the government during an investigation. The documents to be removed and destroyed include: Civil and Criminal Forfeiture Procedure; Select Criminal Forfeiture Forms; Select Federal Asset Forfeiture Statutes; Asset forfeiture and money laundering resource directory; and Civil Asset Forfeiture Reform Act of 2000 (CAFRA).
They are sweet. Love you guys.
Last week two of my airplanes in a day were broken, so they had to send me through some other airline or some other plane. While waiting for my next plane, I purchased a book of articles from Molly Ivins. I was laughing for the rest of the trip. It makes Clinton even more likable. Larry Flint also has a quite interesting book.
This is a public service announcement: do not watch "The Village".
Must see two-minute video: Will Ferrell as the president. Too many great bits.
On that same subject, I enjoyed my first Gore Vidal book quite an excellent writer.
My quest to learn to play four instruments at once is progressing nicely. I have learned to play 2 notes in four different things. At some point, I expect some kind of magic economic phenomenon to turn me into a virtuoso.
Met loads of people, partly because I have developed a skill for missing every session and hanging out in the public areas. Loved the conference, always good to discuss things live.
Dan Sugalski was a man of his word, and brought a couple of pies for the contest. I do not like Parrot, but the man and his team stood by their word. Guido was a gentlemen and refused to throw the pie. So no pics.
I noticed that Open Source proponents using MacOS X have developed highly tuned excuses, similar to those that smokers have about why cigarettes are good for you.
At this conference I also managed to miss Robert Love's presetntation. This entry is here to mend the offense, and as a public promise to Robert that there will be some intensive picture taking action at his next presentation.
The big announcement yesterday was from Jim Hugunin: IronPython, an implementation of Python for Mono and the .NET Framework was released to the public under the CPL license. It has been a long wait, but it was worth it: Python is a language of choice for many developers because of its ease of use and rapid prototyping cycle, and C# is a fantastic language for component-based and large scale programming, now both languages have come together.
His presentation touched on the challenges of getting a dynamic language like Python to run efficiently on the CLR, and also presented a couple of benchmarks with interesting results: while IronPython on the CLR seemed faster on average with the various tests, with Mono it ranges from 5% to 50% slower (and in a degenerate cases with exceptions, we are 65 times slower). But that being said, it is not terribly slower than Python 2.3, and we are going to look into these issues.
IronPython works out of the box on Linux, and I was able to run Edd's sample out of the box.
Echoing Edd's sentiment: there is a sense of freshness in being able to issue Gtk# commands from the Python command line.
Jim also announced that he is joining the CLR team at Microsoft to improve the VM for scripting languages. Congratulations to Jim on his new job!
Robert is famous for doing the most interesting presentations and for two years in a row I have missed his presentation. Yesterday, I was on a meeting while his presentation was running.
The Mono Developer's Handbook from Edd is out! I got my copy from Edd as they sold out the books that Powell had brought to the show. I was told on the elevator from some O'Reilly folks that today they are bringing a bunch more to the show.
Slides from my Mono presentation are here. These slides were done before IronPython was announced.
I have met another five people who were told two nights ago that they had over-sold the hotel, and they could either take 100 dollars or the free room that they would put them on. The hotel claims its standard practice, but I have never met so many people in a conference that were left room-less. Am staying so far, that I can manage to take a nap from my hotel to the conference and ponder all kinds of deep topics on my trip.
In Dallas I ran into Rory in the airport. All I can say on the McDonalds bit is that I was very hungry, and it wont happen again.
Going to Austin on Monday, then hoping to OSCON in Portland.
I posted a list of areas that we are working on for the Mono 1.2 release. Mono 1.0 has been fairly stable, we will likely issue a bug fix release with a few bug fixes in the next couple of weeks.
Massimiliano has checked a of the Arrays Bounds Check Eliminations to CVS. See his results. This will help with computationally intensive tests. He is now working on a framework to implement Partial Redundancy Elimination for Mono (SSAPRE) as well as prototyping a new relocation feature to improve Ahead-of-Time compiled binaries memory footprint.
In the meantime Ben and Duncan have been doing some optimizations to the code: many small tree optimizations, peephole optimizations and implementing a few tricks to reduce the size of generated code: each one giving a percent here, a percent there. Ben also has started the work to add precise garbage collection to Mono: now we track precisely everywhere where we keep handles to managed memory. The immediate side effect with Boehm's GC is a 3% performance improvement in the MCS bootstrap. For smaller programs, the visible effect is much larger.
On the subject of JITs, Neale's support for s390 keeps on improving, we will likely back port these changes to the 1-0 branch.
 |
We can finally travel again outside the United States. Maria and myself are planning on spending a couple of weeks in Europe visiting some friends in France and Spain (Paris and Madrid will be in the plan). Will be glad to meet folks during our trip. I will also attend Brainshare Europe in Barcelona in September. |
|
Yesterday I decided to use one of those nifty installation images that we have in the internal network to perform an OS upgrade on my machine. The only problem is that the images we have on the network are designed for quick-installs: no questions asked. A tiny bit of information that escaped me as I live life in the fast lane.
This time I avoided spilling the coffee on the keyboard, but I was a few seconds too late to unplug the power and remove the battery of the computer when I saw the message that said `Formatting hard drive'. I was expecting an upgrade, and I got a reinstall image.
Anyways, I managed to recover my partition setup by using a nifty tool called gpart which guesses my partitions (Linux, swap and Windows). But some data was corrupted, after running fsck on the file system, tons of files ended up in lost+found, all kind of very scary error messages were shown up, and many files on my machine ended up with large blobs of zeros in the middle.
Happy for me, I had done a backup of the anonymous method support for MCS, which has not been checked in into CVS, but plenty of e-mail and images that I had not copied to my server got corrupted.
For now, I have decided to install on a separate hard drive and machine.
Jon has posted an update to the baning of his web site from Google advertisement: The Google Freedom of Information Act. His site has some updates on Google inconsistency here
Very nice development platform for GUI applications, which happens to generate code that will run on the Flash Player VM. The widget set is very flash-like, and has the standard set of components you would expect from a widget set, and the components are tied together with their implementation of ECMA Script.
Since the VM is the same across all platforms the code runs on Linux, Windows and the Mac unmodified, I am pleasantly surprised by the results.
Microsoft's Avalon is doing something very similar to this, but the Macromedia markup is not only simpler, but also cross platform from the client to the server.
Chris Toshok has been removing the Java-isms from the Mozilla Sport Model GC.
A GC done in 1998 for Mozilla's own implementation of Java (Eletrical Sheep) which is concurrent, generational, precise and has a C API.
Sport Model is available from the Mozilla tree as: mozilla/ef/gc
The Glitz hackers at Usenix did a mind-blowing demostration of their technology and how Cairo applications benefit from their OpenGL accelerated graphics support.
They have modified the SVG rendered from Cairo as a simple presentations program: wonderful 3D-based transitions, very clearly rendered text, smooth and zoomable.
We vastly underestimated the Slashdot effect. There were 85k hits in the first hour since we went live, and then the machine collapsed under the weight and has remained in that state despite repeated attempts to get some data out of it.
None of the betas really had this problem, we got some mild load, but today the load on the machine was insane.
I made a few posts today: New Windows.Forms plan, the new cvs rules in the post 1.0 world and finally a thank you note to developers.
Mike Kestner has posted an update on Gtk# in the release.
I had a great afternoon at Usenix, met lots of good friends again.
Tomorrow: Rob Pike's keynote at 9am.
The OMG is one step ahead: they have a RFP for the Minimal CORBA. Beautiful.
Apple's new Spotlight is remarkably similar to Nat's Beagle and Nat's Dashboard.
Nat's tool was demostrated yestearday at GUADEC, here is a photo from the talk.
I have been asked recently whether we should fork the C# language and add extensions and improvements to the language and the class libraries to deviate from Microsoft (there are plenty of little small things that can be done with relatively no effort).
I do not believe that making the Mono C# compiler incompatible with the Microsoft and the ECMA standard is a good idea. A big benefit of having a compatible language is that source code can be interchanged between the two platforms with ease. If we were to modify the language to have features not found in the Microsoft compiler, we would make the life of our end users (software developers) harder for no good reason.
On the other hand, I would encourage folks to prototype their ideas on the compiler: if your idea is great, we could help drafting a proposal and bring that forward to ECMA and Microsoft, and who knows, it could even become part of the standard.
I personally did not like the C# language support for nullable types I felt they had no place in the language, and I think a lot of people feel the same way.
I changed my opinion on its usefulness when I explained them to a couple of friends: they immediately saw the benefits to them. It was clear that my programmer background was not the same programmer background that nullable types addressed.
A good friend was asking me about why I had abandoned CORBA (I did not). Here is my response:
On the CORBA question: I have not particularly abandoned the idea of CORBA. It was just that CORBA as a platform to solve the multi-lingual issue was too hard (too huge of an investment, steep learning curve). In fact, I would like to use more of IIOP as a replacement for remoting and web services in key places.
I think that *some* elements of CORBA are extremely useful and are better than many of the Microsoft proposed APIs/protocols, but the problem with CORBA is that you must move carefully: it is too easy to get trapped in that world of standards and try to implement and use everything.
Some bits of CORBA are extraordinary, but teaching it is hard given the large scope of it: what pieces of it must be ignored and what pieces are followed is a tricky part.
I think the Next Generation Web Services (WS-*) world has reached the same level of complexity that CORBA achieved in an effort to satisfy the users requests. It seems that WS-* is a victim of its own success: once SOAP web services could be produced and consumed easily with `netcat', but today, realistically to integrate with any of the advanced features you need a stack as complete and as complex as the various CORBA implementations.
Web Services were pushed in the same direction that CORBA was used, and it started to get used in places where CORBA was used, and they ended up with pretty much the same thing CORBA had, and sadly without some of the benefits of it. Not a particularly fascinating subject.
Speaking of fascinating technologies, a few ex-CORBA people went to create a new RPC stack with a very precise set of features at ZeroC. It is called Ice
I first heard about Ice from Vladimir, who wrote his own implementation of the protocol in C#. It is available from the Mono CVS repository, and is a subset the features offered by ZeroC's product. ZeroC's product is dual licensed: GPL and Commercial and today they support Java and PHP with a C# version in the works.
Having being subject to three years of propaganda, this movie feels like an Oasis.
Too short, seems like a lot of interesting material was left out.
Various reports have arrived that Microsoft was demoing Mono at the LinuxDays. I do not have more data other than a Windows machine was used to build a web application, copied to Linux and ran there and that they also showed Monodoc.
Nice!
Got tickets for the worst possible time for Farenheit's 9/11 showing tonight. I underestimated the demand, all the other showings were sold out.
The Mono Freeze has continuted in preparation for the 1.0 release, everything is looking good.
My friend Jon Perr was running a political commentary site, called Perrspectives and using Google adwords to advertise it.
Here is the tale of the adwords censoring his site.
One of the best Daily Shows today. Jon Stewart was amazing.
Lame Blog now supports Atom using Atom.NET. It supports Mono out of the box (yup, nice Makefile and all), and comes with awesome docs for it. Am still an Atom newbie, so I do not know if I got everything right, drop me a note if my Atom stinks.
It took 10 minutes, so do not expect Enterprise-enabled, transactional based atom feed just yet.
Cory from the EFF went to Microsoft to talk about DRM, here is a transcript which should be mandatory reading.
Joel keeps pumping out the gems.
Most importantly, he follows up with a concrete list of features that the web needs. Now is the time for all good hackers to join the Mozilla development.
A key to the proposal from Joel is that some high-level features must be incorporated into HTML in some form, and not be limited to server-side controls implemented with a particular technology (ASP.NET or Struts or PHP): it should be something that can be placed on a static HTML page.
My favorite conference is coming to town in a couple of weeks. Hope to see a lot of folks
Martin has been doing quite a lot of work on the Mono Debugger, getting nicer every day. And it has docs ;-)
A parser and scanner for VB.NET has been released by Microsoft. It is written in VB.
Kuwait Times: "U.S truck carrying radioactive material caught in Kuwait".
Tehran Times: "The MNA reported for the first time the coalition forces suspicious transfer of WMD parts from Kuwait to Southern Iraq by trucks."
Update: Someone researched this in depth here, and apparently the trucks were coming *out*, not in.
The Cocoa# developers got their first window showing on the MacOS X, and they also got inheritance working. This is a young binding, but here is a screenshot of what it looks like:
Cocoa# sample application.
Ross improved on a script from Matt to do web page thumbnails.
Here is the same written C#, Gtk# and Gecko#.
using System;
using Gtk;
using Gecko;
class X {
static WebControl wc;
static string output = "shot.png";
static string url;
static int width = -1;
static int height = -1;
static void Main (string [] args)
{
for (int i = 0; i < args.Length; i++){
switch (args [i]){
case "-width":
try {
i++;
width = Int32.Parse (args [i]);
} catch {
Console.WriteLine ("-width requires an numeric argument");
}
break;
case "-height":
try {
i++;
height = Int32.Parse (args [i]);
} catch {
Console.WriteLine ("-height requires an numeric argument");
}
break;
case "-help":
case "-h":
Help ();
break;
default:
if (url == null)
url = args [i];
else if (output == null)
output = args [i];
else
Help ();
break;
}
}
Application.Init();
Window w = new Window ("test");
wc = new WebControl ();
wc.LoadUrl (args [0]);
wc.NetStop += MakeShot;
wc.Show ();
wc.SetSizeRequest (1024, 768);
w.Add (wc);
w.ShowAll ();
Application.Run();
}
static void Help ()
{
Console.WriteLine ("Usage is: shot [-width N] [-height N] url [shot]");
Environment.Exit (0);
}
static void MakeShot (object sender, EventArgs a)
{
Gdk.Window win = wc.GdkWindow;
int iwidth = wc.Allocation.Width;
int iheight = wc.Allocation.Height;
Gdk.Pixbuf p = new Gdk.Pixbuf (Gdk.Colorspace.Rgb, false, 8, iwidth, iheight);
Gdk.Pixbuf scaled;
p.GetFromDrawable (win, win.Colormap, 0, 0, 0, 0, iwidth, iheight);
if (width == -1){
if (height == -1)
scaled = p;
else
scaled = p.ScaleSimple (height * iwidth / iheight, height, Gdk.InterpType.Hyper);
} else {
if (height == -1)
scaled = p.ScaleSimple (width, width * iheight / iwidth, Gdk.InterpType.Hyper);
else
scaled = p.ScaleSimple (width, height, Gdk.InterpType.Hyper);
}
scaled.Savev (output, "png", null, null);
Application.Quit ();
}
}
Jeff posted on portability of Java vs .NET code in an article.
First lets state the obvious: you can write portable code with C# and .NET (duh). Our C# compiler uses plenty of .NET APIs and works just fine across Linux, Solaris, MacOS and Windows. Scott also pointed to nGallery 1.6.1 Mono-compliance post which has some nice portability rules.
Porting an application from the real .NET to Mono is a relatively simple exercise in most cases (path separators and filename casing). A situation that I would like to fix on upcoming versions of Mono to simplify the porting (with some kind of configuration flag).
It is also a matter of how much your application needs to integrate with the OS. Some applications needs this functionality, and some others do not.
If my choice is between a system that does not let me integrate with the OS easily or a system that does, I personally rather use the later and be responsible for any portability issues myself.
That being said, I personally love to write software that takes advantage of the native platform am on, specially on the desktop. I want to take advantage of what my desktop has to offer: Gtk# (when using Linux), Cairo, OpenGL, Cocoa# (when using the Mac), GConf, Gnome Printing, and access to Posix.
If my software uses all of the above libraries, will it be easily portable? Most likely not.
Consider what the iFolder team is doing: they are writing the core libraries as a cross platform reusable component. This component is called "Simias" and provides the basic synchronization and replication services. Simias works unchanged on Linux, MacOS, Windows and Solaris. Like every other cross platform software, it must be tested on each platform, and bugs on each platform must be debugged.
This is not different than doing any other kind of cross platform development.
Then they integrate with each operating system natively at the user interface level. Windows.Forms and COM on Windows; Gtk# on Linux and in the future Cocoa# on the Mac.
Although Gtk# looks and feels like Windows.Forms on Windows, the problem that they were facing is that Gtk# was an extra download for people using iFolder, and they chose to keep things simple for the end user.
Although Jeff's post is fairly naive and not that interesting I do have a problem with his follow up: Mono is not just a `Wine-like' technology to emulate an API.
Mono is a complete development stack, with a standard core from ECMA and ISO. Jeff has obviously not written any code with Mono, or he would know that it is quite an enjoyable standalone development platform as oppposed to just a runtime.
Mono is also not limited to run the .NET code, thanks to IKVM: a Java VM written entirely in C# and .NET, we can run Java code just as well as .NET on the same virtual machine, and have them happily talking to each other.
Another interview with Nat on the Novell Linux Strategy.
Nat and Dan in Bangalore.
Laura in Kona
Bangalore.
Arturo is a modern day Indiana Jones, a resourceful humanist. On this picture with his laptop and portable 17" monitor, making up for a hard learned lesson: do not fight gravity with your notebook LCD screen.
Arturo and his C64-like TiBook.
Trailers are now available on Rotten Tomatoes, and a list of dates in the US
Can not wait to see Michael Moore's new movie, opens on June 25th!
Venus Transit on Tuesday.
With Mono Beta2 I was able to get MonoDevelop to work on my Mac.
You must get Mono Beta 2 (0.95), gtksourceview (0.7 Fink), Mozilla (Fink), GtkSourceView# (0.3), Gecko# 0.4 and MonoDevelop 0.4.
MonoDevelop on MacOS X
There are a few Linux-isms in there that you must fix, a quick workaround is to add the following to your $prefix/etc/mono/config file:
Then you must edit $prefix/lib/monodevelop/bin/gdl-sharp.config, this is what I have:
You still need to use GDK_USE_XFT=0 from the command line.
Of course, the real fix is to get MonoDevelop to generate those files (and fix the few incorrect hardcoded references to x11), but I will let Todd do that.
I was named one of InfoWorld's 2004 innovators: here.
Maria in Rio.
Rio.
Mauricio and Laura at the Metropolitan.
At the first day of the ECMA meeting in Hawaii.
Laura and Marcelo in March.
Mark Pilgrim has a great follow up to his freedom-0 article.
Spent some time this afternoon playing with Nemerle and their latest release.
Specially nice since now MonoDevelop supports Nemerle in the built-in editor.
My main problem is that I find it hard to think in any other way which is not the standard programming that I have grown up to do, maybe I need a hobby programming task to do. It will have to wait until we release Mono 1.0, right now things are busy.
My personal wish: I would like a C#-like scripting language myself. Sprinkle a few perlisms, rubyisms and pythonisms in there. Drop the class carcass.
A small patch I have been playing with in my copious spare time is one to turn all unresolved method calls in C# to a dynamic code translation. So basically:
object a = new XmlDocument ();
a.Load ("/tmp/a.xml");
ie, notice that the type of the variable is `o'. The downside: the runtime has to transform the incoming parameters to something that matches the call, you loose the compiler safety net, and its slower. But at least you can prototype quickly ;-)
I do not like the current implementation of anonymous methods, it really does not work in the presence of nested anonymous methods, so I have gone back to the drawing board and have now a new design for this internal chunk of the compiler that am a lot happier with. As soon as the beast compiles, I will upload a new patch.
The C# compiler also gained recently a new flag: -pkg:NAME which integrates pkg-config directly into the compiler. We are making the world a better place, one command line option a day.
Andreas, Ben and Paolo have been discussing moving existing code that we implement in C to the managed world, as our JIT is in some cases as good as the C compiler and the transition from managed to unmanaged is too costly: we can now move more code into the managed world.
The old gcc exceptions mechanism that the Mono JIT used for a long time to speedup calls into the unmanaged world is gone. It was too much of a support nightmare (gcc and libc would often be out of sync, rendering the optimization useless), and instead Zoltan has cooked up some ways to improve the transition cost on x86 and SPARC.
The PowerPC port got a big boost today with various fixes checked in from Paolo; Neale continues to update the S390 port and Zoltan has checked in some fixes to support Linux on the SPARC (in addition to Solaris).
We still need to support the Itanium and the x86-64 CPUs (if you have a good recommendation about a book on these platform, please mail me) as they are important platforms for SUSE.
Lluis completed this week the Thread.Abort implementation for Mono. Our old implementation had various issues if we aborted thread while we were in unmanaged code (since there was no way to clean things up). Lluis' new implementation now shuts down things properly.
Now this might seem like a problem that few people would run into, but the reality is that it happened a lot with people using ThreadPools, ASP.NET or WebRequests since all of them triggered a call to Thread.Abort, and the side effects were ugly: from assertions in the runtime, to hangs at program exit.
This fixes the last major reliability blocker problem we had for Mono 1.0.
Dick in the meantime implemented the locking functionality for Files, a feature that some people needed and that was not really there before.
Joshua has checked in the tools to produce HTML out of Monodoc. Real men use Monodoc, but if you feel like giving up on your manhood, now you can browse uncompressed, not-as-beautiful, not-indexed classes ;-)
They are rapidly closing the last pending bugs in the MCS compiler, none of them are crucial, but we want to ship with as few bugs as possible in the compiler. At this point, we are no longer accepting large changes to the compiler (which also means that Anonymous Methods will just not make it into the 1.0 release, too bad, they were too cute).
Seth has raised some valid points on the patent problem, as it related to Mono.
A big problem with everyone raising potential patent problems with Mono is not that they are wrong in any way, but there are a few problems with it:
Now, it is hard to argue with the nay-sayers about routing around the patent for two reasons: we do not know what might be patented and valid (ie, no prior art can be found or properly articulated) and most importantly for any given topic we can engage in weeks of discussion on what-if scenarios.
We do not plan on infringing patents, and if were to infringe on patent, we will either find prior art that renders that particular claim invalid, or rewrite the code to work in a different form. We do not like software patents, but we will abide by the legal rules.
If you can not think of a different way of running a C# program than the one that exists today, you are not a very imaginative/innovative programmer. The worst possible scenario is not `They will stop distribution forever'. The worst possible scenario is `They can stop distribution until we find a workaround'.
And again, remember, the software patents problem is not limited to the specific instance of Mono. Everything Seth said applies equally well to every bit of our open source stack today: do we infringe on a Microsoft patent? Do *you* know for sure you do not? Have you performed a patent search? On every possible bit?
Red Hat has chosen to adopt Java (despite the same potential problems with patents) and has decided that it is in their interest not to use C#/Mono. Like Red Hat's Seth states: this is self inflicted damage on their part, and they will not be able to ship any of our leading edge GPL code (Simias, iFolder, F-Spot or any of our future development tools).
Red Hat could either stop whining, and have their developers work in Mono and use Mono, and help us fight bogus patents or route around them, or they can keep posting to their blogs more fear-mongering.
Andy Satori has posted his insight here.
If you are going to reply, I just ask you that you take a step back, and for every instance of the word `Mono' replace it with every major open source project today `gnu libc', `linux kernel', `Open Office', `samba', `x11', `cairo', `gtk+', `qt', `binutils', `gcc', gnome', `qt', `mozilla', `my favorite file system', use your imagination.
Does your foe have a patent to it? Or someone that can be acquired by your foe?
Most people operate in Stop Energy mode, so I typically ignore them, and keep moving.
A small story I like to tell people: when I started writing Gnumeric, I was very afraid of one thing: the computational engine. How do we recalculate the value of cells when a change happens? How do we make this perform well? How do we do iterative computations? How do you resolve recursive references?
All of those problems were fairly scary, and I did not have an answer to them. I looked at all the source code I could find for spreadsheets around that time, and none of it did even a remotely good job: it was all pretty amateur, and none of it really did anything remotely close to what commercial software did.
I started work on Gnumeric nonetheless, figuring `When the time comes, I will face that problem', and spent the next three months making sure that Gnumeric was visually pleasant, that it looked like Excel, and that the "feel" was right. I tried to implement computations trivially during that time in a couple hour hack and that failed miserably.
By the third month, I decided I would not touch a computer until I figured out an algorithm for doing these computations, I took a pencil and a notebook and went to write down the steps. Surprisingly after a few hours of work I had something that looked correct.
That same day I implemented the computational engine with the features I wanted and it just worked!
What I like about this story, is that I could have given up at any point since there was a large problem ahead of me: a problem I had no answers to. And I see this with many free software developers, students and even in normal social situations: people stop doing things because they see a big problem ahead of them that they can not possibly conceive working around. My advise to every young programmer is to start writing code and delay addressing imaginary problems until they become real.
I like people who find and propose solutions.
The Mono team (both the community and the Novell employees working on it) is pretty much such a group: a group solving problems, and moving forward.
Ran into this interview this morning. From the Sacramento Bee.
Incidentally, watched For of War this week, McNamara at some point says `We need to win the hearts and minds of the Vietnamese people'.
Kristian Rietveld picked up on the challenge to write a WHIRL to CIL compiler. This means that any languages supported by the GCC WHIRL fork (C, C++ and the two Fortrans) could be used as compiler front-ends.
Kris has a sample of his work so far: a small C program translated to WHIRL (gcc), then to CIL (he had to write his own WHIRL reader.
Congratulations!
A sweet interview with Nat on the Novell Linux Desktop.
Man, I spent some quality time going over the JBoss soap opera. I always felt things were not quite right when I was reading TheServerSide.
Not everyone gets the importance of free software at once. To me the point of no return came when I was using non-Intel Linux machines, and could not run any of the new proprietary Linux software on the Alpha host we had.
The Movable Type licensing term changes have done the same for a new generation. Dive into Mark's Freedom 0 article rings true. The same kind of feeling we had when we started the Gnome project, we decided to not look away with something that was `free enough'.
After five months of delays, Massimiliano Mantione has joined the Novell Mono team. His focus will be on compiler optimizations.
As part of his interview process (which lasted a month), Massimiliano completed the arrays bounds check elimination feature for the JIT compiler. Now that he is part of the Novell staff he is redoing his work to match the current VM.
Plenty of good feedback from the Mono Beta 1. Duncan has been taking care of the packaging things, and as of today we are shipping zip files with all the packages for those of you who did not want to manually download all of the packages one by one.
Novell has just open sourced the Evolution connector to Exchange. The code is available on our ftp server or you can browse CVS.
Congratulations to everyone involved!
Was reading Robert Fisk's latest article and googled for the keywords. Here is the shocking video.
Some cartoons, and a couple of interesting sites: Talking Points Memo and the Media Matters web site.
Jon Johansen's used Mono and MonoDevelop to build DeDRMS, a program used to decrypt the music you purchase from iTunes Music Store.
I tried it out, and I was able to play the music I had purchased on Linux, it is really nice.
Johansen was on the #mono channel, and we got a chance to look into some of the performance issues in Rijandel. Ben noticed something interesting: plenty of our array access was done with a byte value on an array that always had at least 255 elements. So he cooked up a patch that does said ABC elimination.
A more comprehensive patch has been cooked by Massimiliano (who joined Novell today to work on Mono) which hopefully will make it before Mono Beta 1.
A series of dates for the Mono 1.0 have been posted.
Jeff seems to like Cringley's statement of "The central point was that paying too much attention to Microsoft simply allows Microsoft to define the game. And when Microsoft gets to define the game, they ALWAYS win."
A nice statement, but nothing more than a nice statement, other than that, its all incorrect.
Microsoft has won in the past due to many factors, and none of them related to `Let them define the game', a couple from a list of many:
In 1993-1994, Linux had the promise of becoming the best desktop system. We had real multi-tasking, real 32-bit OS. Client and Server in the same system: Linux could be used as a server (file sharing, web serving), we could run DOS applications with dosemu. We had X11: could run applications remotely on a large server, and display on small machine. Linux quickly became a vibrant innovative community, and with virtual-desktops in our window managers, we could do things ten times as fast as Windows users! TeX was of course `much better than Windows, since it focuses on the content and the logical layout' and for those who did not like that, there was always the "Andrew" word processor. Tcl/Tk was as good as building apps with QuickBasic.
And then Microsoft released Windows 95.
The concensus at that time? Whatever Microsoft is doing is just a thin layer on top of COM/DCOM/Windows DNA which to most of us means `same old, same old, we are innovating!'.
And then Microsoft comes up with .NET.
Does something like XAML matter? Not really. But it makes it simple to create relatively cute apps, by relatively newby users, in the same way anyone could build web pages with HTML.
Does Avalon really matter? Its a cute toolkit, with tons of widgetry, but nothing that we cant do on a weekend, right?
Does the fact that its built on top of .NET matter? Well, you could argue it has some productivity advantages, security features and get into a long discussion of .NET vs Java, but its besides the point.
Everyone is arguing about tiny bits of the equation `We have done that with Glade before!', `Gtk/Qt are cross-platform!', `We can get the same with good language bindings!', `We already have the widgets!', `Cairo is all we need', `What do users really want?' and of course `Dont let them define the game!'.
They are all fine points of view, but what makes Longhorn dangerous for the viability of Linux on the desktop is that the combination of Microsoft deployment power, XAML, Avalon and .NET is killer. It is what Java wanted to do with the Web, but with the channel to deploy it and the lessons learned from Java mistakes.
The combination means that Longhorn apps get the web-like deployment benefits: develop centrally, deploy centrally, and safely access any content with your browser.
The sandboxed execution in .NET [1] means that you can visit any web site and run local rich applications as oppposed to web applications without fearing about your data security: spyware, trojans and what have you.
Avalon means also that these new "Web" applications can visually integrate with your OS, that can use native dialogs can use the functionality in the OS (like the local contact picker).
And building fat-clients is arguably easier than building good looking, integrated, secure web applications (notice: applications, not static web pages).
And finally, Longhorn will get deployed, XAML/Avalon applications will be written, and people will consume them. The worst bit: people will expect their desktop to be able to access these "rich" sites. With 90% market share, it seems doable.
Will Avalon only run on Longhorn? Maybe. But do not count on that. Microsoft built IE4 for Windows 98, and later backported it to Windows 95, Windows 3.11 and moved it to HP-UX and Solaris.
The reason people are genuinely concerned and are discussing these issues is because they do not want to be caught sleeping at the wheel again.
Will this be the end of the world for Linux and the Mac? Not likely, many of us will continue using our regular applications, and enjoy our nicely usable and consistent desktops, but it will leave us out of some markets (just like it does today).
Btw, the Mozilla folks realized this already
[1] Although it was easy to see why .NET supported the Code Access Security (CAS) in .NET 1.0, there was no real use for it. With Longhorn/Avalon/XAML it becomes obvious why it was implemented.
Although some of the discussion has centered around using a native toolkit like Gtk+/XUL to build a competitor that would have ISV sex-appeal, this is not a good foundation as it wont give us Web-like deployment (we need a stack that can be secured to run untrusted applications, and we need to be able to verify the code that is downloaded, which leaves us with Java or .NET).
The time is short, Microsoft will ship Avalon in 2-3 years, and they got a preview of the technology out.
I see two possible options:
I think someone will eventually implement Avalon (with or without the assistance of the Mono team), its just something that developers enjoy doing.
If we choose to go in our own direction, there are certain strengths in open source that we should employ to get to market quickly: requirements, design guidelines, key people who could contribute, compatibility requirements and deployment platforms.
We have been referring internally at Novell to the later approach as the Salvador platform (after a long debate about whether it should be called MiggyLon or Natalon).
We do not know if and when we would staff such an effort but its on the radar.
Are there patents in Avalon? It is likely that Microsoft will try to get some patents on it, but so far there are little or no new inventions on Avalon:
I will be doing the keynote at the Usenix Virtual Machine Research and Technology Symposium on May 6 and 7 in California next month.
Am also attending the Usenix Conference in Boston this summer.
Nice new search engine from Amazon.
Greg was nice enough to point me to the PathScale compiler suite: a high performance compiler suite for AMD64. Pathscale's compiler is based on Open64, but has reportedly updated its C/C++ compiler frontends to a recent GCC (as opposed to the current Open64 derivative compilers).
OpenScale is lead by Fred Chow, an ex-SGI developer that created WHIRL, and later Pro64.
So as a starting point for a Managed C++ compiler, PathScale sources might be a better option.
This product shows one of the splits that people were afraid of to circumvent the GPL: the front-ends which are fairly complex (C++) has been split out from the backend and a proprietary highly optimizing compiler has been developed for the AMD64. It was just a matter of time before someone did this though.
A fresh patch and a full tarball for MCS.
I read Anthony Green's feedback on using Open64 as the foundation for implementing a Managed C++ compiler. I respectfully disagree with his opinion.
Let me explain why Open64 is the best starting point for implementing Managed C++.
First, the requirements:
Since C++ is a language of titanic dimensions, it is not one that you want to reimplement. Your best choice is to pick an existing C++ compiler. In the case of the free software community, that means gcc or any of its forks.
The question is whether GCC's internal IR can be retargetted to produce code for the stack-based CIL and whether you can propagate the extra available metadata. The later seems like a problem that we would have in both Open64 and gcc.
Now what makes Open64 interesting is the fact that we can achieve the first goal without touching GCC: C and C++ compilation would be performed with the Open64 compiler down to WHIRL and then a new generic WHIRL-to-CIL compiler is produced that generates the files we want. We do not have to mess or touch any of the existing GCC internals (it is a difficult code base to work with).
The above is very similar to IKVM's JVM to CIL compiler: the input "language" is an IR, the output language is a different IR.
The fact that Open64 does not target the x86 in a way is irrelevant, because we are not interested in targeting the x86. We are interested in targeting the CIL.
If we were to use the current GCC, we would have to intercept a good stage in the compiler, and most likely deal with RTL and produce bytecodes for CIL. The RTL is hard to penetrate and deeply linked to gcc internals. WHIRL is independent, well documented, and has various tools to process, consume and analyze the various WHIRL stages.
Finally there is the point of the FSF and the GCC maintainers refusing to make structural changes to GCC on philosophical grounds. A split that would encourage the creation of proprietary front-end and back-end systems.
Not only does this mean that its better to work with the Open64 fork of GCC which has already made this pragmatic decision and is a better foundation for targeting the CIL, but our goals are more aligned than those of the GCC maintainers.
The latest version of Open64 folded in the changes from Intel and ICT.
Some people think that I wrote the Mono JIT. I did not. Dietmar, Paolo, Zoltan and Martin are the people who have hacked on the JIT engine in Mono.
Recently, as a side project, I have been playing with the JIT a bit to improve some code generation here and there, and together with Ben we are learning how it works internally, it is fascinating to watch it in action.
We have been using a simple example: String.GetHashCode hoping to get things to the point where the JIT output matches GCC -O3. The code is slightly smaller than GCC, but it is wasting two registers, so in a tight loop it ends up placing a local variable on the stack which has a high impact on a tight loop.
Someone on IRC pointed me a few days ago to Open64. A compiler suite that includes C, C++ and Fortrans that generate a new intermediate representation called `WHIRL'.
Some of the compiler front-ends are the GNU compiler front ends that have been re-targeted to generate WHIRL instead of RTL. This is fascinating because it means we can now seriously consider implementing the ECMA managed extensions to C++ (the job of moving to a non-RTL IR was done by SGI).
It also means that any compiler that is moved to generate WHIRL could run on any ECMA VM.
You can get the WHIRL IR documentation from here
This topic keeps coming up: are there tools to manipulate CIL images (instrument code: pre- and post- processing, add classes, remove classes, trim methods, replace methods, append instructions) and sometime ago the fine folks at the University of Coimbra have implemented such a tool: Runtime Assembly Instrumentation Library
The other day Nat and I met David Vaskevitch, Microsoft's CTO. We went dancing.
Blogs are the TV of the Internet. Reading them is fun, but they are not particularly challenging.
Plenty of channels to choose from though.
My e-mail now consists of 40% of spam after it has gone through SpamAssassin, in the mornings or weekends it is 50% of it.
These days I use Mutt to manually remove the spam before I incorporate my e-mail into Evolution where the mail gets split in plenty of folders (and would make spam removal harder).
Is everyone else getting this same volume of trash?
Of course, the big news is that Microsoft has released an internal project called "WiX" as open source and is being hosted in SourceForge. A good move, since it gives a lot of people confidence that the license used is an open source license, without having to spend some quality time reading every sentence of a new license.
From the blog entry from one of the authors you can see that Stephen Walli was behind making this happen. I first saw Stephen doing a talk on startups and VCs at Usenix, on the early days of Ximian, and I remember taking notes frantically. Later I had a chance to meet him at OSCON in Portland.
As I make slow progress on Anonymous Methods on the C# compiler -due to some very embarassing assumption on my part- but most issues have been solved now. Am now implementing parameter capturing and must finish the field access reference from an anonymous method, fix a couple of regressions with iterators and commit quickly to CVS. Martin Baulig has been going through the C# generics spec item by item double-checking that his compiler has everything that we are supposed to have (Generic tests today amount to 20% of our positive tests, and 10% of our negative tests). He has finished with the generics spec as far as the ECMA working draft is concerned, but its lacking some of the latest additions that were freshly submitted in January.
Martin also worked on the new alias features in C# 2.0 and some of that code is already on the CVS tree.
Reflection.Emit is sadly not complete enough to build our generics C# compiler (even with the recently released .NET Framework 2.0 preview) so we had to resort to more hidden methods in our Reflection.Emit API which are only available to our compiler. We hope to post the list of our API needs in case Microsoft is interested in exposing these kind of changes in their implementation.
At the PDC in one of the compiler BOFs, Brad Abrams asked if people had written a compiler that followed the Common Language Specification (CLS) rules and very few people actually said they had. Although we had a C# compiler, we had not implemented the CLS rules for it.
Marek Safar recently contributed the CLS support for our C# compiler. The initial patch is about two months old, we went through various code reviews before the code could land on CVS: the traidional review for maintanability, style and performance was done before we could take his patch. Marek did a fantastic job addressing every concern that Martin and myself had. It turned out that the CLS tests have a minimal impact on compilation time.
Partial Classes is another feature that more and more people are asking about. On the surface you would think its trivial to implement it. And in fact most of it is trivial to implement, except that there is a tiny little clause in the spec that states that type lookup must be performed using the current list of using declarations. The problem is that the list of using declarations might be different from file to file, so in two different pieces of a partial class "MyType" might have a different meaning.
Partial classes are debatable an ugly hack, but at least this rules make sense in terms of doing what the programmer expects.
Implementation wise, it means that we need to do a lot of code shuffling to implement it, and it is not something that we are likely going to have by Mono 1.0.
Erik pointed me to this nice writeup on the usability of Gnome given recent debates on the topic.
I am counting the minutes for Sun to ship our Mono implementation for Solaris. Maybe we can still make it to the Solaris 10 release.
Just picture the benefits, out of the box free C# compiler on Solaris SPARC and Solaris Intel. Out of the box ASP.NET and ADO.NET on SPARC, and the Gtk# bindings for writing applications for the Java Desktop System.
Not to mention that they get the industry's most sexy JIT compiler for free.
I am walking with an extra cell phone battery in case McNealy or Schwartz decide to call me up over the weekend to discuss potential agreements (if I dont pick up, please leave a message, the wonders of ATT wireless).
Thanks to Pedro Santos I got a full list of the Mono Brainshare PPT files:
Notice that the slides that Erik and myself used were slightly different than those that we published for the event, as we continue the long tradition of `Redo your presentation the night before'.
Nat just posted the official Novell position on the toolkits
I just posted this to Slashdot:
As Nat has posted elsewhere, the Heise article is wrong.
My team and other teams within Novell continue to develop and use Gtk as their toolkit (recently open sourced Simias/iFolder for instance) and all of the Mono GUI development tools.
The only use of Qt that am aware of today is SUSE's recently open sourced YAST.
Btw, if you have been following my posts on my blog and on the desktop-devel-list, you will know that my feeling is that all of the existing toolkits today (Gtk, Qt, XUL and VCL) will become obsolete and we need to start looking at the next generation toolkit system.
One of the interesting aspects of Avalon is that they built the widget set on the equivalent of Gnome's AA canvas. Canvas and Canvas items. They call them `FrameworkElements', but it is the same model: once you "paint" something, it stays there (link)
Nautilus had a branch that had some more advanced canvas items than the ones we ship in libgnomecanvas: Andy had written some canvas items that rendered tiny visualizations of a web page, so "web page" links would update live.
Sunil has an amazing tutorial on using the Novell.LDAP library for Mono. To find, go here and search for "DirectoryServices" on the Title. Sorry, the direct link fails.
Jim's paper on IronPython is out, where Jim shows that loosely typed scripting languages can take advantage of the CLR to outperform their interpreter implementations.
My plan was to write a short pithy article called, "Why .NET is a terrible platform for dynamic languages".
Unfortunately, as I carried out my experiments I found the CLR to be a surprisingly good target for dynamic languages, or at least for the highly dynamic specific case of Python. This was unfortunate because it meant that instead of writing a short pithy paper I had to build a full Python implementation for this new platform to see if there would be any hidden traps along the way. Because performance is such a dominant question for Python on the CLR, the rest of this paper focuses entirely on performance issues and measurements.
This document is the result of various discussions with Mono and MonoDevelop users on their needs to build, package and distribute their software by using Mono Develop.
I will update this as the discussion evolves on the mailing list.
Not all software projects handled by MonoDevelop are equal, there is a range of options that must be taken into consideration:
In addition to the above, certain applications must probe for specific features on the target system where the software is to be deployed (C libraries most of the time) or conditionally use one or more assemblies at build time. Only a minority of applications will require this.
We want applications to be self contained, so running an application within MonoDevelop will not cause a full make/make install process to be triggered before it can be executed.
Instead, applications should run from any directory being invoked, and should pull any data files that they require using relative paths to the executable path. Most of the time this is not an issue, since data files can be embedded into the executable as resource files (images, icons, glade, xml resources are common ones).
This is necessary so when a user runs an application in MonoDevelop, MonoDevelop only needs to trigger the compilation and running of the program on its current path for it to be functional.
The master file remains the "cbmx" Combine file. All the information is kept there, and auxiliary files are only generated to allow people to deploy applications without requiring MonoDevelop to be installed.
The generated output from the new build system should be a hand generated configure script that will probe system features and generate Makefiles to compile, install and remove a piece of software.
Probing for optional configuration options will be done using pkg-config
Autoconf and automake are to be avoided for the traditional C# targets, as these systems are better suited for C and C++ development and have their own sets of portability and dependency problems.
The build should be driven by make in all cases. The current infrastructure should be modified to generate the makefiles for the current project before each compilation, and two targets can provide all the needed features: all builds the software, and run would run the execution script for this program.
This means that instead of calling the compiler with a response file that we have hand-crafted, we should produce the Makefile for it that contains everything we need it to build.
The response file can still be used internally by the Makefile to work around possible command-size limitations in Unix, so something like:
Mono programs typically include a wrapper script to invoke them, like this:
#!/bin/sh /usr/bin/mono /usr/bin/program.exe $*
In certain Linux systems it is possible to have the kernel invoke program.exe directly, but this is a feature only available on certain kernels, not necessarily available to users without root access, and it is definitely not available on the other platforms that Mono supports.
Compiled executables for Mono will contain the above shell script to invoke the program. In addition, the shell script could be used to set an LD_LIBRARY_PATH for glue/helper libraries.
Our runtime and class libraries can isolate us from many system specific dependencies but there are still some features that we might want to support conditionally.
For the sake of having a binary that works on every platform out of the box without recompilation, it is sometimes preferable to delay until runtime conditional features like this. Although this might not always be possible.
There are two places where probing takes place:
Today we should use pkg-config to do the heavy lifting in terms of probing for existing libraries: a dialog box can be used to define a library, dependencies and possible the conditional build definitions that are needed.
Probing of low-level Unix features in a way that integrates with the IDE has not been yet studied, but I feel that these must be done in a case-by-case basis: Library probing, method probing, or maybe even adding a hook to insert some shell scripts to do the work.
The probing would be generated into a configure file and would update a configuration file (ProjectConfig.cs for C# code, and ProjectConfig.h for C code). The same files that MonoDevelop would maintain from the IDE, these files basically contain:
During development, when the user requests to run a web page, or a web service should probe for an available port, launch XSP on that port and finally start a web browser pointing to that address.
The only trick is catching when the web browser has been closed so we can return MonoDevelop to the "development" mode and shut down the XSP server.
We could just plainly ignore this and just trigger the execution.
We should add a profile for developing using Java targetting the CLI. This would take care of creating the jar files from the referenced assemblies, use the system javac compiler and invoke Mono with IKVM with the proper arguments.
This should bring into consideration the integration of existing JAR files into the IDE, and call IKVMC to build DLL files out of the system jar files.
The generated makefiles should support a target to ship the source code, a feature that should also be available from MonoDevelop's IDE. This probably can be done as a the `dist' makefile targte.
Creation of an RPM spec file is a possibility, but RPMs are not portable to every platform. Maybe a zip file, or a compressed tar file are options.
Since the packages should allow to be hosted on any prefix location like MacOS applications, it might not be much of an issue.
In a few more hours Erik and myself will be doing the Mono components of the Friday keynote at Novell's Brainshare event.
In spite of his race, that man is extremely valuable to me. He is not some random dingbat I found on the Strip.
You can watch the keynote live tomorrow at 9am MST or you can wait and get the archive.
We'd be fools not to ride this strange torpedo all the way to the end.
The Gnome Users in Spain (host of the largest Linux deployment today) are having the "GUADEC Hispana", their Gnome Users and Developers Conference for the Spanish speaking developers on the 21-23 of May in Almedralejo, Spain.
Chris Stone just announced that Novell will be moving the whole company to OpenOffice by the end of the year, and to Linux on the desktop a year after (I did not see the graph clearly).
iFolder and Simias (A metadata-based file system, with built-in synchronization) have been Open Sourced as well, and you can check it out here. Simias is similar to Longhorn's WinFS and i tis built on Mono.
Nat just demoed the desktop, with iFolder/Simias to share and synchronize the data between a Windows machine and a Linux machine and demostrated the Groupwise support for Evolution and Gaim.
Havoc, you are skipping over the fact that a viable compromise for the community is not a viable compromise for some products, and hence why you see some companies picking a particular technology as I described at length below.
The community can go XPCOM/PyGtk if they choose to (btw, same legal problems apply related to patents on COM ;-), but it is unlikely that the larger projects will pick on this.
You are right that a "wrapper" could encapsulate Longhorn. But I think it will be a useless effort.
No ISV will pick a layer on top of the Longhorn layer on Windows today or tomorrow: .NET is simple, easy to use as opposed to older APIs. ISVs will demand native support for them.
Perl and Python directly support COM and .NET APIs today for interop. Am sure others will agree that why wrap everything in Longhorn, when you can just use your favorite language interop to use those features?
As I said, I still believe that the "Open Source Desktop Components" is a better way of going, more than the "Linux-based Open Source Desktop".
Underestimating Longhorn: Also, we should not under-estimate Longhorn. This is not a traditional OS anymore. This is an OS, that exposes .NET APIs as well as plugin interfaces for classes at every layer of the stack: file system, synchronization, transactions, communications, presentation and a miriad things more. "Wrappers" will hardly cut it here.
Not surprisingly, I think that Mono is the best possible path for ISVs: it allows them to share plenty of code (not all of it if they are aiming at "perfect" integration) between the various platforms with a high-level programming language. With a runtime environment that will let developers take advantage of the APIs in the major market.
So the core of Havoc's thesis can be summed up as:
We need to avoid fragmentation as various Unix desktop companies pick up a platform to develop software.
Sun is a major Linux Desktop player that will never ship Mono, but is using Java. So we should use Java to avoid fragmentation.
Legal and technical details, while interesting topics, are not at the core of this debate.
Novell: At least from this side, there has not been a company mandate to pick Mono over Java for any projects. Individual teams and projects inside the company have picked up on its own merits: iFolder, F-Spot and a few other internal projects which are not public yet. Some other internal projects picked Java for their own efforts.
The community has picked up on Mono/Gtk for a few applications on its own as well, the Gnome Foundation had no saying on this.
In a few areas, we believe that we should use Mono, but avoiding a community splint is an important consideration to us. Our plans to adopt Mono on Evolution are on hold, as well as integrating Mono with OpenOffice (notice that OpenOffice already has hooks for .NET though).
Sun: I will just assume that Sun developers have enough experience, and visibility into Java, that to them it is a natural fit to pick Java for projects, and that there is some degree of company mandate to use it. Am assuming this based on the naming of their Java Desktop System.
Longhorn: Microosft jokes aside, an important consideration for some projects is the fact that Longhorn will be released, will get deployed and the OS APIs have switched from C/C++ to CLR-based API.
In the Longhorn world, APIs are no longer your C/C++ grandmother APIs. Every new API introduced for the operating system is built on top of .NET. If you want to take advantage of it, you must write .NET code.
Writing code in Java is nice for writing code that is portable and uses to the lowest common denominator. But living in this bubble is not an option on Windows.
So the rationale for using Mono in some cases internally has been the fact that in Longhorn, you will have to write code in C#. Even if we have to write different GUIs (like iFolder: it will have three implementations: Windows.Forms, Gtk# and in the future a Cocoa# based one), we still get to share a lot of the functionality below.
Maybe the community does not need this kind of functionality, but most ISVs will, and that I think is a pretty big setback for Java and its Java ways. To survive in the desktop ISV market, Java will have to break with the write-once-run-anywhere mantra, and deeply integrate with Longhorn's WinFX.
If I were Sun, I would be retargetting my JVM code generator on Windows to generate CIL and making sure they can use every single Longhorn API.
I personally think that we should move away from the "Linux Desktop" view of the world, and more into the "Open Source Desktop and Components" (I first heard this idea from Nat a few months ago).
It may sound like a trivial difference, but it is not. As much as I love the Linux desktop, and as much as I love our tools, the most successful desktop components today are OpenOffice and Mozilla because of their cross-platform nature.
Windows NT, XP, MacOS X and Longhorn will be with us for a long time. The best possible outcome of open source will likely be a segmented market like 33/33/33 for the desktop market.
In my opinion Java, Swing, Gtk+ nor Qt address effectively portability to all these systems. And by that, I mean that you always end up with an alien application: either the look, or the integration into the platform is substandard.
Mozilla and Abi to a larger extent got this relatively close to right. The botttom line is: no technology today gives you transparent portability.
The best bet today is to share as much as possible on your "engine" and redo the OS integration components for each OS you support.
Today there is already a major fork on the road.
Audio/Video: Today we got Xine, GStreamer and Helix as platforms for doing audio/media playback with different angles on the problem and no clear way of uniting them any time soon. Not to mention all the different player-level components.
I would love to see a standardized C-based interface that every one of them exposed and allow people to pick one over the other. I for one am not excited about requiring 160 megs of GStreamer code on my machine to essentially play mp3s and CDs.
And having an interface for the above is probably more important than any amount of Gtk+, Java, C# or Python skin on top of it.
Office Suites: We got plenty to choose from here: OpenOffice (in my opinion the only contender for the next three years) and the two smaller open source solutions.
Still, when it comes to engaging the community and pushing in a single direction, we got half the Gnome community pushing for Gnumeric/Abiword. If we can not reach concensus at this level with the community, I think we are going to have a hard problem selling anyone into agreeing into Java or C#.
Ok, gotta catch a plane.
For those keeping up with the language debate in Planet.Gnome, am linking to Paolo's excellent second follow up on the subject. Paolo is not yet aggregated in Planet.Gnome.
Paolo touches on why the ECMA CLI VM is a better VM to pick and describes his gives his view on the patent risks.
Am getting ready to attend the Novell Brainshare conference in Salt Lake City this coming week. This trip agenda is pretty packed.
Am doing two presentations on Advanced Development with Mono as well as attending plenty of meetings with users, customers and reporters. Am looking forward to demostrate some of the latest developments in Mono and MonoDevelop
Sadly, we are not bringing our SPARC to the show to demostrate it, as it is kind of heavy ;-).
Am doing a talk at a local users group, but I can not find the e-mail with the information for my presentation, so if you know what it is, please mail me the information.
Installed the latest MonoDevelop from CVS. It now comes with integrated Mono Documentation (from MonoDoc) and the Mono Debugger.
Discovered Blogs at MSDN, fascinating stuff on all things .NET related. For those interested in tracking Avalon and XAML, you also should check out Longhorn Blogs.
If you see this from Planet Gnome, you might want to read the rest from the source since it keeps the nice CSS.
So today I figured it would be an interesting excercise to write a small Gtk# application with Java. To do this, I used IKVM the Java VM implementation that runs on top of .NET and Mono.
There are two possible ways of using IKVM: one is to use it as a Just-in-Time compiler which translates the Java bytecodes into .NET Intermediate Language as it goes. But this means that at runtime you are compiling things twice: the Java-to-CIL JIT and the CIL-to-Native JIT.
Gtk# is really a bad name. Because Gtk# is not limited to C#, any programming language in the .NET framework can use it today and because it covers more than only the Gtk API, it covers various other components of the GNOME Development Platform.
First, you need to get your hands on Mono and Gtk#, you can get these from Mono Download page and Gtk# from their sourceforge page, or if you are lazy like I am, you use the packages on Red Carpet.
The next step is to download IKVM.
Now, Gtk# is a .NET assembly (this is the ECMA lingo for "library"), and Java does not know anything about this. It is necessary first to generate some stubs for these classes to let the Java compiler knows about the types defined in the C# world. This is done using the netexp.exe program from IKVM, like this:
$ mono netexp.exe /mono/lib/mscorlib.dll
$ mono netexp.exe /mono/lib/gtk-sharp.dll
$ mono netexp.exe /mono/lib/glib-sharp.dll
$ mono netexp.exe /mono/lib/atk-sharp.dll
The above commands basically "imports" all of the types and their definitions into something suitable for Java to consume, the result is:
$ ls *.jar
atk-sharp.jar glib-sharp.jar gtk-sharp.jar mscorlib.jar
The netexp.exe program will import all of the types into the "cli" namespace. So if you had a class called "Gtk.Window", it will be exposed to Java as "cli.Gtk.Window".
So I begun with a small Java program, I had to Google for Hello World, since I did not remember much of Java, and I have to say, I am still not comfortable with the classpath thing. Anyways here is my sample little program:
import cli.Gtk.*;
public class Demo {
public static void main(String[] args) {
Application.Init ();
Application.Run ();
}
}
To compile the above program type:
$ javac -classpath gtk-sharp.jar Demo.java
This produces a Demo.class file that contains the Java bytecodes. The -classpath file instructs the Java compiler to find the type definitions on the gtk-sharp.jar file that we had previously produced with netexp.exe.
Now, it is not possible to run this directly in Java, since the jar files produced by netexp.exe are only stubs, so we will need to run this in the Mono world using IKVM in JIT mode:
$ mono ikvm.exe -classpath .:gtk-sharp.jar Demo
The above just sits there waiting for events, so feel free to kill that. We will now add some meat to the program, this is a slightly more interesting sample:
import cli.Gtk.*;
import cli.GLib.*;
public class Demo {
public static void main(String[] args) {
Application.Init ();
Window w = new Window ("Hello Mono with Java#");
Button b = new Button ("Click me");
w.Add (b);
w.ShowAll ();
Application.Run ();
}
}
To compile, you will need to reference the libraries we created before:
$ javac -classpath 'gtk-sharp.jar:glib-sharp.jar:atk-sharp.jar:
mscorlib.jar:.' Demo.java
This will produce Demo.class, now run it:
$ mono ikvm.exe -classpath .:gtk-sharp.jar Demo
The result is shown here:
The above is basically translating Demo.class from JVM bytecodes to ECMA CIL, then the Mono JIT translates that into native x86 code. The next step is to precompile the Java code directly into .NET code, which will skip the double JIT process:
$ mono ikvmc.exe -reference:`pwd`/classpath.dll Demo.class \
gtk-sharp.jar
$ ls *exe
Demo.exe
$
The above compiled the code directly into a a Mono/.NET executable, to run it, just do:
$ mono Demo.exe
But we can go one step further. We can avoid completely the JIT process by precompiling the .exe file which contains instructions in the ECMA Common Intermediate Language into native x86 code using Mono's Ahead-of-Time compiler, to do this, type:
$ mono --aot Demo.exe
$ ls Demo.*
Demo.class Demo.dll Demo.exe Demo.exe.so
The Demo.exe.so contains the native x86 code. Mono still requires the Demo.exe file to be around to extract metadata, but the Just-in-Time compiler will not be used in that case:
$ mono Demo.exe
Mono detects the shared object file and resolves methods to those contained in the image file. You can see the native code generated by using the objdump command:
$ objdump -d Demo.exe.so
...
Caveat: in some versions of IKVM references to System.IntPtr are turned into gnu.classpath.RawData, and your program might not compile in the javac, to fix this problem do:
$ echo "package gnu.classpath;" > RawData.java
$ echo "public class RawData {}" >> RawData.java
$ javac RawData.java
$ mkdir -p gnu/classpath
$ mv RawData.class gnu/classpath
Mono and IKVM depend on the GNU Classpath, so it is as complete as open source Java, but you get the added advantage of accessing any Mono/.NET libraries as well.
Today Mono/IKVM can run large applications like Eclipse, Jython and JBoss. Screenshot of Eclipse running on Mono.
I was asked to post this on my blog, a copy of a post from the mono mailing list. This is slightly edited from the original:
The fear that people have on Mono's legal issues apply equally as well to everything else. Let me explain. Sun owns various patents on Java, and they might just feel at some point threatened enough to use them as a weapon against open source. In the same way people feel that Microsoft might pull that trigger. Just to put things into a different perspective: Sun has litigated over Java in the past (against Microsoft) over a contractual dispute and has done threatening legal moves against JBoss at some point (which I do not claim to understand) over bits of J2EE. If Java on Linux became a threat to Sun, would they use their patents? I do not know, and I hope not. Am only illustrating the point, just like other people have vehemently illustrated the Microsoft patent risk before. There is nothing in Java that makes it any safer than Mono at this point. We do not have any guarantees, any written statements, any guarantees that Java on Linux will not be sued under certain conditions. Microsoft has granted RAND+Royalty Free licenses to any patents they might own that are required to implement the ECMA 334/335 standards. So at least our core VM, classes and compilers are safe from any litigation from *Microsoft*. Now, pay attention to the above, because it is important. The fact that Microsoft has given access to any patents they might hold on .NET does not mean that a third party that has a patent that is required to implement ECMA (or Java) will grant that license. Why does this matter? Because we just do not know if someone has a patent on pieces that Java and .NET implement. There might very well be one that we are not aware of. The patent might remain sleeping for a few years before someone decides to profit from it. And the above is important. It is important because even with a fully re-engineered virtual machine, runtime system and the rest, we do not know if you will not be infringing on a Sun, Microsoft or third party patent. With the current patent situation, it is probably impossible to ask small startups or individual developers to do a patent review before they make decisions on how to implement their software, only very large companies might afford it, and believe me, even with vast resources, you might be taken to court by an unknown (Eolas patent for example) or by a law firm who focuses on purchasing dormant patents and litigate them. Nat used to say "If you write a thousand lines of code, you are violating someone's patent today". The picture is not pretty for anyone in the software industry. But this is similar to what happens to biology students: on their first four semesters as they learn about all the dangers, infections, vectors for infections and bacteria, they stop eating everything, they start washing their hands with special products, they double clean their utensils, they wash their fruits ten times a day. Two years later they are eating food with their bare hands again.
Paolo has written some follow up comments to Havoc's language advocacy post today.
A report on the 237 missleading statements made by the Bush Administration on the threat possed by Iraq is now available from the House of Representatives Web Site, it includes a nice PDF with the report and graphics and a searchable database.
Last night Zoltan Varga checked-in his last patches that complete the Mono JIT port to the SPARC (with Solaris). The system passes all of our regression tests, and bootstraps Mono from scratch.
We had support for SPARC v8 and v9 as an interpreter, and some early work had been started by Mark last year. Zoltan picked up on the job on the first week of February and got the port done in marginally more than a month.
With three JIT ports now (1 CISC, 2 RISC), most of the portability issues on the JIT must have been taken care of.
Edd has written a fantastic article on the Mono Meeting. The Slashdot peanut gallery has initiated a flame-fest over the comment that to me C is dead.
The Gnome Notifier is definitely not a production system, it is a toy that illustrates a simple way of sending notifications to the system (some other people have discussed this before. Ideally a more complete system would have a history mechanism, and a way of browsing/answering previous messages.
For example, the most annoying problem I have with GAIM (My Instant Messenger in GNOME) is that whenever there is an interaction (you got disconnected from a remote site, or someone added you to their buddy list) a pop-up window shows up. This pop-up window shows up in the middle of your typing and grabs the focus. If you are writing code, writing an e-mail or doing any other form of typing, you are likely going to accept whatever is the default button by mistake, as you press the spacebar. Not to mention that you will have to re-type a few letters.
What I would like is for someone to integrate that into the Panel in some form, patch Gaim and all the other offenders, and have a way of getting back all the pending notifications.
I believe strongly that the Gnome Human Interface Guidelines should incorporate notification patterns and practies in their document, the following comes from the UI talk at the Microsoft PDC where there is a nice classification of user interaction:
Spectrum of Interaction Possibilities, from the PDC
Very sad news this morning; An outrageous attack on Madrid. Speechless.
This is a quick hack that I put together in December 2002, a small notifier that looks like the Windows XP notifier with a nice little scrolling thingie. Someone asked me today about this hack, so am uploading it here.
The notifier embeds HTML with a few small tags that get displayed.
The nice trick back then was that you can send notifications to it by changing a Gconf key. You can then send notifications using the gconf api from your favorite language or from the command line language.
To use it today, do:
$ gnome-notifier &
Then to do notifications, you call a command line tool:
It supports a cute little prefix "run:", which does the obvious:
notify is just a shell script that calls gconftool.
Ideally this would be incorporated in some form into the panel, and with a history mechanism, you could use that to replace things like Gaim's annoying notifications.
So someone has implemented a XAML-like stack for Windows.Forms. Just to be clear on the danger of XAML for the Linux desktop: it is not about the markup language being a problem: its about the fact that XAML developers would create XAML applications that are bound to the Avalon toolkit.
So it comes down to: No Avalon, no app.
Benjamin Wootton has been working on Mono's Code Access Security (CAS) support. CAS is a way of creating arbitrary "sandboxes" in the .NET environment. The idea here is to load and execute untrusted side-by-side with your trusted code code without compromising your application. Similar in spirit to Java's security model.
CAS is needed for the various "click-once" setups for downloading, running and updating applications over the web, but more advanced uses enable scenarios like running untrusted plugins in a trusted application (for instance, a file format importer downloaded from the network, or plugins for your application which you do not necessarily want to trust).
You can read his list of requirements here; The project status page (with all his patches to add CAS to Mono) and a screenshot of his Mono CAS Configuration tool.
I have been working on anonymous method support for the compiler in stages. My latest patch for the curious lives here.
The first one was to implement the implicit method group conversions to delegates, that one allows you to write things like:
void Method ()
{
button.Clicked += clicked_handler;
...
}
void clicked_handler ()
{
}
The second stage was to handle anonymous method declarations inline, and move the body of the code into an helper method in a chunk like this:
void Method ()
{
button.Clicked += delegate {
Console.WriteLine ("hello");
}
}
Until that point things were relatively simple, the next step was a lot more tricky, and it involved capturing local variables:
void Method ()
{
int i = 0;
button.Clicked += delegate {
Console.WriteLine (i);
}
}
The above code needs to be compiled into something like:
void Method ()
{
Locals1 __locals = new Locals1 ();
locals1.i = 0;
button.Clicked += locals1.__AnonymousMethod1;
}
class Locals1 {
int i;
void _AnonymousMethod ()
{
Console.WriteLine (i);
}
}
Things get more complicated when you add multiple levels of scopes to variables:
void Method ()
{
for (int i = 0; i < 10; i++){
int j = 0;
button.Clicked += delegate {
Console.WriteLine (i + j);
}
int z = i + j;
}
}
The above needs to generate roughly this:
void Method ()
{
Local1 locals1 = new Locals1 ();
locals1.i = i;
for (int i = 0; i < 10; i++){
Locals2 locals2 = new Locals2 ();
locals2.locals1 = locals1;
locals2.j = 0;
button.Clicked += locals2.AnonymousMethod1;
z = locals2.locals1.i + locals2.j;
}
}
class Locals1 {
int i;
}
class Locals2 {
Locals1 locals1;
int j;
void AnonymousMethod ()
{
Console.WriteLine (locals1.i, j);
}
}
So fairly tricky: the variable can be accessed from the method containing the anonymous method.
One of the trickiest parts is the process that guesses the return value for the anonymous method: it might seem like inference is at work, but in fact during the resolution process we know the type we requiere, so the compiler triggers the resolution of the inner block when it gets this information.
Another complex bit was that the resolution/emit phases of the compiler had to be completely decoupled (they were already partially decoupled) because it is necessary to identify any variables that might be captured before we can even generate the first line of the block.
The patch is my work-in-progress code, it can not be checked into CVS just yet, since it breaks the iterator support in the compiler, so that must be fixed first.
I need to finish my write up and post the pictures of the event, but that will come later ;-)
This week the Mono Novell hackers have met for the first time in Boston, and we have been discussing the various tasks that need to be completed for Mono 1.0 and 1.2. IRC has been relatively quiet, and the exchange of ideas and discussions in town have been great.
The good news: we are on schedule for the 1.0 release, with a very nice cushion to test things. The only areas that are going to be very close to the deadline are System.Data and System.Drawing.
We got a few folks explain their areas of work to the others (so far I attended the meetings on security, remoting and the debugging session).
Duncan has been leading the release engineering meetings and laying down a process for the ongoing builds, and the 1.0 release packages.
Martin, Mike, Todd and Daniel are busy working on a small surprise for MonoDevelop, that they are hoping to demostrate on the open house this Friday/Saturday.
Windows.Forms is alive again! Peter Bartok demostrated various applications working with the new Wine, and together with Jordi Mas, they are resolving the various rendering integration issues between Libgdiplus (cairo) and WineLib (Wine turned into a library).
I read with interest Edd's thoughts on XAML and a new UI for GNOME. I have been doing some small XAML tests recently, and it is a very easy markup to generate. As I mentioned before the issue with XAML is that it will be very attractive to developers to move from HTML to XAML, as it provides more control, more widgetry and is an extensible system.
The future of Linux on the desktop is in fact on the line: if enterprise developers and IT developers fall in love with Xaml for building their in-house applications it will marginalize again Linux on the desktop.
There are two views of how to solve this problem. The Nat Friedman view of building a matching system in the meantime: leveraging our existing technologies, or the Miggy-view, which is lets implement the Avalon/XAML API. I think we should pursue both paths.
New article on the Israeli wall.
Monday flew in-and-out of Denver; Followed by XML Edge panel yesterday in Boston, where I had a chance to meet again Margo from Sleepycat.
Next week will be twice as crazy: all of the Novell Mono Developers are descending into Boston for a whole week of meetings and working together. This is a historical event, since the team has never met before face to face (only a few of them have met).
On Friday and Saturday we are hosting an open house event for folks to come and meet with the team and learn a bit about Mono. We have now an agenda for the meeting.
Duncan shared a few links with me today Rumsfeld Fighting Technique and this. From Dare, I found a nice post from Aaron: How Stating the False Hides The True
Am in the international Open Source Conference held in Malaga in Andalucia. Andalucia and Extremadura are the two states that have adopted Gnome across the board: education and government. There are 400,000 users in these two areas (20% of the Extremadura population are Gnome users) and have around 100,000 Gnome desktops deployed.
This is a very big number of Gnome desktops deployed. This might be the largest Linux desktop deployment in the world (China will follow later with the Gnome-based JDS system next year).
This is entirely a Debian/GNOME setup, and there is a local industry that has emerged out of this: various small companies here are providing the support to the governments of Andalucia and Extremadura (Will get the name of the consortium of open source companies tomorrow, because right now I forgot).
They have developed quite a set of interesting tools: from back-porting changes to the stable version of Debian (addressing one of Debian's weaknesses) to developing tools to manage large network deployments (similar to Red Carpet's enterprise features, but for Debian) and a nifty tool to create bootable distributions and turn them into CDs that people can carry around (metadistros).
There are tons of stories floating around, and people very excited about this technology. From the kids that after doing their work in school ask the teacher for permission to use the "Guadalinux" (this is the name they use to refer to the Linux machine, based on the distribution name) to the class rooms that are now entirely quiet due to the kids playing with the "Guadalinux" systems.
Also grandmothers refer to the web as "mozilla" they pronounce it "mo-ci-yha", as in `I found in mo-ci-ya that you can do this and that'. Very interesting stuff.
During a few conversations with the various officials and engineers that work on this project, I have mentioned that they should probably should join the Gnome Foundation's Advisory Board, something that I think we should fast track. I asked the education secretary if they had any issues with Gnome, and if there was something we could fix, or improve for them, and they said `So far we have not had problems with the teachers'. A good perception.
The technical guys on the other hand had a few requests: from Evolution failing to send SMTP mails in some occasions (we should investigate this) to better integration with the braille stack in the accessibility framework (accessibility here is very important due to a fairly strong Spaniard organization called "La Once").
My friend Charles Curran from the UK Linux Users group is also in town, he is now living in Sevilla, and came to the meeting. It was very nice to see him again.
Lastly, about 30 Gnome Developers from the "Gnome Hispano" got together in the afternoon to meet and discuss. I learned that a "GUADEC Hispano" is being planned for May in Extremadura.
The Mono presentation went fairly well, I was still a bit tired from the jetlag, but it came out OK. I updated MonoDevelop from CVS, and things worked out of the box: I demoed the intellisense feature which is just a great way of developing Gtk# apps.
While jetlagged and unable to sleep, am checking out the Nemerle language. A functional language designed by Michal Moskal for the .NET Framework that works out of the box in Mono.
This compiler is self-hosting, which is fascinating. Worked out of the box on Mono 0.30
A fascinating product from Mainsoft has been released: Visual MainWin for J2EE.
This product lets you run your ASP.NET applications written in C# or VB.NET inside a J2EE application server and integrates beautifully with Visual Studio.NET. All .NET applications can also use EJBs and reference Java classes, you can see a live Flash demo of it.
Mainsoft has been using Mono's class libraries to deliver the functionality and they are regular contributors to the code base. We wish them much luck with their new product.
I will be in Madrid on Monday and Tuesday (busy all day until dinner-time).
Cena el Lunes, Comida el martes: Si están en Madrid, por favor pónganse en contacto con Juantomás o Roberto Santos para que nos juntemos para una cena el Lunes o desayuno/comida el Martes.
Jon Perr who used to work for us at Ximian has launched a new web site.
Been doing good progress with anonymous methods, but last night on the plane on the way back home, I discovered a big problem with my design (I had a fairly clever way of computing the right return type in an anonymous method).
My clever hack was to hook up to the standard conversion code: anonymous methods are generated during the implicit conversion code. The problem with this approach is that it was too late to capture variables.
Am right now toying with overloading the implementation of Field expressions and LocalVariableReference expressions to handle the lifting, rather than the clever CapturedVariable expression which I was using before.
Marek has been cleaning up the compiler internals to turn our compiler into a CLS-aware compiler, now we will be able to flag CLS violation errors. His fixes includes long-standing wishlist items to refactor the interface members to become regular MemberCores (which they do now) and refactoring some of the attribute emission and gratuitous differences in constants and fields that we had in the code.
Am visiting Novell's main development offices for the next two days. If you are here and want to talk about Mono, drop me an email.
After yesterday's release of Mono 0.30 I finally had some time to look into what the guys have been up to with MonoDevelop (the port of the venerable SharpDevelop from Windows to Linux).
To my surprise, MonoDevelop is fairly advanced, and I was able to do all of my MonoDoc development on it today:
MonoDevelop with a fresh project for MonoDoc
I was improving the file format for our Index, as well as some touch ups to the collaborative framework in MonoDoc:
MonoDoc's index
Here is what the collaborative documentation editor looks like now:
The MonoDoc embedded editor.
I have most of the anonymous method support written now. Now the time for debugging has come.
My excuse for being there for almost a week was the ECMA meeting for the CLI and C#. As Brad pointed out, there are now two public mailing lists for providing feedback and discussing the ongoing work of the ECMA CLI and C# standard efforts, you can subscribe to them by going here for C# and here for CLI
During the meeting there was a set of "interesting" proposals to the C# language, and I have come up with my own, watch this space for them.
After the ECMA meetings were over during the day, I would run to the beach and do some all-amateur snorkeling action: the hotel where we stayed at was packed with multi-colored fish and large turtles that would swim next to you, minding their own business.
At Ximian we developed a tool to build, package, sign, qa and distribute the Gnome desktop, which we refered to as "Build Buddy". This week it was released as GPL software.
Build buddy uses an XML-based configuration file similar to the RPM spec file to describe how to build a package and apply optional configuration options and patches depending on the target operating system. It can work on a cluster of computers and can also run various builds for different operating system on the same machine by using chroot-ed environments (we call those "jails").
We will be moving our XML build files to the public CVS this week.
Nat pointed me to the Scoop proposal. We have been talking about implementing this kind of functionality to solve the issue with the IM client in Gnome poping up all the time, and handling other notifications that the system has for quite some time. The mockups in that site are a great starting place.
Went with Duncan and Robert to see Fog of War featuring Robert McNamara. A media rich movie, surely inspired by his book on the Vietnam mistake. Gorgeous music by Philip Glass. Obligatory watching required.
Dude, if you read this, please return our salami and cheese. We checked your fridge while you were out, and you have to dispose those tomatoes you got six weeks ago, they are starting to smell.
Sometimes I get advise from random people on writing code.
The Independent/UK is running the Real State of the Union report.
A research project called DaCapo implemented a memory management toolkit in Java for the Jikes Java VM. This GC engine looks fairly good.
One of the fascinating things about Jikes's JIT engine is that it was completely written in Java. Absolutely mind-blowing. The upside is that many things can now be done in a higher-level language than C like JITing and garbage collection, the downside is that these systems are fairly heavy during compilation time and are best suited for server use and not desktop use.
A balancing act would be fantastic.
In Mono a few months ago we discussed a few possibilities on implementing more code in the managed world for the JIT engine. One of the options is to expose our current IR, and perform a few optimization in the C# world who could mutate the IR and keep the two existing layers: CIL to IR and IR to machine code to remain intact.
To make the above balanced, we could invoke the C#-based optimizations only conditionally, for example, when doing Ahead-of-Time compilation of code.
I turned the TV on, to Bush saying that abstention was the only way of fighting STDs, followed by an applause. Oddly, I was not tuned to Comedy Central.
Little is known about the new intermediate language that Sun is working on. All I know is that Guy Steele is involved in this effort.
The story has various interesting elements: a new intermediate language for high-performance computing; A call to get IBM and Cray involved into the architecture/design of such an intermediate language, a new language (or maybe a language extension) to take advantage of these features and finally because they want to create an industry standard out of it.
This is interesting in many levels: first, it could be a departure from Java's current focus of compatibility. This policy of VM compatibility, while good for software developers, and to Sun's story of write-once, run anywhere has also lead to the stagnation of the VM specification, and the intermediate byte code language. Which is a source of criticism from people who want a performing intermediate language. Today the Java intermediate representation can not be effectively used as it is for high performance code.
But Sun has the engineering talent, the knowledge, and the team to turn their expertise in optimizing compilers into a new intermediate language that would better suite the Fortran/C/C++ developers.
I of course would love to see the ECMA CLI be the foundation for this work, but if I were in their shoes, I would probably begin by extending the Java byte codes towards supporting features from the Sun IR for their optimizing compilers, or extend the Sun IR to support object-oriented features that could support Java.
Maybe Sun is interested in going through an ECMA-like process to standardize this intermediate representation. Am looking forward to learn more about this project.
My interest in this comes from the work we have done in Mono and Mono's IR. Although we are very proud of the code generation engine we have, it is still in its infancy in terms of the optimizations we can perform. I guess I would love to learn how Mono can benefit from it, and even maybe be able to consume this IR.
Today I implemented the Method Group Conversions finally, after getting some clarity of mind. The patch was relatively short, mostly shuffling existing code around. So it is now possible to write:
Button b = new Button ("Hello");
b.Clicked += handle_click;
...
void handle_click (object o, EventArgs e)
{
}
Specially interesting to Gtk# developers, since the plan is to move the delegate signatures from the GtkSharp namespace into the class that defines the delegate, so people will be saved from writing:
// What they would have to write:
b.SizeAllocated += new Widget.SizeAllocatedHandler (handler);
// What they can write:
b.SizeAllocated += handler;
void handler (object o, SizeAllocatedArgs args)
{
}
I talked to Martin today for a while about the debugger. It is finally back in shape: it can debug managed an unmanaged, so people can use it to debug the JIT. The bad news is that it requires an NPTL threading system, which is only available on Red Hat 9 or with 2.6 kernel installations.
One of the limitations of the debugger is its current command line language is yacc-based and grew organically. It is not really great for interactive work.
I have been pondering what to do about this: an option was to use JScript, but its not ready. Another was to use something like IronPython, but that is also far away, and another is to roll-a-tiny-command-line-system.
Am leaning towards rolling our own command line language, my struggle is between a few models:
Each model has its beauty, and it is hard to make a decision. Will roll the dice next week.
On top of that, I want the command line processor to perform some parsing for us, so we can type:
(mdb) b -thread 4 Main
In C#, the "break" command would be implemented like this:
class Break : Command {
[Argument] public int thread { get {} set {} }
public Break (string [] args)
{
}
}
So the thread property would be set to "4", and the Break command would receive { "Main" } as an argument.
I installed Mono on MacOS X. This is the first time that I use a Mac for doing development. A few impressions: The Mac UI is incredibly pretty, am glad the Gnome folks are using this as a model to follow. After using the Mac, Longhorn and XP feel cheesy, and Gnome feels rather professional, but not as complete.
Now, the big downside of the MacOS is their kernel. This is on a machine that is faster than my laptop, and still takes three times as much to build the Mono C sources.
The problem can be tracked down to their Mach kernel. In a way its good, because it makes us look much better for server and heavy duty use. On the other hand, if they did not have Avi from the Mach team running their decisions, that kernel would have been long gone and Linux or FreeBSD kernel would be used instead.
A few years ago, I looked into implementing the Mach-O file format, its a primitive beast, it should not be hard to implement that and implement the few things in Linux that MacOS needs to get their UI tools running on a decent kernel.
The new alpha GC from Hans Boehm works on MacOS with Mono, which addresses one of the big problems people had. Mono-wise: there are a few JIT failures with OS 10.3 though while things work on 10.2.
To assist in the debugging, I started learning about the PowerPC architecture. So far I have only seen two nice things about its design (the conditional register files, and the summary overflow bit,) but the choice of opcode names is the worst I have ever seen. Psychologically it has the effect of making me think `This instruction set sucks'. I might be wrong, it might be just a perception thing, but having used the SPARC and the MIPS in the past, which are pretty beautiful designs, you are left wondering about chips designed outside of universities.
Jordi Mas is joining the Mono team on Monday. He will be working on GDI+ and System.Drawing, that will be a good first task for him. In the meantime, Peter Bartok is taking over the gargantuan effort to make Wine-current work as a library, and make it use Cairo in the X11 backend to solve the fight we had between those two.
Lluis has checked-in th esupport to th eweb srevice page to render a sample seesion of what a request to the webserver looks like. Gonzalo got the FileSystemWatcher interface implemented on Windows and Linux (using FAM, and falling back to polling) which is pretty cool and Jackson has been working in our tracing support for ASP.NET, all very nice, new toys for the weekend.
Chris (of Hungry Programmer's fame, X-Word, LessTif, Jafar and most importantly Evolution) had a close encouter with the FBI and the Secret Service and they took all of his computers, details are here.
We keep focused on our Mono 1.0 release, so those of us working on this release get to enjoy fixing bugs, while the others developers get bored to death implementing new code and boring new features.
To keep the excitement some folks have been doing performance tuning, the Mono C# compiler has been a good test bed to improve our performance. Various elements come into play: precompilation (which for compilation gives a 30% performance boost), VM improvements (method to assembly inlyining, optimizations, memory saving), class library improvements (reducing the memory size used by our classes) and in particular the compiler got tons of tune ups. Ben, Gonzalo Jackson, Paolo and Zoltan have all been working on this.
A lot of interesting data came from the mono --profile output on the compiler, and by reducing the memory usage of the compiler we were able to get 26% of performance improvements in a month. So now the compiler is down to 2.9 seconds in bootstrap time (without precompilation compilation, just pure JITing) on my machine.
MonoDevelop, a port to Gtk# of SharpDevelop has been gaining momentum, and we have now moved it to the Mono CVS repository, although we are using Subversion for this project. This project has drawn a lot of attention and has helped improve and tune some of Gtk# which is quite mature nowadays.
On the other fronts, it is mostly bug fixing: the networking stack, the xml stack, the web services stack, asp.net is getting a lot of attention, and a lot of bug fixing.
Martin is taking a sabatical to complete the core of the debugger. Once he is done with these core changes, we will bind the UI to MonoDevelop while he completes the compiler Generics support, and maybe we will drag him back to the debugger for another pass of bug fixes.
Peter is working on integrating the Wine and Cairo, so we avoid having them fighting for the screen as we have them now. This will include updating our port of WineLib to the latest version of Wine.
The MacOS X port is working, but it needs testers on MacOS to try the latest editions of the Boehm GC do build fixes and so on. On the PowerPC, we are moving our focus to Linux.
Eric Durand and Francois Beauchemin from the Laval University will be implementing the compiler for regular expressions to CIL for the Mono runtime. This is part of their last semester work, and I will get to evaluate their work.
A couple of interesting links founds on Slashdot posts. First, a fascinating reading at The Register from the CES in Las Vegas: "HP declares war on sharing culture", then the home page for professor William Kahan which contains tons of interesting articles on floating point, algebra, math and java.
Some folks have been using Mono as a research platform recently (virtual machine, dynamic code generation, code optimization, profiling, recompilation, tuning, security) and more.
Duncan told me that he met with a few folks from a University during his holidays and they said that they chose Mono over Rotor for research because Mono has a real JIT as opposed to Rotor's simple JIT, and we also have a solid base for optimizations with our SSA platform.
Many areas in Mono can be improved for people who approach it for research though. We should improve these areas. We need better documents in a per-function basis, a lot of the time we do not have those and unless you are familiar with the code it might be hard to understand on a first read what things do. We also need to document the fields used in our structures better.
Now, the good news is that if you are a dedicated hacker, in a few weeks you can understand the JIT engine and implement some nice optimizations. Recently Patrik Torstensson came back to hack the JIT engine and implemented various optimizations (signed div constant fodling, inlining of common opcodes, peephole optimizations), as well as fixing various hard bugs.
Massimiliano Mantione as part of the hiring interview for the JIT engine wrote Arrays Bound Check elimination.
Peter today announced his new MBuild tool. A replacement for Make/Ant/Nant/MSBuild.
As we discussed the various benefits that MBuild has over other systems on irc in #mono, I came to a realization: There are tons of good new, fresh ideas in MBuild. Which is quite unusual in a build system.
The tarball is available here: http://www.newton.cx/~peter/files/mbuild-0.0.1.tar.gz Start at the README, and then check out doc/Manifesto.txt.
The finalist videos are out, you need QuickTime to watch them.
Slow day, mostly administrivia, coping with the new office at the new building. We moved from Boston to Cambridge, very close to Quantum Bookstore. Still got a chance to check up jwz's livejournal and tried to use BlogLines to browse my blogs.
Can not remember where I found this link today, from George Soros: The Bubble of American Supremacy..
Fantastic vacations in Brazil, today am leaving Rio de Janeiro and going back to Boston.
pedro, tberman and jluke have made a tremendous amount of progress on their effort to port SharpDevelop from Windows.Forms to Gtk#. They got intellisense working, the shell and are now porting the various smaller dialog boxes, which is a great sign of the progress, in only three weeks.
Martin has been improving the reliability of the debugger. The debugger is made up of a core API and various "interfaces" to it. The only one working today (the others have bit-rot) is a bizarre command line language.
Before I went on vacation, I was debating what to do about the UI for the Mono Debugger, I thought we should write a new debugger by pulling as many nice widgets from the gIDE/Anjuta efforts and redo the debugger, but now with MonoDevelop being available it only makes sense to integrate the debugger directly into the IDE instead of creating a new UI just for the debugger, and we get to reuse syntax coloring, intellisense and the other SharpDevelop shell features.
Once MonoDevelop matures a bit more, it will make sense to also do port the code coverage GUI to it, implement a GUI for the profiler and move Gtk-NUnit# to it.
Spend the first few days in Porto Alegre, with a two day trip to Florianopolis. We are now in Bage, and returning to Porto Alegre tomorrow through Pelotas and Casino. Then next week we head over to Rio to meet with Nat and Alex and spend new years eve there.
Am in Sao Paolo, going to Porto Alegre later tonight. Will go to Florianoponis this week, later Bagé and finally will head over to Rio de Janeiro for new year.
Ettore, my very dear friend passed away yesterday, December 10th, and has left a big void in my life, and the life of his friends, people he worked with, and people he collaborated with. Hard to think that we were exchanging e-mails just a couple of days ago, and that we were discussing photography two weeks ago in New York, and having greek dinner last week.
I first met Ettore in real life in Paris after we had known each other over the internet for over a year. Ettore he had contributed to Gnome the first docking toolbar and for this occasion we arranged to meet in Paris. In that meeting, he outlined his vision for a file manager (gnome-fm) and we designed the first pass at the gnome-vfs. Eventually, these would become Nautilus, today's GNOME file manager.
Ettore did not hesitate to leave his job to join Nat and myself in the adventure that would be Ximian. He was the second employee at Ximian, and started working on turning the HTML engine into a full-blow editor, this work is in active use today in Evolution. Later on, he became the leader for the Evolution project, which is in use now by thousands of users.
The first time I met Ettore, he and Clara cooked for me a new dish that until that point was unknown to me: spaghetti carbonara, which I loved. Year after year, every time I would prepare it, I would remember fondly how they taught me to make it.
Chema was a great loss a month ago, and this comes as a second very hard moment for our group of friends. Terrible moments like this are a reminder that we should enjoy every minute of our lives and cherish the frienships of everyone we know, on the internet and on the real life.
We are going to miss you bambino.
We are getting some pretty sizable contributions to the documentation of Mono through Monodoc.
Jim Hugunin (the creator of Jython) reports that his early .NET compiler for Python is performing very well, in contrast with ActiveState's previous attempt, in some cases better than CPython. It always bothered meb that ActiveState discontinued work, and came to a conclussion on .NET performance rather quickly, with JScript and VB.NET being proofs that better speeds could be achieved.
A copy of Jim's posting is here (the listserv requires a password to read), the details:
The early results with IronPython show that Python compiled to
IL can run fast. On the standard pystone benchmark, IronPython-0.1 is 70%
faster than CPython-2.3. The numbers for pystone as well as several
micro-benchmarks are shown below. For ease of comparison, all times are
normalized to Python-2.3. Smaller numbers indicate faster performance. IronPython-0.1 Python-2.3 Python-2.1 Jython-2.1
pystone 0.58 1.00 1.29 1.61
function call 0.19 1.00 1.12 1.33
integer add 0.59 1.00 1.18 1.08
string.replace 0.92 1.00 1.00 1.40
range(bigint) 5.57 1.00 1.09 16.02
eval("2+2") 66.97 1.00 1.58 91.33
Good to stop the meme of `.NET is slow for scripting languages'.
Illustration: patent on a simple web app
Someone on the net sent me this:
Mono's ASP.NET running on an X-Box running Debian
On the other hand, I do not know how I forgot to blog about a real ASP.NET web site running on Mono: http://www.mo8il.com/
I have not seen this reported yet anywhere, but as I was flipping through the pages of the newspapers on the airplane on the way back from Frankfurt, I noticed that Sun has signed a deal with the UK to provide 500,000 of its desktops based on Gnome, OpenOffice, Mozilla and Evolution.
A second batch of congratulations for our competitors/collaborator friends at Sun. They got one million users for GNOME in China. 1.5 million desktops: not bad, not bad at all.
The guys got a very good review from eWeek: Sun Rivals Windows, Office. An interview from a couple of months ago with Jonathan Schwartz is here. This one about their desktop effort.
Here is a review of our own XD2 in Open for Business.
Richard Smith has published an intro to Mono in the Novell CoolSolutions.
The conference was awesome. We got to meet a large community of enthusiastic hackers that wanted to participate in Gnome and Mono activities. Nat and myself did in total four presentations, three of them we did together, people really enjoyed the complemented discussion on stage.
Our talks were spaced out so we could spend time to talking to people, which turned out to be a great idea: we spend the three days at the conference answering questions and hopefully giving some helpful hints on how to get involved in open source developement.
The Novell Booth at Bangalore Linux.
The Novell booth was crowed the whole time, and the Novell team here did a fantastic job, they even had a quiz competition for various open source topics.
The conference so far has been fantastic, it is great to meet so many students and developers who are interested in becoming contributing citizens in the free software world. Yesterday Nat and myself did a couple of joint talks on the desktop. Today was Mono day #1 and the talk covered the basics: the rationale for Mono, what is available, and the roadmap.
The Main Room
I spent the next five hours talking to various people who were interested in different facets of Mono and open source development. The Novell booth was packed, and the guys manning the booth were overloaded with questions about the desktop, the bounties (which we are promoting here for the first time in public) and Gnome Bangalore (which was just launched).
Naba Kumar of Anjuta fame has a boot all for himself to demo Anjuta and the locally built PDA is also being displayed on the show. Another important project at the show was the IndLinux effort: they have been working on translating Gnome to ten different Indian languages:
IndiLinux GNOME
Tomorrow we are doing another joint presentation, this time on rapid application development with Mono. We have a little surprise prepared for this one.
This release took us a long time to go out, but it is pretty exciting, with PPC supported. The best Mono release ever!
Today I do my first Mono presentation at the Bangalore Linux event. I helped Nat with two of the Gnome presentations yesterday at the event, those were fun.
A very pleasant journey to Bangalore. At the lounge in Boston they had Champagne and Burritos:
Champagne and Burritos For the Traveling Connoisseur.
During the six hour layover in the Frankfurt airport, I did some low-hanging-fruit hacking: reduced MCS compilation times and memory usage a bit more. On the airplane I managed to get Gtk# using Cairo# which required fixing various Cairo# issues, and adding some custom features to Gtk#. Will check those in, once we decide on the new name for the `CairoState' object, which we currently call `Cairo.Object' which is just not right.
Barb wire, keeping someone out of something.
Following the steps of PlanetGnome, Novell now has an aggregated service of Novell blogs at Planet Novell
Added some helper buttons to assist the folks writing documentation with Monodoc, also we have now activated the Monodoc editing web service, so those users that are using Monodoc CVS are now able to send their contributions back from the GUI.
Our web service is running on Mono ASP.NET with the Apache2 module. For the curious, our web service is hosted here.
Am taking a plane to Bangalore in a few hours. This trip is to meet with my colleagues at Novell/Bangalore who will be working in Mono (starting next week) and also to attend the Bangalore Linux Conference. Will be talking about Mono as a development platform, and meeting with some of the existing contributors to Mono and Gnome that have e-mailed me.
On my way back, am planning on stopping by Germany and Spain, but the exact dates and locations have not been sorted out yet.
The Mono team is in good hands, with a flury of activity on every corner: we are advancing quickly on completing the .NET 1.1 APIs for the Mono 1.0 release, and a few team members have been amusing themselves implementing features from the .NET 1.2 release.
As I write this, am migrating my album from my mPhoto software to Ettore's F-Spot photo management application (both written in C#, but Ettore has done a much better job than I did with mPhoto ;-).
Lastly, I have been playing with Cairo in Gtk#, and having a fun time using it from C#, it needs a bit of loving which am going to be doing on the airplane, and will have something to check in when I land in India.
Cool link of the day, comes from Brad Adams blog: http://broken.typepad.com/
My friend Mancha (Fernando Magariños) worked for two years on and off doing the typography for a physics book in Mexico, and the book was just awarded the prize for the best typesetting, layout and editing in Mexico.
Mancha composed the book with TeX. Will post links when I have them.
Congratulations to Sun on getting the deal with the government of China. We are competitors, but still the software they are delivering is open source.
I know various of the hackers and developers at Sun that have worked hard on this: on Gnome, in OpenOffice and Java, and I am glad that their hard work is going to in such a large deployment.
A few years ago, we met with John Heard and Marco Boerries who were working on various angles of Sun on the desktop. It was back then that John had seen a future for Gtk+ as an ISV platform, and that Marco would bring up the idea of open sourcing StarOffice (which we have been very excited about contributing to). They wanted to see Gnome mature: and they were two important driving forces for the establishment of the Gnome Foundation. Through all these years of work, Sun has funded big parts of development of various components of the open source.
Despite all the criticism they get from Jonathan Schwartz quotes about Linux, Sun is a massive contributor to the open source pool. OpenOffice alone is a big chunk of functionality. But their daily involvement in Gnome 2 has been a pleasure to watch: they were the first to push Gnome to be fully accessible to comply with government regulations.
Anyways, good luck to our competitors. Tonight is a big win: at least 1.3 billion people will be running Evolution.
Microsoft announced the specs for the XML markup for Office, and they are royalty free. The actual license text contains:
If you distribute, license or sell a Licensed Implementation, this license is conditioned upon you requiring that the following notice be prominently displayed in all copies and derivative works of your source code and in copies of the documentation and licenses associated with your Licensed Implementation:
"This product may incorporate intellectual property owned by Microsoft Corporation. The terms and conditions upon which Microsoft is licensing such intellectual property may be found at http://msdn.microsoft.com/library/en-us/odcXMLRef/html/odcXMLRefLegalNotice.asp?frame=true."
By including the above notice in a Licensed Implementation, you will be deemed to have accepted the terms and conditions of this license. You are not licensed to distribute a Licensed Implementation under license terms and conditions that prohibit the terms and conditions of this license.
It appears that the above *might* be incompatible with the GPL. It sounds like the BSD advertisement requirement. Further study is needed to really understand the issues.
This is the long promised write-up of the PDC trip. It has taken quite some time to digest what was unveiled there.
At the PDC we saw the latest ways in which Microsoft has pushed the operating system beyond its roots into an advanced operating system; far more than the universe of read(), write() and poll() that Linux developers usually think of as being "the OS."
Brady, Gonzalo, Lluis and myself went to the PDC, to check the latest product announcements related to the .NET Framework. We were in for a surprise. As I left the Boston airport, I confidently told Nat `Everything is under control, there will be some generics, some of this and some of that, will report back'.
I religiously sleep until noon, so waking up at 7am to attend the keynote conference was against possibly my most sacred principle. We had accumulated plenty of miles to be there and we were three hours behind Boston time, so I capitulated and was happily having breakfast at the conference center at 8am. By 8:10 I had already purchased a stack of books on ASP.NET 2.0, System.Xml 2.0, the new C# spec and the annotated CLI book. Me and the janitor were the only customers going through the books. For a second, the thought that the conference was empty crossed my mind, but the sales dude rapidly informed me that I had only 20 seconds to make it to the opening keynote. I ran.
You probably have read about the keynote material everywhere by now. There were a few things announced:
There was a lot of wow-factor from the various demos as they were building them. They have this new file format called `Xaml' that is used to specify GUI layouts with XML. It was interesting that the demos were done with Emacs and VI. On one hand, they showed that there was no trick (or that these technologies were not `simplexity-based'), but on the other hand, I realized: they do not have a GUI builder for Avalon yet.
Xaml was particularly interesting, for Gnome people this is not news, but it is worth describing: the XML format binds the element names to .NET classes, and each one of the attributes maps to a property, so something roughly like:
The above gets translated with the XAML compiler into something like:
So as you can see, pretty straightforward. Of course, the wow-factor comes when one of the attributes can be a video, and you can apply arbitrary Postscript-like transformations to the whole thing. Very much like Display Postscript-based systems, the MacOS or the venerable NeWS system (the difference being that Microsoft will drive this into every desktop, while the other systems never made it into the mass market).
One of the best moments of the keynote was the demostration by the guy from Amazon. They showed a beautiful GUI client, that was apparently fully written using Avalon in a month of work. I allocated a full 30 minute slot to a quest to reimplement it at home, and I can say with authority that 30 minutes are not enough.
During the next few days of the PDC, I attended the core CLR/.NET talks and the GUI ones; Gonzalo took on the ASP.NET ones and Lluis attended the Indigo talks. We met with Brady from the iFolder team at Novell, and he attended the WinFS talks.
My friend Benjamin knew that the Mono BOF had not been approved by the INETA folks, so he invited me to talk a bit about Mono on his own BOF on Sunday, the title was `Microsoft and Academia' (this is when we patched the main program to mention Mono). I did a small 5-minute presentation on Mono, and got to meet a few folks after the presentation.
On Monday, it was clear that we needed to put together another meeting. People on the hallways were asking when we would have the Mono meeting. In particular Sami Jaber who was covering the event for DotNetGuru in France volunteered to announce a new venue, and guaranteed `At least the French contingent will show up'. So we pulled out our maps, and found a perfect spot for the event: the Foyer that connected two hallways in the LA Conventions Center. We announced it on the relevant sites, and relevant blogs, and went on with life. Picking a time for a BOF was hard: there were pleny of other activities every day, so we basically picked the dinner time.
The day of the event, we went to pick up the Ximian/Mono T-Shirts to the hotel, we had plenty of time: 30 minutes to the BOF, and the hotel was only a few blocks away. Of course, we did not plan for one of those mythical traffic jams to play a role, and we managed to walk back from the hotel carrying boxes of t-shirts and being embarassingly late by 30-minutes.
Sami was there, and we started to gather a small group of people, but once the audience identified the t-shirts, we got together a pretty large group. The group took over all the available seats in the foyer, probably sixty to eighty people, hard to estimate.
I did a tiny introduction to Mono, really small, and then the next 90 minutes we spent them doing questions and answers. I got to meet various Mono contributors and regulars from the list: Dave Bettin, Kral Fretch, Urs Muff and plenty of actual users that do not hang around on the list. Since the audience was very .NET-savvy, that made my job a lot simpler, and the questions were fantastic. I like this format more than the regular formal Mono presentation, but I realize that this group of people was unique.
The introduction was basically the first ideas on what Mono 1.0 should be. The introduction, plus some of the insight from further discussion became the Mono Roadmap.
We now need to work hard on that roadmap and deliver on it. It is going to be hard.
Both Windows.Forms and XAML do layout of their widgets with some engine. The main mistake of Windows.Forms was not copying the constraint-based system that Gtk uses, and the Gtk containers that Gtk uses.
In .NET 1.2 they have an attempt to fix this by introducing various new widget containers: grids (tables), flows (not available on Gtk, but never needed it) and a few others. The main problem is that you have to "attach" the containers to its parent before you can do anything with them. A step in the right direction, but too cumbersome to use.
Hopefully, Avalon will promote a different model, a more sane one.
During the event everything was demoed by using this new markup language. Of course, everything produced with it looks terrible. And the reason is simple, XML might be a nice replacement for a few lines of code, but doing GUI layout in code is always a boring, error-prone, and most of the time the results are of low quality.
Xaml was pitched as a way of splitting the work between a designer and a programmer, which has an element of truth to it, but in reality they need a good GUI designer for producing interfaces (very much like Glade is to Libglade in Gnome).
Xaml is just a markup language that wires CLI classes together, so although it was demoed as a GUI composition tool, it could be used to wire together other components as well. My guess is as good as everyone else: it was probably intended to be a decent serialization format. A definite improvement for those folks building round-tripping IDEs, since now they only have to parse one language, and a fairly easy one to parse as well.
Now, the Avalon components that can be wired up have been built on its entirety on a new rendering framework, one that seems fairly powerful: a PDF like 2D imaging system, with video playback integrated.
This leads me to my first prediction: the first generation of Avalon applications will:
This brings me to the next point: the Microsoft folks, realizing that Avalon turn the rest of the century on the return of the <blink> tag on steroids, they have produced a number of interesting documents and on their public UI talks, they not only made fun of themselves, but they also have visibly taken the Joel-on-Software usability pill, and they are talking about the same thing we have been talking about in Gnome: usability, simplification, consistency.
Building rich desktop applications with Xaml is very easy: things can begin as "prettier" web pages. You do not have to be a programmer to use Xaml, and if you are, you can add extra functionality, just like Javascript does for the Web.
This of course poses a threat for the open source desktop, more on this on the upcoming sections.
Jon Udell in his blog points out that there are various new XML formats coming out of Microsoft that have some ammount of overlap with exising technologies: Adaptive Flow Format instead of CSS; Windows Vector Graphics instead of SVG; WinFS schema definition language vs Xml Schema.
At least for the first two, I can understand why the engineers rolled their own. It might not even be a case of not-invented here, it was just that given their model, it was just simpler to follow this path.
WVG/SVG is the obvious case where it might be convenient to bend the rules of Xaml: interop in this area is more important than the minimal benefit of integrating with the CLR. This is just just like coping with JPEG or GIF files: it is just not worth changing them.
From the Mono perspective, it is still an early technology to implement, but it is definitely an area that we are studying and we are hoping to produce some implementation guidelines for the most courageous developers. The core Mono team is right now working hard in producing Mono 1.0, and we are not planning on working on it immediately.
Avalon appears to be a large beast. I am left wondering if this is why the Microsoft developers have been talking about reducing the number of APIs exposed. It might be a good idea.
It might be interesting to build a smaller Avalon, one that could run on smaller devices, and would consume less resources would be a fun project.
Xaml is HTML merged with the Desktop UI
Although Xaml seems to be only a cute idea, it is simple enough, and each one of the individual components are powerful enough that it is very likely that Xaml could replace HTML as a way of creating rich content on Windows platforms. It would leave out of the equation Linux, Solaris and MacOS.
For free software users this again becomes a problem, since we continuously face proprietary protocols and file formats as a limitation of our platform. A limitation that we have to address every step of the way. In the case of Xaml, it is not the lack of documentation or a proprietary protocol, it is just that it is intimately tied to the .NET Frameworks.
Using Mono we will be able to bridge this gap: if people produce XAML-based applications and content, we want to be able to render that, and to do it right, we will have to implement the whole stack.
Various components will make XAML an attractive authoring environment:
A lot of fun work lies ahead of us.
The good news is that the ASP.NET team surprised everyone: ASP.NET was already simple, and they made it simpler, and they added much wanted features like master pages, many small controls that factor-in common functionality on web sites. My personal favorite: pre-compiled deployment of web sites.
The XML folks did not stay behind: there are many new features: XQuery appeared in the framework and the new XPathDocument.
The bad news for Mono are thatn ASP.NET has more than doubled in size since the 1.1 release and the features in XML are fairly large improvements. The good news is that we were starting to get bored with the existing class libraries: largely bug fixing was the major focus, this injects a lot of fun into the Mono equation again.
For instance, a group is already working on an early implementation of ObjectSpaces.
The new storage facility to be available in Longhorn has some interesting features that have lead to lengthy debates in the Linux communities. WinFS will be released as part of Longhorn, so it will become available in 2006 and only to users that migrate to the new OS.
Brady explained to me WinFS, and his own project: iFolder 3.0. The features in WinFS will be available in Novell's own iFolder 3.0 by mid-next year. Both the workgroup client and the server will be open source offerings, and we plan on adding the same kind of GUI functionality that people saw at the PDC (the UI elements are being developed with .NET: Windows.Forms on Windows, and Gtk# on Unix).
iFolder is in fact one of the most interesting pieces of technology that Novell has been working on, and we hope to bring these features to Linux and Windows users (needless to say, before WinFS ships, and in more platforms than they will run ;-).
Some confussion still remains in the open source world about the inner working of the WinFS. WinFS does not replace the existing file system: it still uses it to store the actual bits of a file. WinFS basically is a layer that can extract interesting information from files when stored on it: the regular data goes into an underlying file system storage, and juicy metadata bits are extracted and recorded at this point. One possible use scenario of WinFS is to perform queries on the juicy information.
Hacker extraordinaire Jeroen, the author of IKVM was also at the conference, and we got to hang around with him.
At this point you might have realized that the new three pillars of the new OS are:
More information on Indigo is available in Lluis' Indigo blog entry.
Microsoft has taken another bold move in moving all of their new API development into .NET.
Not only are the new operating system features cool, but they have turned them into an API.
It is now our turn in the open source world to track these innovations, and expose turn applications into API providers.
It is important for Mono to continue its path (Note: we should do this in an orderly fashion, in peace if you will. Not screaming, waving our hands and banging our heads against the wall).
We have to leverage what is unique about Linux, iFolder, Gnome, Cairo, the VFS, our databases and expose those features to the managed world.
Mono needs to become a core feature of every application.
Chema Celorio, a good friend for the past four years died yesterday on a skydiving accident in Mexico City.
The Gnome folks might remember Chema for taking over gEdit, the Gnome Printing platform and later on managing the Ximian team in Mexico and the Ximian Desktop effort. He was became famous for being the #1 bug reporter to Gnumeric, and a close friend to everyone that met him.
He helped bring newbies by fueling the Gnome-Love project, a project, where developers would be hand-hold, and no question was too simple to be asked.
Chema was passionate about skydiving, technology and free software. He was preparing for a mexican record of skydiving in the upcoming weeks. We had dinner frequently when he was in town, and he would always ask the right questions, and make us laugh all.
Just two weeks ago Maria and I had him for dinner at home, and we taught him to cook crepes. We will miss him.
There is a skydiver's forum: in Mexico.
Chema was thinking about moving to Europe.
I have a few pictures I took from Chema, from Barcelona in September: here, here, here, here, here and here.
Nat has a picture of Chema last year at the Cave.
Nat comments
My main work this the PDC was completing the Mono Roadmap and the list of things that I feel comfortable releasing in 1.0 form.
The roadmap is important to help people plan ahead of time. They now will be able to know what things we will support and when we will support them. Until now it was an open-ended question.
Mono 1.0 contains less features than expected. A short sample of what some people wanted: more platforms for the JIT, EnterpriseServices, WindowsForms, development tools and more stable database providers.
I debated for a long time what to do about Mono 1.0: should it be a full .NET 1.0/1.1 release, or should it be a subset of it? It is clear at this point that we wont be able to release a product if we wait until everything is done. Specially since .NET 1.2 with its big changes is going to be released very soon now.
Today, different assemblies in Mono have different stability levels, and I have decided that enough is enough: we will release the stable components and focus on making those rock solid in 1.0. In upcoming versions as components mature we can expand the offering.
A big motivating factor was the recent PDC conference. It is obvious that many hackers will want to work on the more fun new features, but if we jump into that bandwagon now, we will never have a usable release. So the roadmap helps to solidify the direction of the team, while keeping the doors open for those who want to try something new to work on.
The missing functionality in Mono can be divided in:
Some developers are already working in 1.2 features. For instance, the C# compiler has iterators and some generics support. Our runtime engine has some generics support as well, and we have got a few baby steps in ASP.NET done.
A friend of mine at the Microsoft PDC conference who is an Independent Software Vendor (ISV) made a few observations: the continuous breakage of the Linux development platform is hurting them. Linux is still a small market compared to the Windows and Mac markets. In most cases, the revenue opportunities for the small and medium ISVs are too small to make a Linux port worthwhile, and when it is, the staffing requirements for maintaining and testing their software for a dozen of distributions and release versions quickly becomes a big burden.
In particular my friend complained about the a.out to ELF migration; Then the ELF libc5 to libc6 migration, and apparently the new version of libc6 breaks their application again. They still update their software, but older binaries distributed to the public stop working on new releases of the product. Internally I know that all those changes were needed for Linux, and also that it is possible for the Linux community to provide the backwards compatible packages. Although this is possible in theory, in practice these compatibility libraries are not shipped with the main distributions.
In his view, this is scaring off developers (both his customers and themselves), and he has noticed a decrease in the demand for their software on the Linux platform and an increase on the MacOS X platform. As an anecdote I would not worry much about it, but the problems he described resounded with what we have heard from customers.
I used to think that the worst offender in breaking working applications was Debian. Considering that the commercial distributions at least did an effort to make stable releases of their products, as opposed to the continuum of updates that Debian is. Supporting Debian as an ISV is just too hard: there is no way to release software that will be usable a few months down the line, and there its too easy for a Debian user to accidentally move from `stable' to their `bleeding edge' setups. But to these outsiders, Debian is not even on their radar: the support offered by the commercial Linux distributions is flaky compared to what they are used to from the Unix world and Windows.
At Ximian we had a similar experience: the Ximian Desktop was built, packaged and tested on a number of distributions (Debian was supported once upon a time for example). But as time went by the matrix of distributions that had to be supported kept on increasing, the small differences kept on creeping and we were not able to keep up maintaining and testing packages for all these combinations of Linux, let alone suppor them. And keep in mind that Ximian was a company commited and devoted to support Linux-based applications.
Note about Debian: it is clearly the choice for many free software enthusiasts and is very entrenched due to its deep community roots. Tools like apt-get help people try out the latest developments in the open source world with little effort, and their community commitment is fantastic, but is a very hard platform to support for an ISV.
As much as the free software community would like to see a fully open source system, with every conceivable tool and piece of software available as free software it will not happen in the short or medium term. After all these years of working for this cause, we know that many of these applications will just not materialize as free software: games, vertical applications, developer tools, educational software, just to list a few.
To make Linux a viable platform for mainstream desktop use our community needs to realize the importance of these third-party vendors and not alienate them. Having a stable API, and a stable ABI is very important for this reason. GNOME has learned this lesson and has strict commitments on ABI/API stability (thanks to our friends at Sun that pushed for this) and the XFree folks deserve the credit for making ABI compatibility across operating systems a reality for their drivers. Two good steps in the right direction.
And of course, part of the problem is that it is not fun to work on backwards compatible ways, nor is it fun to work when innovation is hampered by backwards compatibility. Proprietary software is not going away any time soon, and our community should start thinking about ways of co-existing with it, such that ISVs help our platform by enriching it with a larger software offering.
Red Hat has taken an active approach at providing an API-stable edition of Linux with their enterprise editions. It is good as a short-term solution, but it is not a long-term solution, nor a scalable one given Linux's varied offerings. We need to attack the problem at the roots: The culture of API stability needs to be assimilated by maintainers and developers.
Which brings me to Mono (funny how everything I think revolves around this topic). With Mono we are trying to keep things compatible with the .NET Framework: even when we believe we can do better, we avoid introducing incompatible changes. When we have new functionality, we encourage our developers to expose that new functionality in a new library, and encourage them to make it available also to .NET developers (System.Security/Mono.Security is the best example of this pattern).
We very much hope that Mono will become the standard development platform that developers are looking for: a platform that makes strong API/ABI commitments, supports older versions of the libraries and supports their products moving forward (in fact, .NET does provide this very functionality in the GAC). It is useful that the .NET 1.0 and 1.1 APIs are set in stone now, because we have a concrete goal to aim for, and developers will know that those APIs will be supported.
Also, the CLI makes binary compatibility easier to achieve. A lot of thought went into the VM and into the C# programming language to deal with versioning problems that arise during the natural life time of a component. On the VM side, it is possible to add new fields, new methods and rearrange them without suffering ABI breakage. This is possible because the .NET metadata preserves naming information and binary layouts are only computed on the target processor at installation or JIT time.
People sometimes focus on what would happen if Microsoft changes an API in .NET, how would that impact Mono? This is not as much as a problem, given Microsoft's commitment to keep binary compatibility; The major threat to Linux as a development platform is its own development model, mixed with the lack of understanding in many hacker circles that API and ABI binary compatibility are crucial.
Update: And of course if something like the Linux Standard Base would get a long way to make this happen, but it has never got a lot of buy-in from the actual distributions.
Still writing it up. Hold on ;-)
Am back in Boston from the PDC. Lots of improvements to the .NET Framework in the short-term, and some very interesting but still early work for the long term.
Will post all my notes on Monday, once I decompress.
The Vietnameese government goes Open Source. WOW
Mono people: Lets get together on Tuesday 28th at 6pm at the West Tower Lobby in the LA Conventions Center at the PDC to discuss Mono. Pass the message.
After this we can head over to the "Meet the Experts" session at 7pm.
Tomorrow we will devise a plot to get more people interested in Mono to get together; My plan right now is to take over one of those empty areas around 7pm and just get together around the tables. I spotted a few places that seem to be deserted, will confirm tomorrow, and we can have a massive Mono love-fest.
The fine folks at the `Microsoft and Academia' BOF have welcomed us to participate on their track so we can discuss Mono from an academic perspective.
The BOF is at 7pm at the Conventions Center.
We just arrived to the PDC, and we put open source in practice and did some patching of the BOF announcements to reflect the Mono session.
After a nice evening improving the new System.Drawing foundation built by Alexandre am ready for some airplane hacking. Will be arriving early to LA for the Microsoft PDC.
I have arrived to LA, we are staying at the Hyatt, feel free to leave messages to get in touch with me. and Lluis will be arriving later today.
The language specs for C# have been published
As I upgraded the hard drive on my machine today --which took a few hours to copy the rats' nest that is my home directory-- I begun the process of assimilating the GDIPlus Flat API.
A few weeks ago, Alexandre Pigolkine, Jordi Mas and myself were discussing the development roadblocks that we had with System.Drawing (as part of the Windows.Forms effort). The problem is that we made one of the most common engineering mistakes: when faced with the issue of multiple choices, instead of choosing one, we chose them all.
Being seasoned C# developers, we created an internal interface, and had each backend implement the interface. Then the official System.Drawing API was implemented and it became a multiplexor for the various implementations. We had Win32, Xr and Gtk backends. Of course the issue is that improving the backends becomes fairly hard: a change has to be reflected in five places: three backends, the interface and the multiplexing call site. Not terribly hard for one or two API calls, but it starts to become hard with an API as big as this one. I take all the blame for the mistake.
After some discussion, we decided on a new strategy: System.Drawing would only have one implementation, and this implementation would be based on GDI+. On Windows, the implementation would just call into the real GDI+ library, and on Unix systems we would provide a full implementation of it. To implement GDI+ on Unix, we have based our implementation on Cairo which has pretty much the same imaging model that GDI+ (and PDF) have.
This has several advantages: we maintain and write less code; we can test against the real GDI+ implementation on Windows and remove a variable in the debugging process; and we can contribute this code back to the Wine project.
But plenty of assumptions we had made before do not apply necessarily now. Before we had a managed implementation of the image loaders: it was just as fast as the C code and by virtue of being C# code, by extension it was cooler. But now in this GDI+ world, we will move things like the image loaders into the C code API, and the C# code will become thin wrappers around it.
The above also explains why there is a regression in Windows.Forms and System.Drawing on CVS as opposed to the latest official Mono release. So now I should be able to assist the System.Drawing developers.
The upcoming Mono not only will add Cairo as a depedency (if you care about System.Drawing), but our internationalization support will also require the International Components for Unicode library.
We will continue to provide packages on Red Carpet, and RPMs on the site for downloading, but we are seriously considering reusing the Ximian Desktop installer to install Mono on a machine. That means that instead of downloading a dozen packages from our site, you would only download one. This hopefully will reduce the number of problems that people have with installations and we would also ship the Apache module pre-configured in the distribution.
Duncan is researching this, and we will keep people posted.
Wondering about the organization of a meeting of Mono users at the PDC, it seems like Monday afternoon before the reception, or Thursday are good time slots for getting together.
Alternatively, the Mono folks will be wearing the cool Mono t-shirts, so if you are interested in discussing a Mono topic, feel free to come and join us.
Today's most beautiful blog update goes to Nat for his fantastic photographic update on the Bangalore trip and his insight on his trip to ramp up the new Novell open source hackers that will be working on improving Gnome, OpenOffice, Mozilla and Mono.
In other news, am going to Bangalore in early December, and I have to plan something with convenient stops in the middle. It has to involve a Paris stop, so I can meet the Mono hackers in Paris, and introduce myself to Fabrice Bellard.
In November the Gnome Hackers will descend into New York for the Gnome Summit where we will talk about the major problems facing the Linux desktop today. This event is a follow up to last years Boston Gnome Summit.
There are tons of new topics for this year that I am looking forward to discuss:
And of course, get everyone to adopt Mono for their projects, as we know it is the One True Runtime (bug reports, happily accepted
I just received a letter from the INETA PDC organizers informing me that the Mono BOF would not be happening. I was looking forward to discuss Mono. The BOF suggestion had a pretty good rating and hat plenty of voters, I guess it was a far stretch to have Microsoft have a BOF on Mono :-)
Notice that there is an estimated of 60 BOF talks, but only 48 were approved.
If there are people interested, we can still sit down and discuss Mono at the PDC, there will be at least three of us: Gonzalo, Lluis and myself.
I am looking to hire a full-time developer to work on the Mono JIT engine. This would include working on the code generation engine of the JIT (so compiler experience, low-level programming experience is a plus), advanced optimizations for the compilation engine (various SSA-based optimizations, array-bounds check elimination, fast-call conventions, loop optimizations), debugging interfaces and would involve dealing with a garbage collected, multi-threaded runtime environment.
We are porting the Mono JIT to various platforms, so you would be learning new assembly languages, new ABIs and more. If you are interested, drop me an email at miguel@ximian.com
I have been applying every one of those "Apply this patch immediately" updates that I have received on e-mail from support@microsoft.com, and my machine seems slower every time.
Update: I have received on last count 9 emails from people informing me that the above is a virus. Guys, it was a joke. Obviously I failed in my attempt to be funny.
Chris Toshok today has been working on embedding Mono and Mono-based applications inside Evolution in their new UI branch.
Here is a screenshot embedding the Mono documentation browser in Evolution:
Some people have asked me about the theme for this year Birthday's present. This year theme is going to be `Nice and Expensive'. It is a repetition of an old-time favorite. But this year, lets try harder to stick to the theme.
The article is here, and I had forgotten about the Syria Accountability Act that was making the news last year until I ran into Robert's article today.
We modified the Monologue software to use multiple-threads to download the RSS feeds concurrently, and this exposed a couple of tricky bugs in the runtime and our DNS setup. Gonzalo was on a quest to track all of these problems down, and our abusive version of Monologue is now fully functional.
Now the major source of problems was not a Mono bug, but a dead-lock condition that was not obvious. Turns out that Monologue/threaded happened to fill the Threadpool queue (no surprises there: threadpool will just take care of things), but the Http code needed a thread from the pool to download things (the API is using the async version of this as well), and that caused a deadlock.
Ben wrote an RSS aggregator that we are running now on http://www.go-mono.com/monologue to track the Mono blogs. You can now get all your Mono news in a single spot. This is similar in spirit to Jeff's Planet GNOME
If you are interested in running the aggregator in your machine for your own personal blog reading, just download the `monologue' module from our AnonCVS repository.
I have tried three kinds of RSS aggregators out there: desktop-based, mozilla-based and html-based. From my personal browsing experience I believe that the HTML-based aggregators are the best kind. Specially when we you are using Mozilla/Firebird with tab browsing.
There are plenty of desktop-based aggregators for both Windows and Linux (I tried them all in a quest for the perfect UI). The desktop-based aggregators typically embed a web browser in the browsing pane to render the news. And this is the source of most frustration with them.
The embedded HTML rendering engine has some very bizarre interaction glitches when you follow links, and you try to go back in history, or when you start following links inside the aggregator (which it is bound to happen).
Since it is not really possible to read comfortably the news inside the aggregator, you can either open a new window (uncomfortable) or hope that the aggregator can instruct your browser to open a new tab, but it is still annoying to use.
The obvious answer to the above problem is to put the aggregator inside the browser. Luckily Mozilla/Firebird have made plugin authoring a breeze, and there are a couple of options out there.
These aggregators today suffer from a problem shared by the desktop-based aggregators: they are based on the modern news-reading/mail-reading model. These present the user with a collection of folders with items old and new, and you read your feeds one by one. This model is ill-suited for blog reading because blogs do not produce large volumes of data per day, and you most likely want to read all the new things in the day at once. Not once per week, so the interaction model is basically to read a single post on each folder and move to the next one, and repeat this a number of times per day. Not very efficient.
The third kind, the one I like the most are the aggregators that generate an HTML page with the consolidated data. This in my opinion is the best model because you get to read HTML content on your main HTML browser and all the tools available on your browser are available to you and most important: there are no surprises on the behavior. Since it aggregates all the data at once, every time you visit it, you can get a snapshot of what is happening, rather than having to check 20 sources one by one.
Firebird users probably will like the last one the most, since its a feature packed browser, and with a rich set of extensions that make browsing more efficient. But in general any user of a tabbed-based browser will enjoy the later kind the most.
Yesterday there was another suicide bombing in Israel. The reaction was an attack on an alleged terrorist training camp in Syria. Following the Bush doctrine of `destroy evidence first, cover-up with non-answers later'.
Been thinking this morning that it is time to write a Israeli-Palestine Conflict Primer. On second thought, maybe I should just strongly recommend reading John Pilger's Palestine Is Still The Issue an eight-parth documentary available online (wish they sold the video on DVD).
Edward Said passed away, his latest article and a tribute to his writing.
The Hamas group that has been striking at the civilian population was initially funded by Israel in the 70's to undermine the growing popularity of the PLO and Arafat. A policy that now has backfired. Some details here.
We completed the SouceGear project!
The project included adding a lot of functionality to Mono to support Web Services on the client (mostly having a full XmlSerializer implementation as well as its close family members) and making Mono robust.
To make sure that Mono was robust, SourceGear designed a series of extensive tests that Mono would be put under, and the acceptance criteria for the work we did included running the tests for a 24 hour period of time on a single instance of the virtual machine. Needless to say, making the Mono VM robust enough to run these tests for 24 hours was not easy, and we ran into all sorts of low-level interesting features, memory leaks, race conditions and other assorted small problems that would not have shown under normal circumstances. We are very happy about this.
In the meantime, while parts of the team were tracking down the elusive bugs in the runtime, Lluis took the time to implement the server side component of ASP.NET, so as part of the SourceGear effort, we also got our web services stack implement on the server, which was a nice plus.
I was feeling that I should argue a bit more about exceptions, until I received a mail from Krzysztof Cwalina at Microsoft, he raises a good point about exceptions and the null return pattern: they do not allow an error to be propagated, nor details about the error.
He is absolutely right, and my example with files was not a good one. I had in mind APIs that did not need to propagate a rich error or details about the condition. Krzysztof said:
One problem with null is that you may get notified about the problem really far away from the point when the error occurred. Exception will be thrown right there at the point where the error occurs. The other problem is that null cannot tell you why the error occurred. Error codes have their own set of problems.
Of course (as with every design) it's a tradeoff. In this case a tradeoff between better error reporting (fail fast, rich error message) and performance (and other things). In general, we err on the side of better reliability, clarity of errors, etc. when designing the Framework. We have several exceptions to the general rule in explicitly identified performance-sensitive APIs.
Lluis the man behind the Mono implementation of Remoting and Xml Serializer explains on his latest blog entry how the undocumented IXmlSerializable interface works. If you ever wondered how you could have precise control over the Xml mapping in XmlSerializer, this is the interface used internally by the framework.
Sebastien, the man behind the Mono cryptographic infrastructure now has his own blog.
Duncan also started his
In a recent interview Anders said:
If you ask beginning programmers to write a calendar control, they often think to themselves, "Oh, I'm going to write the world's best calendar control! It's going to be polymorphic with respect to the kind of calendar. It will have displayers, and mungers, and this, that, and the other." They need to ship a calendar application in two months. They put all this infrastructure into place in the control, and then spend two days writing a crappy calendar application on top of it. They'll think, "In the next version of the application, I'm going to do so much more."
Once they start thinking about how they're actually going to implement all of these other concretizations of their abstract design, however, it turns out that their design is completely wrong. And now they've painted themself into a corner, and they have to throw the whole thing out. I have seen that over and over. I'm a strong believer in being minimalistic. Unless you actually are going to solve the general problem, don't try and put in place a framework for solving a specific one, because you don't know what that framework should look like. [Artima's interview with Anders]
I like Anders' position regarding Checked Exceptions, contrast this with James Gosling's statement, which I believe does paint a broken picture:
One of the traditional things to screw up in C code is opening a data file to read. It's semi-traditional in the C world to not check the return code, because you just know the file is there, right? So you just open the file and you read it. But someday months from now when your program is in deployment, some system administrator reconfigures files, and the file ends up in the wrong place. Your program goes to open the file. It's not there, and the open call returns you an error code that you never check. You take this file descriptor and slap it into your file descriptor variable. The value happens to be -1, which isn't very useful as a file descriptor, but it's still an integer, right? So you're still happily calling reads. And as far as you can tell, the world is all rosy, except the data just isn't there. [Artima's interview with James Gosling]
This is in fact the source of many security problems. One of the first security code audits I witnessed was by a volunteer that reviewed my first setuid application that I shipped as part of the Midnight Commander (the software only shipped after the security audit). A 200 line program got back 700 lines worth of comments, many of them related to not checking error conditions from trivial system calls like `close()'.
But modern C APIs do not use int return codes, in fact not even the C standard library uses those: that is only the low-level Unix C API that has this feature. The standard C library API returns a FILE * object, and for instance, most of Gtk+ and Gnome APIs return objects (in the form of a pointer to an object).
The beauty of returning a pointer to an object, is that you can return NULL as your standard error return value, and if the value mattered, you will most likely take the necessary steps to check its return value, or they application will just crash the moment you try to use it.
This could be applied to the .NET and Java APIs to reduce the amount of required try/catchs. For example, the File.IO.OpenRead method could be (shown here is the artist's representation):
public static FileStream OpenRead (string file)
{
int fd = open (file);
if (f == -1)
return null;
return new FileStreamFromFD (f);
}Which makes null a valid return value. If you fail to check for the return value, you would get a nice NullReferenceException, but you would allow the expensive creation of an exception object, and the ugly try/catch block in the call site.
Obviously we can not change the existing APIs, but we could encourage developers to minimize their use of exceptions. In my limited personal experience with software design, when I have faced applications with tons of Exceptions it was extremely hard to keep up with them. A rewrite of the software to avoid exceptions and use the more sane API paid for.
I wrote about Ben previously, he now has a blog which we are hosting for him at Ximian.
Laura and myself have been shopping for various items for our new appartment. Once we had chosen the rug, everything fell into place, and in two hours we swiftly sorted out our color differences. The rug really ties the room together.
Just coming back from the HispaLinux congress in Madrid. This was a very short trip: only two days in Madrid, traveled all this and did not have enough time to eat enough ham.
Update on Extremadura from Jose: they are 100,000 Linux desktop machines in the administration and 276 machines on public centers. The public machines are fewer than the 1,500 from the Telecentros, but still a healthy number.
The fine folks in Spain have a Live CD with Ximian Desktop 2. You can try Ximian Desktop without installing Linux on your machine, the whole system runs from a CD.
Federico pointed me to the announcement of OpenOffice's support for C# and the CLI, it is here:
We are pleased to provide a preview of the CLI-UNO language binding. It gives developers the possibility to write client programs for OpenOffice.org, as well as stand-alone UNO applications, with CLI languages, such as C# and VB.NET.
The details about the language binding are here: http://udk.openoffice.org/cli/cli-uno.html.
The Microsoft PDC program is getting more and more interesting. As a sneak preview of the table of contents of a System.Xml/System.Data based book shows. Dare also sent me a link to the ASP.NET changes. Fantastic!
Lluis, the developer behind Mono's XML Serialization, a large part of Remoting and our SOAP web services stack has started a blog. His first post is about the his GenXS tool used to create custom XmlSerializers (a feature not found on Microsoft's edition, but that we use in a few places).
Dare linked to Omri's posting about why binary serialization for XML is a bad idea.
I have not really formed an opinion, and am definitely not an expert on the matter of binary serialization for XML, but I believe that Omri's position is an incorrect one. Omri's thesis is that there are multiple things that you might want to opmize for: size, parsing speed and overhead for generating the data and that it is not possible to define a file format that satisfies all of those different needs.
This is not new, and this happens with everything we build today: as software developers we constantly have to balance multiple needs: maintainability, performance, extensibility, perfection, scalability, configurability, usability. The job of an architect is precisely to find a good balance taking input from multiple sources. We are going to make mistakes, every step of the way, but the sooner we start making those mistakes, the earlier we will be able to collect real data on the issues at hand.
The other problem with Omri's thesis is that it misses one bit: who are those likely to benefit from a binary format? They probably will fall in two camps: those who want smaller chunks of data transfered, and those who want faster encoding/decoding of the infoset not the average XML user.
We do not need to satisfy everyone, just a large percentage of the user base. The others can feel free to define a different format, or ignore this solution altogether or build on top of this in the future.
For instance TCP/IP makes no guarantees on quality of service despite the fact that many people have valid and important uses for it. Still, it did serve a large community of people and what is even more interesting: clever people found ways to work with these limitations and do a reasonable job given the foundation.
Some time ago, I spoke to Daniel Veillard the author of Libxslt and Libxml. When Mono started, we wanted to reuse as code as possible, and those two libraries made a lot of sense to reuse.
The problem is that .NET Framework defines three mechanism for handling Xml: the Dom model, the pull parser, and the path navigator (a DOM-like interface). It was not possible for us to just use libxml to implement our Xml needs, it would have added too much overhead, and would have been an ugly hack.
.NET contains two pretty clever tricks: the pull parser (XmlTextReader and XmlTextWriter) and the path navigator, which exposes a cursor-based navigation interface. The beauty of the interface is that you can wrap any kind of data source and expose it to the XML subsystem with this interface. So you can wrap a database, a comma separated value file, a file system, anything you can think of, and dynamically provide the content. Interesting because it is possible to use XPath queries on top of it, or apply xslt transformations. XSLT in .NET is built completely on top of the XPathNavigator.
For a long time, in Mono we used libxslt: we would dump all the data from an XmlDocument, or a XPathNavigator into a temporary file, and then use libxslt to do the heavy lifting.
This approach had various problems: libxslt was not designed to be thread safe (a requirement for us: on ASP.NET we need to be able to do xslt transformations from multiple threads), so we had to add big locks around the xslt invocations. Also, it was not possible to create a context for the transformation, so extension functions were global to all the transformations. The only solution was to shutdown and restart the libxslt engine every time we did a transformation, not really optimal.
Fixing the problem was not going to be easy. Libxslt is a very large piece of code, and Daniel estimated that re-implementing it would take about a year. That is why I discouraged 16-year old Mono developer Ben Maurer from working on this project. He was not really ready to spend a year of hairy coding, and would likely not be able to do something even as fast as Libxslt.
Ben ignored my advise and went on to implement a managed implementation of XSLT. The idea was to remove the libxsl dependency: remove the temporary files, fix the extension object problem, and the locks.
In the course of a couple of weeks this summer, Ben had the basics of XSLT done, and he recruited the help of Atsushi to help with problems and missing features in the XML core, and Piers to fix and improve our XPath implementation.
The three hacker team in less than a month did a tremendous amount of progress implementation was able to be used instead of Libxslt for Monodoc.
The surprising news this week is that Ben has made Mono's managed XSLT faster than the C-based libxslt. Faster on a number of the XSLTMark tests and on other practical stylesheets (including the stylesheet used in Monodoc). The performance can be attributed partially to some performance improvements Atsushi did to our handling of XPathDocuments. The other part was the tireless work of Ben in doing performance tuning in our implementation: from profile-driven changes like removing calls to foreach on ArrayLists with loops to architectural changes. The biggest improvement was adding an interface for resolving functions/variables at compile time.
Atsushi mentioned that lots of the performance improvements came from Ben reusing concepts from SAXON. SAXON is the fastest xslt implementation out there, and its written in Java.
Congratulations to all the Mono XML crazy hackers for achieving this fantastic progress in so little time.
The Mono IL assembler has finally matured to the point where it can be used to bootstrap the Oberon IL compiler on Mono. The details are in Jackson's Blog.
Of course, some of you might want to laugh because we got generics support before Oberon worked ;-)
Go Jackson!
Anne talks about our recent discussion. She wants to reuse the Mono CLI, and build on top of it patent-free technologies along the lines of the technologies done in the past for Java (Cocoon, Struts).
She is absolutely right about the need to build a parallel universe of technologies. In Mono we have already started this process:
Jonathan Pryor has written a tutorial about Marshaling on Mono and the .NET Framework. Hopefully this will become a chapter on the Mono Handbook
One of the points discussed on the document is about string marshalling in .NET and the limitation imposed by the current specification. Sadly the ECMA specification (and .NET) only cover Ansi and Unicode as encodings for strings. Both are also underspecified, they are both `platform independent encodings'.
This is a problem, because there is no such thing as `Unicode encoding'. There are specific ways of encoding: utf-8, utf-16, ucs-2, ucs-4 and others. Which one are we talking about.
The issue we face on Unix and Windows is that there are plenty of libraries that have very specific requirements. We first ran into this problem with the Python bindings to .NET. Python can be compiled to either use utf-8 or ucs-4 API entry points.
Another example is Gtk#. Currently it generates bindings like this:
[DllImport("libgtk-win32-2.0-0.dll")]
static extern void gtk_label_set_text(IntPtr raw, string str);
public string Text {
set {
gtk_label_set_text(Handle, value);
}
}
The above uses the default "Ansi" encoding, which we have conveniently mapped in Mono to do a conversion from Unicode to utf-8 (Gtk+ uses utf-8 as input). But this is not entirely correct. The trouble is that to be entirely correct we will have to generate code like this:
[DllImport("libgtk-win32-2.0-0.dll")]
static extern void gtk_label_set_text(IntPtr raw, IntPtr str);
public string Text {
set {
// Marshaller is a helper class that every developer
// has to roll on its own.
IntPtr raw_str = Marshaller.ConvertToUTF8 (value);
gtk_label_set_text(Handle, raw_str);
Marshaller.PtrToStringGFree (raw_str);
}
}
This is not a problem for Gtk# which is generating the bindings for us, just a bit more of annoyance, but it is a problem for newcomers to .NET who will find the above just too complicated for average use. Not only that, but the other problem is that most of the time the app appears to work. It is only under stress conditions found during deployment (or testing if you are lucky) that the developer will be bit by this missing functionality.
We identified a couple of unused bits on the encoding for this attribute in the ECMA spec, and suggested that they get used for the most populate encodings (utf-8 and ucs-2 I believe), but we were turned down by Microsoft. The current position is to use a platform specific attribute to encode this. This has problems, because we can not be compatible with .NET unless we all adopt the same scheme. The other problem is that by using a real custom attribute to do this, as opposed to a synthesized one (the attribute being turned into a bit value) is that we will loose performance.
Anyways, too bad that Microsoft is not interested in fixing this platform usability issue, specially since they have been focusing on fixing things that would force programmers to write more code. This seems like one of those things.
Microsoft recently sponsored a research to compare the development costs of using .NET and J2EE to build enterprise applications. The story is here.
The results are not surprising to me. The study claims that .NET is on aveage 28% cheaper than developing with J2EE-based frameworks. Both J2EE and Swing have been over-engineered and over-designed. It is probably a very solid design, but has abused the model-view-controller architecture. If not kept under adult supervision architects designing MVC platforms make the development of average applications cumbersome.
The results are exactly along the lines of the input we received in March 2003 when we did the Second Mono Survey. Our Survey focused on ASP.NET as a technology for developing web-based applications, and the people we had a chance to interview gave us that same message: ASP.NET saves them on average 20% of their development time.
The research study we did shed some light into the debate. The application serving market can be divided in three groups:
| Market | Development Price Range (dollars) |
Technologies | State |
| Entry level | 0-200,000 | Php, Python, Zope, Perl, home-grown, cgi-bin, asp, aps.net, jsp, j2ee | Plenty of offerings, no dominant player. |
| Mid level | 200,000 to 5,000,000 | J2EE, ASP.NET | J2EE had an early start, but ASP.NET is taking over. These are multi-developer projects of six to twelve months. This market is very sensitive to development times, and a 20% to 28% increase in productivity makes ASP.NET solutions more competitive price-wise and more profitable. The Windows-only nature of ASP.NET its the only thing stopping its mass adoption. |
| High level | 5,000,000+ | J2EE and ASP.NET | J2EE is considered the standard to use. These projects require
hardware mobility and are large organizational projects. The availability
of many J2EE providers is considered a big plus. The lack of third-party providers for ASP.NET slows down its adoption in this market. |
Mono is by no means ready to be an ASP.NET provider on the high-level application server market today, but the mid-market is the sweet spot for Mono and will help drive the adoption of ASP.NET. This is very compelling, because developers can use the state-of-the-art Visual Studio to create their applications (cutting costs there), and deploy on Linux (cutting costs on the server side).
Nat asked me to write a small document for people who are interesting in creating applications with plugins. The following is the smallest setup I could think of (this is the same model I used on the Dashboard).
The Common Language Infrastructure has various mechanisms that developers can use to extend their applications with plugins. This document describes the facilities available and some possible implementation strategies.
Plugins are dynamically loaded modules that extend the functionality of an application. Plugins can be used to enable developers to extend an application after it has shipped, and also as a modularization technique. Applications like the GIMP use a plugin architecture to implement transformation and file formats.
When a program or a library are compiled into assemblies (the binary file format used by the CLI)the information about the available classes, methods, variables, names, parameters are stored into the resulting .exe or .dll. This information can be later retrieved through the Reflection API.
Technically, the only difference between a .exe and a .dll in the CLI world is that executable files contain an entry point, and libraries do not.
For example, the following program will list all of the types available in an assembly. Both a .exe or a .dll will work:
using System;
using System.Reflection;
class ListTypes {
static void Main (string [] args)
{
foreach (string file in args){
Assembly a = Assembly.LoadFrom (file);
Type [] types = a.GetTypes ();
Console.WriteLine ("Assembly: " + file);
foreach (Type t in types)
Console.WriteLine (" Type: " + t.Name);
}
}
}Compile and run:
$ mcs query.cs Compilation succeeded $ mono query.exe demo.exe Assembly: query.exe Type: Class1 $ _
Once an assembly is loaded, it is also possible to extract the available methods or dynamically invoke methods in the recently loaded assembly. For example, the following program will invoke the method "Boot" on any types passed on the command line.
using System;
using System.Reflection;
class ListTypes {
static void Main (string [] args)
{
foreach (string file in args){
Assembly a = Assembly.LoadFrom (file);
Type [] types = a.GetTypes ();
Console.WriteLine ("Assembly: " + file);
foreach (Type t in types){
MethodInfo boot = t.GetMethod ("Boot");
if (boot == null)
continue;
if (!boot.IsStatic)
continue;
boot.Invoke (null, new Type [0]);
}
}
}
}We are using the Type's GetMethod to fetch the public method named "Boot". If we find such a method, we invoke it. In this particular example, we want to invoke static methods, so we test for this and we also pass `null' as the first argument to Invoke.
The following sample program can be used to test our new loader:using System;
public class Demo {
public static void Boot ()
{
Console.WriteLine ("Demo.Boot invoked");
}
}We compile and run:
$ mcs loader.cs Compilation succeeded $ mcs -target:library demo.cs Compilation succeeded $ mono loader.exe demo.dll Assembly: demo.dll Demo.Boot invoked $ _
It is now possible to load code dynamically, but a plugin-system often will need to access the internal data structures and methods to carry out a more interesting job. Our plugins can invoke easily any methods that is available to thme at compilation time.
The following sample program shows a tiny spreadsheet application which provides support for invoking plugins.
using System;
using System.Reflection;
public class Spreadsheet {
string [,] cells = new string [10, 10];
public string this [int col, int row] {
get {
return cells [col, row];
}
set {
cells [col,row] = value;
}
}
}
public class Driver {
static public Spreadsheet sheet = new Spreadsheet ();
static void Main ()
{
string cmd, r;
do {
Console.Write ("cmd> ");
cmd = Console.ReadLine ();
string [] args = cmd.Split (new char [] {' '});
switch (args [0]){
case "set":
sheet [Byte.Parse (args [1]),
Byte.Parse (args [2])] = args [3];
break;
case "get":
r = sheet [Byte.Parse (args [1]),
Byte.Parse (args [2])];
Console.WriteLine ("value: {0}", r);
break;
case "plugin":
InvokePlugin (args [1]);
break;
}
} while (cmd != "quit");
}
static void InvokePlugin (string plugin)
{
Assembly a = Assembly.LoadFrom (plugin);
foreach (Type t in a.GetTypes ()){
MethodInfo method = t.GetMethod ("SheetPlugin");
if (method != null && method.IsStatic){
method.Invoke (null, new Type [0]);
break;
}
}
}
}Compile the above like this:
$ mcs sheet.cs Compilation succeeded $ _
Here is the `export.cs' program that we will compile as a plugin:
using System;
public class DumpSheet {
public static void SheetPlugin ()
{
for (int r = 0; r < 10; r++){
for (int c = 0; c < 10; c++)
Console.Write ("{0}, ", Driver.sheet [r, c]);
Console.WriteLine ();
}
}
}Notice that this plugin needs to access the sheet object in the Driver class from the main program. We will compile this as a library which references the main application. This effectively treats the main application as a library consumed by the plugin.
$ mcs export.cs -r:sheet.exe -target:library Compilation succeeded $ _
A sample session looks like this:
$ mono sheet.exe cmd> set 0 0 hello cmd> set 0 1 world cmd> set 8 8 Eight cmd> plugin export.dll hello, world, , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , Eight, , , , , , , , , , , , cmd> _
There are plenty of other scenarios and ways of structuring your program to have a plugin system. Currently part of the contract used in this document was to use the public classes, methods and fields exposed by the host application. A common pattern used in plugin systems is to provide a class method to register objects and handlers with the host application.
The anticipated release of Gnome 2.4 is out now. It includes a list of Why use Gnome?
Ars Technica has a pretty good review.
Plenty of us the Mono developers and Linux developer got together during the Brainshare event in Barcelona. Lluis (the man behind the implementation of Mono's Remoting and Mono's WebServices support) lives in Barcelona, and Gonzalo (Mono's ASP.NET developer) was coming back from vacation from Istambul. It was the perfect chance to discuss Mono.
Juantomás (HispaLinux's president) joined us on Monday night, and Man, Andreu and Osorio showed up on Tuesday for a few hours for dinner. We had a great time with both our new co-workers are Novell and the Spanish Linux crowd in Barcelona.
Jordi Mas who has been working on Abiword and on the catalonian support for various free software projects is developing an interest for Mono. He has plenty of Win32 experience, and he is interested in helping us move Mono's Windows.Forms support forward. He advocates following a single path: Wine-based Windows.Forms and customizations to Wine to make it track the Gtk+ theme and dropping our support for the Gtk+ based toolkit.
Spent a fair amount of time with Nat: mostly at night when tracking the best restaurants that served jamón and the bars afterwards. Nat had a little accident with his new cell phone.
One of the benefits of joining Novell for us was that our products have a much bigger audience now. This is due to the fantastic channel that Novell has with enterprises. During the conference we met many sales and solution engineers of Novell, many of them already with contacts of people interested in Linux-based solutions (both the Novell Linux software stack for servers as well as the desktop side).
Plenty of people at the confere are considering Linux on the desktop, a recurrent topic with people we met on the hallways was large scale enterprise deployments.
XD2 has the right mix of components to make the Linux Desktop on enterprises a reality:
Nat did one of the most amazing presentations I have ever seen on why the above software stack is the right one for Linux on the desktop.
We are collaborating with other teams inside Novell to support the Novell software stack: Groupwise, i-Folder, e-Directory and Liberty Aliance authentication
In Andalucía, 20,000 Gnome desktops were just launched. I have to take a trip there to witness this again. 20,000 Gnome-based machines on 1,800 schools in Andalucia. I have to go see this. Congrats Gnome folks!
The Telecentros experience in Sao Paolo was very interesting, because the site I went to was one of the centros equipped with accessibility hardware.
Yesterday I arrived to Barcelona for the Novell Brainshare event.
Got together with Chema, Lluis and Nat. Went relatively early back to the hotel, and discovered that we had wireless access, so we hung around until 4am. Nat's humor quality is directly proportional to how long he has gone without sleeping.
In our effort to improve the documentation in Mono we have been working on a GUI tool to browse all kinds of documentation (Monodoc), but we need more people documenting our APIs.
To address this problem, we are making it really simple for people to contribute documentation: we have made our documentation editable. When you are viewing a stub, you have the choice to edit it; For example:
Summary
To be added [Edit]
I recently added a preview viewer for it, for example here we are editing some documentation:
All those changes are saved into a changeset, that the contributor can submit when he is ready. We will submit those using Mono's web services infrastructure. When the changes are reviewed and approved, we commit those to CVS, and they appear on the next release of the code.
This same infrastructure will help for our collaborative annotations for the documentation. This is important to have people share their personal experiences and samples for any given API.
What I really like about blogs is that sometimes people sit down, and write little essays reflecting on their experience. My personal choice is from the craftsmen: because they tell you tales and lesson from the trenches.
I can not make justice to the beauty of Eric's latest entry: F5.
While doing my daily reading of the SWT-port-to-C# reading this morning, found this post that describes the torrid story of Swing and SWT.
Update: That document contains various errors on the side of the origins of Swing. For more details see this thread.
Amy describes her experiences with the iPod and a native user interface here. Very good point about using native interfaces. Firebird already has a couple of XUL-based clients that let the user browse Amazon more comfortably than using the regular Web interface.
I have been reading Al Franken's Lies book. It has been entertaining for the past couple of days, but it turned out really interesting on the chapter on the Clinton efforts on the war against terror and how the Bush administration dropped the ball on that (chapter 15, but it shines on chapter 16).
I tried writting a summary, but its impossible to make justice to those two chapters. It is particularly interesting, because Franken got a team of Harvard graduates from the Kennedy school to fact-check everything he wrote.
Anyways: mandatory reading if you stop by a book store.
To see The Band on the Runtime perform
I am using a new IBM T40 now as my main computer. I was about to go for the X31 which is lighter and smaller, but I have gotten used to the large resolution from my old T30.
Michael Zucchi provided me with a few links to people running Linux on the T40. Most hardware is supported on the T40, but the speed of the hard drive left much to be desired. The new T40 felt like it could not handle the load the T30 did. Any IO would make the system very slow.
After dropping by the #kernel channel on LinuxNet, I was told to upgrade my Kernel to the latest RH update. So far the speed of my hard drive went from 2.5 MB/second to 25 Mb/second. An e-mail expunge that used to take about two minutes seconds, now takes 13 seconds.
I am going to the PDC, hoping to listen to Don's new single.
Gonzalo and Lluis from the Mono team are coming as well.
Also found the PDC Bloggers site.
A completely unproductive day. I just moved into my new apartment, where I will be Nat's neighbor.
Verizon cancelled my DSL during the move, and am using a kind soul's wireless access.
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:
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.
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.
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.
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 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 ;-)
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.
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:
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:
Guido recently quoted a conversation we had about Parrot. I said to him that the Parrot VM design was based on ideology (Guido quoted me as saying religion ;-).
One of my favorite books is Computer Architecture: A quantitative approach.
The parrot design is based on ideology because some of the core design considerations are just that: `real machine use registers, hence register-based intermediate code is faster'. An ideology-based design is one where the design decisions are driven by punch lines and not by a careful and quantitative study of the problem at hand.
Mono implements the .NET virtual execution system; This execution system uses a stack-based instruction set to transport code. Mono never actually sees the stack operations, because we treat the stack-based operations by their name: a serialization format for a tree representation of the original code.
So for example, if you have an operation like:
a = b + c;
The code can be thought of as:
A possible serialization of this tree is easily expressed by a lisp-like expression:
(assign a (add b c))
Another possible serialization is using bytecodes, for a stack machine
:ldloc b ldloc c add stloc a
The above set of stack instructions can be easily decoded back into its original form (see drawing above). This is what the Mono JIT does: it transforms its input CIL bytecodes into various trees like this (we call these the forest of trees):
(stind.i4 regoffset[0xfffffff8(%ebp)] (add (ldind.i4 regoffset[0xfffffff4(%ebp)]) (ldind.i4 regoffset[0xfffffffc(%ebp)])))
The above if the debugging output that renders our C-based trees. We then use a code generator generator to transform the high-level operations (not listed in this example) into a list of low-level instructions:
1 loadi4_membase R9 <- %ebp
2 loadi4_membase R10 <- %ebp
3 add R8 <- R9 R10 clobbers: 1
4 move %eax <- R8
Depending on the optimizations turned on, there might be other steps involved, the end result is:
mov 0x8(%ebp),%eax mov 0xc(%ebp),%ecx add %ecx,%eax
(Actually, I had to trick the JIT compiler into doing this, because dead-code elimination and inlining in Mono eliminate redundant code).
Now, am interested in this debate, because I think that Mono and the .NET VM are ideal virtual machines for scripting languages. Since the .NET folks have done a fair ammount of work into the interop issues (The Common Language Specification) and it is a fairly advance virtual machine, my interest is making Mono a good host for those languages.
It has been said `.NET works great for static languages, but not for scripting'. Which is not true; VB.NET and JScript are both dynamic languages that happen to work just fine on the .NET Framework. And we are convinced that the virtual machine can be improved.
The main issue we have today with Mono and scripting languages is that nobody has done a quantitatie study of what are the performance problems of running a dynamic language in the .NET/Mono CLR: Without an attempt to have a native compiler for the platform, and studying the problems, it is not possible to solve them.
In one particular case (Lisp), we know that implementors will likely want to structure their code (or their generated code) like this:
class Cell {
Atom Head;
Cell tail;
}
Method ()
{
if (object is Cell){
...
} if (object is Atom){
...
}
}
So what they need in this particular case is a fast implementation of the `is' operator (the `isinst' instruction). For this, we did a proposal
Lots of Mono improvements recently; We released version 0.25 recently, which included plenty of the updates to the runtime and class libraries that were required by our partnership with Source Gear to run their vault software on Linux.
Still doing plenty of traveling, after the awesome GUADEC conference in Dublin, I visited Madrid fora couple of days, and then came to Mexico to do some paperwork. Will be flying to Oregon to the O'Reilly conference on July 8th
Will be on Mexico this weekend, and I get to vote (por the PRD of course)
Data Loss
My T30 hard drive died today with all of my information. If you know of a good data recovery service that deals with Linux file systems, please let me know (mailto:miguel@ximian.com.
Now I have an excuse for not replying to pending mail.
Update: I did recover all my data from a company that does disk drive recovery. I was fortunate enough that only the beginning of the hard drive got scratched, and my Linux data partition was not there. Now a long and painful process of pulling the data back begins.
Generators Zen
I got most of the iterators support on the Mono C# compiler working now, hopefully these will be checked in CVS as soon as I polish a few things. You can read a small tutorial about them here.
I think that this has more potential than advertised.
Basically, the iterators support in C# simplifies the implementation of methods that return IEnumerable and IEnumerator classes. Typically an implementor would have to create a helper class that would track the state of the enumerable class, and implement a number of methods: MoveNext, Reset, and GetCurrent. Implementing this state machine is not only boring, but also error prone.
Implementing these patterns are so boring, that the average developer fights the system, and designs clever workarounds: From passing a delegate (a method pointer) to be called back, and have the enumerator work linearly; to construct an array with all the results, and returning this; or the worst, exposing the internals of their object. These solutions might work, but they are not available to the platform developers, as they have to provide the right framework for developers; This also means that average developers wont have their code integrate nicely with the underlying platform and interoperate nicely with others.
The C# iterator support works around the problem. Now it is trivial to implement these enumeration interfaces. There is no excuse to not use the system pattern, as it is so simple to use. Lame sample follows:
IEnumerable CountToThree ()
{
print ("About to say one");
yield 1;
print ("About to say two");
yield 2;
print ("About to say three");
yield 3;
}
When invoked, say from the foreach construct:
foreach (int value in CountToThree){
print (value);
}
The message "About to say one" would be printed, then, the routine would return, and the value would be printed by the print in the foreach main loop. Then, when the next value is about to be retrieved, the execution will be resumed where it left, and the string "About to say two" would be printed, and the value 2 returned.
Notice something: the values are not pre-computed ahead of time and returned: they are returned as they are consumed. This is implemented by a clever state machine and an internal class generated by the C# compiler.
Now, today as I explained my excitement to Ettore on the yield keyword, I realized that it could have more uses outside the scope of implementing enumerator interfaces. Part of the beauty of the yield is that from the developer perspective, it suspends the execution of the method at that point, only to be resumed later on.
This beauty is not obvious at first. It took quite some time for me to assimilate this. Lets repeat it again: the yield keyword suspends the execution of the routine, only to be resumed later. This is not only interesting, this is absolutely fabulous.
What the designers of C# have done here, is that they have taken an annoying and error prone pattern and have made a language extension that effectively addresses a problem.
But it seems like yield could be used for a lot more. In fact, over the years I have implemented plenty of state machines, in the presence of non-blocking operations. Non-blocking protocols handlers, parsers, and GUI applications. It starts to feel like a waste to have this functionality under-used.
For example, an streaming XML parser looks like this:
HandleToken (int token)
{
switch (state){
case START:
if (match (token, "<")){
state = "<";
error ();
case "<":
if (match (token, identifier)){
state = IDENTIFIER;
error ();
case IDENTIFIER:
if (match (token, OPEN_QUOTES)){
state = QUOTE_HANDLING;
} if (match (token, ">"){
state = START;
}
}
}
It would be fascinating if this could be implemeted with yield:
HandleToken (int token)
{
open:
if (match (token, "<")){
yield;
if (match (token, identifier)){
yield;
if (match (token, OPEN_QUOTES)){
...
} if (match (token, ">")){
yield;
goto open; // you know you love it.
}
}
}
}
Ok, that is probably not the best example, as this is just the first time I have thought of this (Am sure the lisp, scheme, icon people have better examples of this). The one things missing here is how to resume the method, and how to provide any new parameters to it. Maybe a resume (method, args) would do the trick.
But the same sort of patterns exist on GUI applications: for example consider the state handling of user input while doing region selection (or the other hundred states tracked by Gnumeric for example).
Extending C# string support
A few things I would like to see in C#, these do not even require changes to the language, but only to the String class:
class String {
//
// Returns the string STR replicated COUNT times.
//
static string operator * (String str, int count);
//
// Splits the string used the provided string
//
static string operator / (String str, String sep);
static string operator / (String str, char c);
//
// Extracts a range of characters, notice that String.Substring is annoying
//
static string this [int start, int end]
}
string s = "Hello World;
print (s [0, 4]); // prints "Hello"
print (s [-2, 2]); // prints "ld"
print (s * 2); // prints "Hello WorldHello World"
string [] j = s / " "; // returns {"Hello", "World"}
Wikis
Been fascinated about the Gtk# Wiki
After Zoltan got us some nice 20% of performance back in the compiler by providing the GC with object maps and having the compiler drop unused structures early on, I felt compelled to do some performance work myself. My results not as impressive as Zoltan, got us another 10% from using a negative type lookup (it was there, but not fully used) and another 5% from using the new namespace information (Paolo got us a new Mono method to fetch all the namespaces in a type).
Also been fixing plenty of bugs in the compiler so Paolo wont complain when I look at C# 2.0 features. There is one bug that I have tried to fix four times now, and made some progress. I have patches to fix part of this, but not to gracefully handle some of the side effects.
After doing pure bug fixing this weekend, I started the work on C# Iterators, a fascinating new addition to the language. Initially I got pretty scared at them, because I did not have any ideas on how to handle the iterator state. Now that I figured how trivial and simple it is, I started to implement it. This is going to be very nice to use.
Only two hospitals are functioning in Baghdad after all the looting and robbing after the city was "liberated". The only building that has been protected from looting was the Iraqi Ministry of Oil.
But that is just a coincidence. In the meantime, the history of civilization, and the history of Iraq has been destroyed, set on fire. And the Bush administration is distracting people now with an increased set of verbal attacks on Syria.
The era of dictatorship has ended in Iraq. The new century of idiocy reigns on the world.
A couple of interesting photographs from the fall of Baghdad.
John Pilger on Blair's responsibility
on war crimes:
A BBC television producer, moments before he was wounded by an
American fighter aircraft that killed 18 people with "friendly fire", spoke to
his mother on a satellite phone. Holding the phone over his head so that she
could hear the sound of the American planes overhead, he said: "Listen, that's
the sound of freedom."
OrbitaFM, my favorite mexican radio station is broadcasting on the Internet. Finally I can keep up.
Today: Global March against the war: Occupation is not Liberation, for more details go to the Intenrational Answer site.
I used to wait for Robert Fisk's coverage to reach the sites I track (CommonDreams, ZMag and Jornada), but with his daily coverage from Baghdad, covering the other side of the story, I have been tracking him directly on the Independent newspaper.
The latest articles from Robert Fisk (which Duncan and I had the priviledge of listening to at MIT two months ago):
Michael Moore's has an awesome letter on his web page. The best bits: his movie, his books, and his web site are getting more hits now than ever. His book (Stupid White Men) has jumped for the fourth time to the New York Times bestseller list (very unusual); His documentary Bowling for Columbine has been ordered more than Chicago;
He looks over various cases of people who criticize the war, and finds that the media is not telling you the truth: there is no backlash against those who protest the war, but quite the opposite. But I guess that is what we get for consuming news from a single source.
My new book
from John Pilger, arrived this week.
The first chapter talks about Indonesia and the dictatorship that was
established there on the 60's (Guess who was behind sponsoring it?) and the mass
killings of dissenters. I had heard the stories about East Timor, but never got
into the details of what happened. Corporate greed, and just like in the case of
Vietnam: the desire to control one of the most resource rich parts of the world
(tin, oil, rubber, coal).
The IMF and the World Bank appear once again as the stars of the show: sinking Indonesia into deep poverty, and promoting what can best be described as an enslaved society.
Finished
Greg Palast's new edition of `The
Best Democracy Money Can Buy'. You should go to your library or bookstore,
and read this book now. One of the few books that got Nat upset.
I strongly recommend the two books above. Do not wait, just get them today (or come by my office to grab them)
Today's miggy-economic advise to countries all over the world: keep the World Bank and the IMF loans away; Do not cave to pressure to change your laws in favor of foreign investment; Do not erode your civil rights, and civil liberties in favor of a unproven economic plans (do not forget to ask for references, because there is not a single good reference); Do not sign any free-trade agreements; Push for high tariffs if you want to survive; Provide state-sponsored social programs. (Hint: Chile does not count, they smartly cheated on the IMF/WorldBank)
Quotes:
One of the fundamental findings of cognitive science is that
people think in terms of frames and metaphors -- conceptual structures like
those we have been describing. The frames are in the synapses of our brains --
physically present in the form of neural circuitry. When the facts don't fit
the frames, the frames are kept and the facts ignored.
And:
Third, it must have a clearly articulated moral vision, with values rather
than mere interests determining its political direction.
As the war begins, we should look ahead to transforming the anti-war
movement into a movement that powerfully articulates progressive values and
changes the course of our nation to where those values take us. The war has
begun a discussion about values. Let's continue it. First, the anti-war movement, properly understood, is not just, or
even primarily, a movement against the war. It is a movement against the
overall direction that the Bush administration is moving in. Second, such a
movement, to be effective, needs to say clearly what it is for, not just what
it is against.
Robert Fisk reports from Baghdad, on the American/British invasion.
| Ali Ismail Abbas, 12, wounded during an airstrike according to hospital sources, lies in a hospital bed in Baghdad, April 6, 2003. Abbas was fast asleep when war shattered his life. A missile obliterated his home and most of his family, leaving him orphaned, badly burned and blowing off both his arms. |  |
More photos of the victims of the invasion.
300 new pictures of slogans, but I will spare the audience the download.
I share Ettore's
frustration. I have avoided watching/reading the minute-by-minute war analysis,
which is just dehumanizing. On the other hand, I have kept up with the events by
tracking Common Dreams as well as
Robert Fisk's C-Span had a debate about war with Daniel Ellsberg. He mentioned antiwar.com, I found Blogs Against War and found Raph's Other blog
Laughed off stage: The following video from C-SPAN is amazing. It is worth listening to the whole thing, Ari is a professional question dodger. But check the video, and go to minute 28, and listen ;-)
The video
Also the American Embassador in Athens resigns to his post due to the administration push for war against Iraq.
In the meantime, an interesting analysis of the new hatered being promoted in the US towards the French.
Russell Mokhiber on covering the White House. Russell writes the famous Ari and I column.
The last bit of the article points something we did not know. When the mexican vote on the UN was discussed, a couple of news papers ran the story that the vote was being bought. The press reported what Ari says at the end. But they did not report the feedback following it. Read it, its fun.I always have enjoyed comments and criticisms from Jamie Zawinski. His insight into this industry, and the communities of this industry are unique, and combined with his sense of humor, it makes for some of the best comments you are likely to read.
Recently Jamie wrote some comments about how those of us in the open source world, and in particular gnome likes to rewrite software gratuitously. I happen to agree with him
Today I upgraded my gnome installation to gnome 2.2. The application I use the most is the terminal. For a long time I had been using happily gnome-terminal which used Michael Zucchi's fast Zvt widget. The UI code was written mostly by me. This terminal had the advantage of being easy to customize and was fast (both at input and output. Keep this in mind). It supported dingus clicking, as well as mouse input, was an international terminal and I was happy.
With Gnome 2, an effort was made to improve the user interface. The "terminal class" concept from gnome-terminal 1.0 was considered too complicated, so a new effort to rebuild gnome terminal from scratch was started and completed by Havoc. This terminal became the new gnome-terminal for gnome 2.0. During the rewriting process a number of features that people had requested were dropped (flags to control the behavior of "logging" the presence of the user: update utmp, wtmp, lastlog) so I promptly filed bug reports for it. Those bug reports were promptly closed, and marked as duplicate because more information was needed (the xterm man page had this). Eventually all this information got logged into another bug and I guess someday it will be implemented.
Anyways, am a grown up man, and I can live with the defaults. If I need to tweak something, I figured `I have the source code'
Today I upgraded to Gnome 2.2. This new version of Gnome includes a new gnome-terminal that drops support for Zvt and instead uses a new terminal widget called Vte. Vte is different from Zvt in that it uses more of the traditional Gimp/Gtk coding style and apparently will be easier to maintain. But the main difference is that Vte is not an xterm emulator, instead it is a terminal emulator that will emulate any terminal, given a terminfo definition for it. This is an interesting academic excercise, no doubt about this. I had my reservations about whether Vte's academic background was good enough as a terminal solution. As I still depend heavily on my terminal, and I still use Midnight Commander as my file manager a good terminal is important.
You could arge argue that terminfo is not a complete definition of a terminal, but only the subset that was used for terminfo/curses, but lets not get these facts get in the way of innovation.
Anyways, my first attempt at using vte with the mouse failed. Apparently events are sent for up to some number of columns, but not all. So it is useless if you want to click on the right pane of mc.
To be fair, Vte lets you use any font on the system, and not only those that were monospaced fonts, which is nice.
Later, I was faced with the slowness of the terminal. I have a P4 running at 1.8ghz. I turned off anti-aliasing (everyone told me to). But it still was slow, for instance if you have a window on top of it, and you drag it around, the widget takes a *long time* to repaint. I mean, significantly longer than OpenOffice or Mozilla take to repaint.
Haven given up on coffee and Sawfish I figured I could also give up dragging windows around. There is really no need to drag windows around see note [1]. But it was still slow, very slow. Someone reported:
fejj: lets put it this way
fejj: nautilus 1.0 can render my home directory faster than vte can
render the output from `ls`
fejj: in my home directory
For those of you non-Gnomites, Nautilus is the Gnome File Manager, and a few years ago, it had a reputation for being slow.
It is also annoying that a compile will take 50% of the time on gcc, and the other 50% by your terminal process as it scrolls the window.
I did not want to spend all day fixing gnome-terminal, so I ran `xterm'. There is enough a man can do and still get something done in the day.
Well, turns out that the default xterm colors are the most annoying ever put together for an application. They hurt my aged eyes.
Next stop: Konsole. As much as it pained me, I installed KDE to run Konsole. I just wanted to get my work done, and I had heard good things about it. Konsole has a complex configuration menu, a lot harder to use than the clean gnome-terminal, but nothing that would require a PhD, as I figured it out in the time it took for the menu to popup. Ugly, crowded, but functional.
I was partially happy. Konsole performed decently speed wise, but it consumed too much memory. I guess it is designed to run on rendering farms. I have enough memory, so I did not particularly care about the 12 megs used at startup. But unlike gnome-terminal which uses a single process to render multiple windows (a nice memory saver), every time you start konsole, a whole process is launched. I could survive, thanks to my loyal 512 meg on-board simm chip. But when I was editing a file, and holding the cursor key down, I noticed an unbearable lag. Konsole was good for text output, and re-rendering of its window, but it is just unbearable for text input.
Me, being the savvy `configure; make; make install' kind of user, decided to build my own gnome-terminal with Zvt. Well, surprise. There is no more support for Zvt in gnome-terminal in the main branch on CVS. Time to use my cvs skills to check out a version of Gnome Terminal that used Zvt. I did so, but the new Zvt has been hacked to use Pango, and it is just as slow as Zvt. I can understand why they dropped support for Zvt: it is now as slow as Vte and I guess if you want to emulate a Wyse-66 it will do it.
I rapidly added to my to-do list `Get an old Zvt, get an old gnome-terminal package', but for now, I wanted to get some work done.
I tried rxvt. That terminal emulator is still as bad as it was five years ago. Next.
Am back at using xterm. The UI leaves a lot to be desired, but it took me only 5 minutes to find the decent colors from gnome-terminal and paste them into the .Xdefaults file, load the resources database into the server, and another 5 minutes to add that to my session startup. I look forward to reincarnate Zvt and Gnome Terminal from its ashes one day.
Five years after Gnome, and am back with the hated xterm. Jamie's post on the `cascade of attention-deficit teenagers' development model resonated in my head.
Update: I got Zvt 2.0 and GnomeTerminal 2.0 packages running on my machine (thanks to Duncan). This is very good news. Xterm was driving me crazy (it is actually *slower* than Zvt) and I had forgotten how to set a massive scrollback. Happiness in MiggyLand.[1] Btw, there is a fabulous demo about a window manager that tries to always give the best space for a window in a multi-window desktop. Sadly, I lack any interest on it, as I like to run all my apps full-screen, and just keep an app per-desktop.
Do not forget to call your senator today: Move On's Virtual March on Washington
Blair faces a revolt, not everyone on the parliment believes a case for war has been made.
Australian legal experts warn that Attack on Iraq could end in International Court.
Paolo reports that a SIGSEGV takes a whole second to be handled in MacOS X on a high-end G4. Not even my PC/AT was so slow. (this is a null pointer dereference).
I am a simple programmer that learned perl out of the necessity to parse Unix formatted files and crunch some data. Just like everyone else.
Typically a crunching data script is born by visually inspecting the look of the file to be parsed, guessing how to parse it, write a perl loop and using the appropriate split or regular expression. Then you move on and do something useful with it.
Of course a quick glance at a file fails to reveal the underlying representation, or the rules used on it to handle corner cases. For example, parsing a comma-separated line is fine as long as there are no escape characters, or not quote-grouping, which is not always obvious during visual inspection. These special rules will appear unexpectedly in a production system, most likely because you only looked at a sample of the file, and not at all the possible combinations. God forbid you actually read the documentation for the file (and in an open source system, the challenge is to find documentation that actually matches the file format, but that is a separate story)
Recently I have been using XPath in .NET to parse, pull and extract information out of XML files. Before XPath I used to be one of those `find the node, now call a function to search the matching children node, repeat until found'-kind of person. XPath has made me a happier man. I realized that part of the pain in dealing with simple text files can be easily addressed with XPath and XML: There is a single format that you can use (and a set of tools that produce and consume valid XML) and a simple way of fetching nicely structured data (as opposed to files like /etc/inittab, /etc/fstab, /etc/termcap or the terminfo database.
Don't get me wrong. Termcap is a great file format if you have a single implementation of the beast, the only API call you know about is strtok(2) and you just learned how to test for end-of-string marker in C.
I know the above sounds completely obvious to everyone. But I liked my little realization this week. I think I might be on the path to XML Zen.
I used this tutorial to learn XPath. First match in Google.
Duncan saw a talk at Stanford by Todd Proebsting. In his talk he mentioned that it would be nice to have extensions to handle XML from your favorite programming language as XML was becoming ubiquitous. XPath gets close to this, but its typically implemented as a library routine. Then Don Box went to a conference and pushed for the same idea. Wild speculation about what Microsoft could be doing begun.
The above gave Duncan an idea: he wanted to be able to use XPath-like expressions within C# to address nodes
It ocurred to me that we could hack our C# compiler to implement Duncan's idea with relatively ease. The idea would be to flag XmlNode with a special attribute (say, [Dynamic]) and then have the compiler resolve "Member Access" expressions with dynamic code instead of using static code.
At compile time the compiler will figure out what "This.String.Method" means. One interpretation could well be `In namespace "This", pick class "String" and lookup the member "Method"'. This in turn becomes "Fetch from class-id XXXX the field YYYY". We could use the [Dynamic] flag to let the compiler know that after resolving the meaning of a particular element in a member access expression, it should not try to statically resolve the meaning of it, but do it dynamically and generate code accordingl.
So given: "XmlNode n = GetNode ();" and the expression "j = n.Types [5].Dingus" would become:
XmlNode temp1 = n.SelectNodes ("Types");
XmlNode temp2 = temp1 [5]; // Gets the fifth node
XmlNode temp3 = temp2.SelectNodes ("Dingus");
j = temp3;
If you can annotate the node with the XML Schema, the compiler could do strong type checking as well:
[Schema ("Dingus")] XmlNode n = GetNode ();
There are issues to be addressed here, like how would C# cope with identifiers like "my-element-name".
I had never thought of the markets in this way. The beauty of this visualization tool is the novel way in which data which would otherwise be hard to correlate can be easily digested with the visual cortex.
Nat sent me this chilling account of what is going on in Bagdhad
Robert Fisk came to do a talk at MIT after attending this morning Powell's presentation at the Security Council. His presentation today is one of a true journalist, I was delighted to read this interview with him a few days ago.
Robert Fisk is a reporter for the UK Independent magazine, and has been reporting on the Middle East for twenty seven years. One of the few journalists that interviewed Bin Laden.
Duncan and myself took the opportunity to have our picture taken with him:
A beautiful article from John Pilger. The first half you can skip, the second half gets graphic.
Cool pictures from the ECMA meeting coming as soon as possible.
41 American Nobel Laureates oppose war.
In Redmond this week, for the ECMA meeting.
Ariel Sharon got re-elected in Israel, a dark day for human rights.
Nat said "`Best Ari and I' ever". `Ari and I' is a series of articles with prime quotes from Ari, the White House spokesperson.
Reading Chomsky's Fateful Triangle. Published in 1983, has an enormous amount of information relevant to the current situation in Iraq. Surprisingly that all this information had been published for so long and I just ran into it.
I am loving Wilson's Ghost. A book from McNamara that did not get enough coverage when it came out (few months before 9/11).
Read the reviews on Amazon, as there are some great comments about it.
Israel will start killing people in other countries that they identify as dangerous.
Countries with a lot of power, by trying to define the rules of engagement are basically destroying the work of those that lived through the war and wanted to create mechanisms that would stop it. I have been reading the new book from former Secretary of Defense Robert McNamara on the subject. Every mechanism that he recommended to put in place as part of international policy is getting backed out in this world of war against terror.
Allowing this seems like an extremely dangerous policy for the world to allow. But there is little that can be done about it. Lets hope we do not become annoying to those running the show and we do not become targets that have to be silenced.
Last year, two armed Israeli Mossad agents were captured last year inside Mexico's congress. They were detained and sent out of the country.
Apple was welcomed by many of us because they decided to open source pieces of their operating system (Darwin).
Darwin is the core of the operating system, but does not cover the more interesting "upper layers" like the advanced windowing system, their framework libraries to create end-user applications or their collection of iTools. But any contribution is good to open source.
The code open sourced is for an implementation of Unix built on top of Mach. It has been improved over the years, and some of those improvements are very good. Sadly, Mach is a microkernel architecture. It has been demostrated time and again that microkernels are more inefficient than monolithic kernels. So today you have to need to get a more powerful computer to perform the same tasks that a smaller computer would do, as the operating system consumes those resources.
Anyways, today by reading Scripting.com, I ran into a project call ICommune. These people are extending in some way the non-open source iTunes component from the MacOS to allow people to export music as if they were file shares. The project got a letter from Apple:
Uh oh... I just received a "Notice of Breach and Termination of License" letter from Apple, stating that I violated my license to the Device Plug-in API which iCommune uses. For the time being, I'm making the download unavailable, while I try to sort things out with Apple. Sorry about this folks. Any good lawyers in the house?
Found this state of the union address. Its funny because its true.I
The E-Mexico site is running a story about the proposed open source legislation for México.
The news are all over the place now. The supreme court ruled in favor of Disney and against the people.
On the propaganda agency and what has happened so far towards secrecy.
As arabs complied with the new INS regulations to register that they are in the country, apparently one fourth of them were detained the details come from the LA Times (copy is here)
http://www.azoz.com/music/features/0008.html
Recently I was discussing with Nat the fact that I did not believe that the way corporations responded to the anonymous share holder was right. And that corporations should have a dual commitment: one social, and one to their sharholders.
He sent me this link from Adbusters.
Also, there is a new Mark Fiore
Some fun sites I read every once in a while: Mark Fiore, Things my Girlfriend and I have argue about. and In passing.
* Perpetual War Portfolio
Death is the best investment: The Perpetual War Portfolio.
* Open Secrets: how is the government ran
Democracy today is not ran by the people, but by corporations that purchase their own leader. http://www.opensecrets.org/ has the data on contributions to the ellections.
* The Best Democracy Money Can Buy:
I contributed this post to a thread on slashdot.
* Pentagon Papers
I have been fascinated by the process through which Daniel Ellsberg leaked the Vietnam study that was commisioned by McNamara to the New York Times.
Daniel Ellsberg wrote a book after 30 years of silence called `Secrets'. There are a couple of interviews with him in Salon: `My only regret' and a recent interview:
The man who leaked the Pentagon Papers talks about why five American presidents lied about Vietnam -- and how to get the truth on Iraq.
Audio from the Nixon phone conversations when the Pentagon Papers were leaked out to the New York Times. Amazing recordings. The call with Kissinger actually started the "plumbers" mess that would eventually lead to Watergate, and later to his impeachment.
* Found the National Security Archive
Lots of information on US National Security. Including information from the Pentagon Papers incident.
* Operation Enduring Fredom: Best Bloopers
Can be found: here
* Oil
My friend Adam gave me a link to this interesting story on oil
* Am I a terrorist or Not?
Am I a Terrorist or Not. Not funny.
* What the world thinks in 2002.
An interesting poll about what people think in 2002.
* Mozilla 1.2.1 and new Galeon
Am using a set of RPMs compiled by Duncan, and the Xft packages for Ximian and am loving my web browsing experience with the new Xft2-based Mozilla and Galeon.
Mozilla 1.2.1 is significantly faster, and the Typeahead features of it are a delight to use.
Pretty scary
Duncan and myself flew down to Washington DC to join the rally against the war in Iraq. I took plenty of pictures, some are available here.
The pictures had to be scaled down to 900x600 because the original files were too big to upload. If you want a particular picture in high resolution, mail me.
So compelled by Michael Moore's new movie I have decided to get myself a video camera and do a documentary about an interesting topic.
Very interesting read from CommonDreams:
http://www.commondreams.org/views02/1025-07.htm
http://www.zmag.org/content/showarticle.cfm?SectionID=22&ItemID=2524
An awesome report on how media reports: Now and Then
Sean Penn paid 56,000 dollars to publish a full page open letter to president Bush.
A beautiful talk by Arundhati Roy: transcription or Real Audio
Also make sure you listen to the follow up discussion with Howard Zinn.
Loving my new Peter Gabriel UP CD.
The Monty Python on bombing for peace
This is priceless.
There is a common error being spread among those who support the Israeli policies towards the invaded territories of Palestine: that the Israel administration is the only democracy in the middle east.
In fact, a quick look at the CIA Factbook shows that Lebanon, Egypt and Turkey are all republics. and Jordan is a constitutional monarchy.
But even if Israel were the only democracy has nothing to do with how the nation behaves. Its government repeatedly violates human rights of the Palestinian population. Of course, there are two ways of looking at the palestinian issue:
Either way it does not look very possitively on the Israeli administration: either they are violating UN regulations and international law, or they are guilty of crimes against humanity (obMeme: Ariel Sharon was found responsible for the massacres of Sabra and Shatila, he is a sanguinary man).
Reading this article it is clear that Israel is fighting a war against the Palestinian population. The United Nations should intevene, deploy forces and restore the peace.
Anyways, the point is that we need to distinguish democracy from justice. The fact that you have a democratic process does not ensure justice. The popular proverb sums it up nicely: `The US has the best democracy money can buy'. That and corruption.
Israel's prime minister is a war criminal, how is this man going to even vaguely give peace to this region? The man is a monster.
I grew up with the image of my country having a terrible problem of corruption (which it does) and a lack of justice (which it does) and having a lot of injustice between the powerful and the poor. But the more I learn about the rest of the world, the more petty Mexico's offenses seem. My country is just an amateur when it comes to high grade corruption.
Oh, something else. The term `anti-semitism' is miss-used all the time, semites are:
Semites are peoples who speak Semitic languages; the group includes Arabs, Aramaeans, Jews, and many Ethiopians. In a Biblical sense, Semites are peoples whose ancestry can be traced back to Shem, Noah's eldest son. The ancient Semitic populations were pastoral Nomads who several centuries before the Christian Era were migrating in large numbers from Arabia to Mesopotamia, the coasts of the Mediterranean Sea, and the Nile River delta. Jews and other Semites settled in villages in Judea, southern Palestine.Present day speakers of Semitic languages are as diverse in physical, psychological, cultural, and sociological characteristics as are speakers of Indo European languages. The most prominent Semites today are Arabs and Jews. They are different in many ways, and they have absorbed a variety of European traits through centuries of migration and trade. The origin of Semitic languages, however, and many similarities in the stories of Islam and Judaism reflect a common ancient history.
So the term anti-semitism is being misused to mean `people who hate the jews' and by some clever propaganda extension to mean `people who dislike the Israel administration policies' .
Racially, those Palestinians that the Israel administration is happilly disposing of their flesh are just as semitic as those pulling the trigger.
Found these trading cards. Pinochet's card is interesting, and contains the following quote: "Democracy is the breeding ground of communism,".
The Church Report from the Freedom of Information Act contains all the fun details!
Richard Cumming's interesting background
Introducing the Chicken Hawks!
Legalized corruption by the Record Labels
Anyone who considers a pre-emptive strike policy, should be pre-emptively be put in a mental institution.
For some interesting history, look at Pilgers's new article. Pay special attention to the politician's speeches. This was scary.
This weekend, am going to Washington DC for the `Stop the War on Iraq Before it Starts' demostration.
Pictures from Iraq from the Voices in the Wilderness gallery: First, second, thid and children drawings
Today I found the Iraq Peace Team web site.
If you use Mono, or are interested in Mono, please fill the following Survey to help us plot its future.
Evolution got a great review on PC Magazine.
Pilger's Documentary available as a web page. It was broadcast yesterday in the UK on ITV.
Wish this got some coverage outside the UK though.
Salon is running an article on the War on Drugs and Jeb Bush regarding the different treatments that his daughter gets, and what other ten thousand drug offenders get.
See the movie trailer for Occupation 101.
New Fisk:
So a few thoughts for the coming weeks: remember the days when
Saddam was America's friend; remember that Arabs committed the crimes against
humanity of 11 September last year and that they came from a place called the
Middle East, a place of injustice and occupation and torture; remember
"Palestine"; remember that, a year ago, no one spoke of Iraq, only of
al-Qa'ida and Osama bin Laden. And, I suppose, remember that "evil" is a good
crowd-puller but a mighty hard enemy to shoot down with a missile.
I found this history of the Iran-Iraq war very enlightening about the real reasons behind a war against Iraq. I will summarize it for you: US control over the oil in the Middle East.
The control is not required because a need on the Middle East oil, but because Japan and Europe are highly dependent on it. You want *your* companies profiting from that oil, and not someone else.
It also explains why Britain wants to get some piece of the action. In fact, they have always wanted to get a piece of the action.
My University acquired the rights to the photographies from the 1968 student movement in Mexico and released the digitized pictures to the government. They will be making the material available on line.
Edward Herman does --of course-- a much better job than I do at showing all the international laws violated by Israel on his Israel Approved Ethnic Cleansing article.
Direct from Indymedia. More civilians being shot.
So all my pictures for the best part of the day turned greenish. A phenomenon that can only be explained by the multitude of settings that the camera has, compounded with my random knob moving.
By the end of the day, I had figured a few things, but now everything is turning out red. The automatic mode in the D60 is not as simple as the one in the S40, not to mention that there is no way to get flash-less automatic.
Nelson Mandela warned Bush and Blair about war against Iraq.
Chomsky's Drain the Swap and there will be no more mosquitos.
Today the Boston Film Festival showed Das Experiment. The movie was very intense and disturbing. Intense as very few movies I have seen in my life, indeed, it is hard to tell when was the last time I got so scared.
Anyways, we learned while leaving the movie (from a German girl that had seen the movie before) that they had removed from the end the subtitles that said `The events of this movie aren based on the Stanford Prison Experiment.'
It is even more scary that this actually took place.
I feel uneasy reading the experiment description from the professor, because to him it was only an experiment. The only place where he redeems himself a bit is where he ponders a number of questions at the end about the prison system.
From this site, I ran into the Peace Psychology papers, I have not checked them all yet, but there are some interesting bits.
Anyways, the movie stresses one interesting part based on the research from the Stanford Experiment: people in a position of power are bound to break the rules, and seem to enjoyed it.
This makes the need for strong rules where human rights can be violated not only extremely important, but they have to be carefully monitored.
Just found a reviewat FilmCritic.
Today I met a very nice photographer called Rick Friedman who was carrying a Canon D60. I was shocked to see someone carrying that camera, as it is just about impossible to get your hands on that, I have tried, and I have looked every web site on the Internet, and that camera is just unavailable.
Well, Rick was nice enough to actually call a friend of his in the area that actually carries the camera and was able to give us one. So today after work, Peter and I went to check out Zeff Phot