Monday, 12 March 2007

The Singleton pattern represents a very common way of using lazy initialization with resources. Textbooks usually describe the Singleton as follows:

public class SingletonClass
{
  private static SingletonClass instance;
  public static SingletonClass Instance
  {
    get {
      if (instance == null)
      {
        instance = new SingletonClass(…);
        // do some initialization logic
      }
      return instance;
    }
  }
...
}

However, as any developer quickly realizes - implementing it in this way in a multi-threaded scenario is highly error-prone: if two threads attempt to access Instance at the same time (when it hasn't been created yet), both may run inside the if block and one of the threads will override the instance created by the other. As we tried to defend ourselves against this scenario, we changed the implementation as follows:

Monday, 12 March 2007 17:57:28 (W. Europe Standard Time, UTC+01:00)  #    Disclaimer  |  Comments [3]  | 
Let’s be honest about it: getting to know Genome is a non-trivial undertaking. It may seem downright daunting. I want to share with you some of the things I did, hoping that someone might benefit from my experiences.
Monday, 12 March 2007 12:02:26 (W. Europe Standard Time, UTC+01:00)  #    Disclaimer  |  Comments [0]  | 
 Monday, 26 February 2007

In my previous post I was discussing about how to mock test data for persistent objects mapped with Genome. Now I want to discuss how to provide this sample data in Blend so the designer building a front end with WPF actually sees how the UI would look like with data.

Genome | WPF
Monday, 26 February 2007 15:29:32 (W. Europe Standard Time, UTC+01:00)  #    Disclaimer  |  Comments [0]  | 
 Saturday, 24 February 2007

We’ve been working on a little research project recently with WPF and created a small (and hopefully handy) application where you can list your contacts synchronized from Microsoft CRM. We store the offline data in a SQL 2005 Compact Edition database and we access the data using Genome.

To make the experiment more exciting we involved a designer in the project, not only to design a cool UI using the features of WPF, but mainly to see how the collaboration between designer and developer works in reality.

Genome | WPF
Saturday, 24 February 2007 15:15:35 (W. Europe Standard Time, UTC+01:00)  #    Disclaimer  |  Comments [0]  | 
 Tuesday, 20 February 2007

Yesterday we were releasing Genome 3.1. After making quite a big step from Genome 2.6 to 3.0 last November, I thought the 3.1 release would allow us to take a breath, do some polishing on the code and finish some of the stuff that just didn’t make it into 3.0.

How wrong I was.

The length of the What’s New for Genome 3.1 will easily tell you that this is not a minor upgrade. Some major improvements have been put into this release, so it is definitely worth upgrading to as soon as possible to 3.1 for everyone working with Genome.

Tuesday, 20 February 2007 17:03:07 (W. Europe Standard Time, UTC+01:00)  #    Disclaimer  |  Comments [0]  | 
 Monday, 29 January 2007

I started working at TechTalk two weeks ago and one of my first tasks was – naturally – to get to know Genome. So I browsed through the tutorials and the quickstarts, and I watched the videos. Those gave me a general understanding of how to work with Genome. To get a real feel for it, I converted the data access layer of one of my pet projects to Genome. I know this pet project inside out, and it contains a couple of queries that are a bit more complex than your basis quickstart query. I felt that this was a good way to learn the details of Genome: take a project with a classic DAL that I know very well, and convert it to Genome while keeping all other aspects of the project. I struggled at first, but after a couple of days I came to grips with Genome and its query language and after that it went like a breeze.

What I like most about Genome is Query Decomposition. Suppose we have a Document entity and a Category entity. A Document can be assigned ("tagged") multiple categories, and there are many documents in each category - a classic m:p relation. In the dark ages of manual sql code, I'd have to write a stored procedure that gets all documents from the last 30 days. I'd have to write another stored procedure to get all documents in a certain category from the past 6 months. Thanks to genome, I have two select methods on my Document class for these scenarios. The first gets a set of documents from a specific time interval. The second gets a set of documents from a specific time interval that belong to a specific category. Using query composition, I can refactor these methods so that the second method calls the first method and does some more filtering on the result of the first method. Each idea is expressed only once in code. Genome takes care of executing just a single sql statement, even though I'm really calling two methods in my programming code. This is imo the real killer feature of Genome.

Posted by Dirk.

Monday, 29 January 2007 14:00:59 (W. Europe Standard Time, UTC+01:00)  #    Disclaimer  |  Comments [0]  | 
 Friday, 05 January 2007

In the recent months there has been a lot of confusion in the community about what LINQ is and what it is not. If you discuss this topic with others and read through the blogs you will find a lot of different perspectives and opinions on LINQ.

Most of the questions and misconceptions about LINQ I have encountered are about mixing up LINQ with an O/RM system and not understanding the impact of LINQ to .NET based O/RMs.

This is a brief summary about LINQ and how it relates to O/RMs, using Genome as a concrete example.

Genome | Linq
Friday, 05 January 2007 18:55:23 (W. Europe Standard Time, UTC+01:00)  #    Disclaimer  |  Comments [0]  | 
 Monday, 16 October 2006

Genome will be at this year's European TechEd in Barcelona, as you may have already seen announced on our website. Joy and jubilation, I'm going along too! Now is the time to disprove two persistent rumours (the first at least seems to persist almost as automatically as classes do in Genome).

Rumour 1: Techies are rooted to their PCs. Techies are reputed to be shy, antisocial creatures who prefer to spend their days holed up in computer labs in the sickly blue light of their monitors. I therefore expect the less heliophobic among you to come to sunny (there's hope) Barcelona in droves and gravitate towards the Genome stand at TechEd.

Rumour 2: Users aren't real. The anonymous masses of software users out there don't really exist. It's all an elaborate scam, complete with erratic e-mail responses, for some unknown esoteric purpose (I've always loved a good conspiracy). Most of you who've downloaded any version of Genome in the past year will know that I send a little welcome e-mail (btw - I've wanted to say this for some time now: they're not auto-generated). That means I've been in touch with thousands of you, but I have yet to come across concrete evidence that you are real people out there. I have lots of e-mails to go by, but I want to see living human faces that I can pin to all those names. The leap of faith concept just doesn't work for me, so do drop by the Genome stand. My vocal chords are atrophying and I've developed phantom keyboard syndrome when I'm not at my PC.

Some of the other members of the Genome team will also be at TechEd. We'd be pleased if you want to take the opportunity to discuss Genome in person. You'll find the Genome stand just opposite the exhibition help desk. Hope to see you there!

I think I'll have to retreat into the server room. It's far too sunny out here...

Monday, 16 October 2006 15:09:52 (W. Europe Daylight Time, UTC+02:00)  #    Disclaimer  |  Comments [1]  | 
 Wednesday, 31 May 2006

When I first saw Matt's blog entry, I thought this guy has gone crazy. They have just released the new CTP of LINQ, which should have been a source of great stress for him, whatever. He has gone crazy for sure. Shit happens.

Unfortunately I’m not the kind who writes yippees and hurrahs, but believe me, now I feel exactly the same as Matt - whoopee! And I also know the ticket to getting into this state: LINQ.

I have to keep my text short (huhuuu), so just look at this:

Wednesday, 31 May 2006 18:40:43 (W. Europe Daylight Time, UTC+02:00)  #    Disclaimer  |  Comments [5]  | 
 Friday, 14 April 2006

On April 12th I presented Genome at Persistence Day in Karlsruhe, Germany which was organised by dotnetpro, a German .NET development publication. Persistence Day is quite interesting, as it is a full day event concentrating solely on two topics:

  • Object-relational mapping for .NET
  • Object-oriented databases for .NET

While the latter is more of a niche in today’s enterprise development market (still, quite an interesting one), there is a huge demand for object-relational access for the .NET platform. The event hosted nearly 200 people and was booked out quickly. The fact that a one-day event with a 99€ price tag that attracts only a regional audience (no one would travel further than a few hundred kilometres for it) was so rapidly booked out (and would have been so even if the event had been planned for 500 people, according to the organiser) amply demonstrates that the .NET developer community is starving for solutions to this problem.

Still, O/RM is an exotic thing on the .NET platform, while it is widely accepted in the Java world. When I attended a software architect workshop in Cortina this February with a group of Java and .NET architects, the Java people just yawned when O/RM topics were proposed for discussion. So how can it be that this topic is widespread on other development platforms but so underdeveloped in .NET?

I see two main reasons for that:

First of all, Microsoft contributes a lot to this situation. They announced Object Spaces twice (PDC 2001, PDC 2003) but never released it. Except at PDC (and on some rare occasions at TechEd), you will never hear about O/RM from Microsoft. It's very funny to read through Microsoft’s current Patterns & Practices chapter on “Designing Data Tier Components and Passing Data Through Tiers” without encountering the word “object-relational mapping” once. I understand that Microsoft does not endorse any specific products, but concealing an entire product category shows Microsoft's attitude to this topic quite well.

Another reason is the .NET development community itself. With few exceptions, many people are advocating against the use of O/RM. They already spoke against it some years ago and they still do. I don’t want to dispute their arguments here, but looking at the number of comments those people receive on their O/RM related posts clearly tells me what an important topic O/RM is for the .NET community after all.

Posted by Chris

Friday, 14 April 2006 15:34:02 (W. Europe Daylight Time, UTC+02:00)  #    Disclaimer  |  Comments [2]  |