replicator.org ... we need to fix it all.

While writing a .NET based wizard engine I thought it would be fine to use an IoC container.

The concepts behind are pretty simple: Instead of simply creating an instance of a class, an IoC lets you specify explicit requirements in the form of interfaces (services) that are injected into a object instance before use. These services need to be registered to be available at the time of the instantiation.

Databases don’t store collections, they store tables. If some data needs to be stored as a list, it needs to be normalized. Usually meaning that a new table is required. For example: to get the collection of a 1:n relationship, an SQL query is processed to select a subset of that table.

Projected to object orientation, a table is a collection of all instances of the same class.

Why this matters? Because a collection is a concept that is not easily implementable in self-adjusting computation.

Following Conway’s law:

Organizations which design systems are constrained to produce designs which are copies of the communication structures of these organizations.

We are starting to get more serious about making programming more like the world actually seems to work.

A simple and effective solution to get over the null-pointer tragedy invented by Tony Hoare is to capture the type system deficiency by convention.

I am starting to collect a number of C# hacks. I hope you’ll find them inspiring. They can be reached from the Browse section on the left.

I will keep you posted when new pages are published. You are welcome to comment on the hacks.

While Oslo may bring us graphical, model and data driven development to the Microsoft Development Platform, the tools and underlying technologies offer interesting textual capabilities. For me, MGrammar actually seems to be the highlight in the Oslo toolset.

I’ve always suffered from getting lost in code that is heavily distributed in object oriented systems. Providing context along with method parameters and calling interfaces from deep within algorithms makes me feel detached from the specific problem I am solving.

Coroutines are nice if your language supports them.

C#4.0 is starting to get in shape: Here is a list of the new features and some examples. Pretty cool stuff, finally we get optional arguments and support for dynamic objects.

Microsoft released Azure, an Internet Cloud Operating System. Now you can run your .NET applications on their data centers. There are already some introductionary videos on Channel9.

I wonder why they did not named it Sky.NET (Sky == Azure?).

I’ve collected a number of technologies and put a component matrix together. This list contains the components I am working at right now and their status.

yours
armin