Ernst Kuschke

An open source implementation of AJAX for .NET here.

Serializes .NET objects on your server and marshals them back to the browser for consumption client side. Allows you to call methods on your server directly from javascript. Cool.

Have you ever worked with the CAB file format? The CAB (short for cabinet) file format is Microsoft's preferred compression format. It is similar to the ZIP format, but more efficient in that it does not compress files one by one, but as one big clunk of data - file boundaries thus overlap, resulting in a smaller compressed file. The compression algorythm is *completely unavailable*.

I recently had the *simple* requirement to extract a cab file into a memorystream. The first thing I did was to make an API call, but I realised that this call can only extract to a file on disk, and I could not touch a disk due to rights. So the API call was out of the question. No problem - there's a CAB SDK. I downloaded it, and surprisingly found the same limitation. Quoting from the readme:

“Microsoft is committed to making cabinet files an open technology.” - March 20, 1997

That sure as heck didn't happen. The SDK is completely unmanaged, and does not even contain COM components. To utilise, it will be necessary to write an unmanaged C++ utility that calls into the libraries shipped with the SDK. Great.

Did I miss something? Please tell me there's a better way.

It's just a preview, but sounds very promising! It seems to be an object-to-relational (OR) mapper library, configurable via XML and features caching, transactions, and more.

From the site: “The Data Mapper is a layer of software that separates the in-memory objects from the database. Its responsibility is to transfer data between the two ends to isolate them from each other. With Data Mapper the in-memory objects needn’t know even that there’s a database present; they need no SQL interface code, and certainly no knowledge of the database schema."

The slides for the presentations held at DevDays 2005 are up and can be downloaded over here.

I found the Tools for Architecture – Designing for Deployment and Development and Testing Tools *talks* quite informative.

I came back from a long overdue trip to Brazil last weekend, and the two weeks I spent there were amazing. Some photos of the trip are posted up here. I recommend going to Brazil to everyone - it is one of the most beautiful, cheap destinations in the world. In Brazil no one speaks English, and an understanding of Portuguese will be very helpful.

I landed in Sao Paulo, a city with a population of almost 18 million people, and by far the craziest place I have ever experienced. If you want to feel MUCH better about the way people drive in Johannesburg, visit Sao Paulo....! We travelled by car, which I think is a great way to experience a country. We went to the coastline of Sao Paulo, and over the next two weeks we gradually made our way up along the coastline, which is absolutely gorgeous with thousands of little islands everywhere, to Rio de Janeiro. Ilha Grande is an island we stayed on for a few days, but unfortunately we couldn't enjoy all it had to offer since I suffered from some diarroeha at this stage...(!) I would have to go back soon and experience everything I missed. One thing I was a little bit disappointed in was the fact that we couldn't surf any waves - in two weeks there I did not even see one surfable wave!! Next time...

If there is anywhere I'd recommend in the tiny piece of Brazil we covered, it would be Paraty, Ilha Grande and of course Rio de Janeiro.

Yes, I've been trolled by Justin's ongoing discussion of the matter.

Let's discuss his “Person” example. Assume I have a Person class, and I have a library called PersonPersistor that has a method: void Save(Person).

I will now need to recreate a “persistor”-type library for each and every class this way, where if your Person object implemented an interface called something like IPersistable, i could write one library called Persist with a method: void Save(IPersistable).

Now i can create an Address class that implements IPersistable, a PersonDetails class that implements IPersistable, and I never have to rewrite my Persist library. (Person wouldn't implement IAddress, it would rather have an Address property of type PersonAddress, which might also implement IPersistable, etc. etc...)

An alternative would be to let Person, Address, etc. inherit from a base class called Persistable, and change the method on the Persist library to: void Save(Persistable). The main deciding factor between using the base class or the interface would be where you want your implementation to lie. Do you want the Persistable bahavior to be the same for all classes? If so, implement in a base class. If not, use the interface and implement the behavior in each and every class.