[svn]After some discussion about the WebComposition/DGS configuration this week, we changed the usage of schema validation with the Web.config file. The validation scope is now not bound anymore to data adapters directly. Rather we introduced a default validation defined in the Web.config such as

   <webComposition>
        <dataGridService>
            <defaultValidation scope="None"/>
         ...    

Valid values are 'None', 'List' and 'Element'.This schema scope represents the default schema validation scope whenever an information store is created and data is added. If set to 'None' no validation is performed at all. Using 'Element' the added XML is validated against the schema (a-priori validation) before the element is added to the information store while  the usage of 'List' causes the data to be validated against the schema after being added to the information store (a posteriori validation).

The settings can be easily overwritten by using RDF meta data e.g. when using the N3 filter on a information store http://www.foo.bar/myStore:

<http://www.foo.bar/myStore>
http://www.webcomposition.net/2008/02/dgs/meta/validation
"Element".

That way, the default value can be always adapted to the specific need for a single information store.

How stupid I was: while dealing with licenses for years, Dirk Riehle finally gave me a reality check. In an interview with Software Engineering Radio he told about his recent work at SAP and his experience and research with open source business models. Exaggerating I say: GPL is great, because GPL is the most capitalistic license you can think of.

As Dirk explained in the podcast the whole dual licensing model is build up on GPL. You sell your product but you also want to be pseudo open source. Then you open source using the GPL. All your competitors can read your code, extend the code, but then have to release everything under the GPL again. So there is no no benefit for your competitor. If customer's or competitors want to extend your code they have to purchase the second license you have.

Personally, I prefer either closed source or quite permissive licenses (FreeBSD, MsPL etc). If yo are going to give your code away, do it right. If you want to build a business on your code base - keep it closed. So I always was quite careful about not reading GPL code or even worse, copying code snippets into your code base that might be under GPL.

Since yesterday however, I really have a different view on the whole topic: If you are open sourcing  a commercial open source project and you perform dual licensing, GPL is used as a pure instrument for your business methods. If you open source  a community project under GPL you probably have not understood the concepts at all.

Also interesting in this podcast was the facts about shifting revenues. So, licensing is a tool used for shifting revenues among various business areas. If you are selling a database you are probably interested, that all operating systems are free of charge, so the customer has more money left to pay your product and your service. If you are some company similar to SAP, you are probably interested in all operating systems and databases are being for free: Consequently, the customer has more money left to spend on your product and services. If you selling your operating system you are for sure interested in having all programs running on top of your system are for free. That way, the customer has more money left to spend on your operating system and the services.

The next time you read about some company switching from Windows to Linux the question is not about saving money on licenses. At the end, I personally don't thing that the corresponding IT budget will be cut down due to the saved licensing fees. I rather think the budget is shifted to some other area.

I just realized I was focused on the GPL from the view of a developer for too long. If you feel the same, I highly recommend the interview with Dirk.

[svn] Another major forward integration of the student branch of the WebComposition/DGS: With revision 1228, CRUD events are supported on service level. I.e. each create, read, update or delete operation on the service (or it's lists) is stored within the meta data of the service. The vocabulary supported for the CRUD events is therefore defined as follows:

• http://www.webcomposition.net/2008/02/dgs/crud#create for create events.
• http://www.webcomposition.net/2008/02/dgs/crud#read for read events.
• http://www.webcomposition.net/2008/02/dgs/crud#update for update events.
• http://www.webcomposition.net/2008/02/dgs/crud#delete for delete events.

Exemplary meta data fore creating, updating, reading from and deleting an information store on a service running at 'http://localhost/dgs' would look like

<?xml version="1.0"?>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
        xmlns:dc="http://purl.org/dc/elements/1.1/"
        xmlns:dm="http://www.webcomposition.net/2008/02/dgs/meta/"
        xmlns:crud="http://www.webcomposition.net/2008/02/dgs/crud">
    <rdf:Description rdf:about="http://localhost/dgs">
        <crud:create rdf:resource="http://localhost/dgs/store" />
        <crud:update rdf:resource="http://localhost/dgs/store" />
        <crud:read rdf:resource="http://localhost/dgs/store" />
        <crud:delete rdf:resource="http://localhost/dgs/store" />
    </rdf:Description>
    ...
</rdf:RDF>

The CRUD event meta data can be obtained as by the /meta URL of the corresponding service.

After upgrading to the Windows Search 4.0 Preview I was quite happy about the new "index now" and "pause" functionality, finally provided by the preview. Brandon Paddock now came along with the missing tool to control the indexer.

Download, install and run. Works perfectly. No more locking down my system due to SearchIndexer.exe. 

Download Link: http://brandontools.com/files/folders/sidebar_gadgets/entry511.aspx

I still wonder why I can't use the switch-statement on typeof in C#?! Finally, I found Peter Hallam answering to this. Irrespectively his arguments, it works for the try-catch-finally statement quite well. So why not for switch?! 

Yibo Hui (徐艺波) blogged about having al look at my (foreign) desk. Quite interesting where your blog entries end up, though. 

Looking around for some cross-post plug-in for a while, I came along this plug-in for Windows Live Writer. Nice idea, but it actually does not load in WLW.

Right now, it is the only plug-in I found so far. I filed the bug and now I am waiting for any response. If nothing happens I have to have a look myself. Thanks for putting it under Ms-PL. If anybody get this plug-in working, let me know.

[svn]Today, I got the first feedback by some of the students about the WebComposition/DGS. Beside the typical start-with-a-new-technology issues considering Visual Studio 2008, ASP.NET and WCF, it looks like the first steps are done successfully. Based on the feedback I received during the day I did several fixes beside the regular enhancements. This evening, I performed a forward integration to incorporate the latest fixes. If you are using the Student Branch, please make sure to  update to revision 1211. 

Changes for today include:

• updated XML documentation of WebComposition.Dgs.Content namespace
• added notes about AppData/Service folder to DemoWeb
• added tests for meta data on service and information store level
• fixed '400 Bad Request' when no write access to AppData folder is given
• fixed SemWeb.dll reference in Content project, now expected to be in /External

[svn]I spend the weekend it setting up the VSR's distributed version control system. From this morning on, the student branch is fully sync'ed and ready to be compiled. Make sure to read the readme.txt in the root directory of the project and copy the SemWeb.dll into your External directory before the first compile run.

This post will give some insight into the distributed version control ad the Distributed and Self-organizing Systems Group. Usually, I am keen about trying out new things, e.g. distributed version control systems such as GIT, Mercurial or Bazaar. However, currently the group's infrastructure is set up with Subversion as internal revision control system.

For the next few months we will start an evaluation phase with the students, working on the WebComposition/DGS approach, based on a distributed version control concept. Core components of the WebComposition project are branched into a dedicated student branch where all students can commit changes. Based on this branch each student creates his or her private branch for local changes.

The coordinator (usually some DSS staff) takes care of regular forward integration of the core components into the student branch. Each student in turn is responsible for forward integration into his or her own branch.

Changes can be submitted after testing and evaluation back into the central student branch by each student performing backward integration. The group working on the project has to agree in the LAKS meeting on the change before backward integrating the updates.

The coordinator finally takes care if these changes are also backward integrated into the original project trunk.

Step 1: Create a local working copy

First, look for a place where to checkout the working copy. Create a folder, e.g. branches\students and use Tortoise to checkout a working copy.

Select the student branch and the local folder where to store the working copy to start the checkout.

After the checkout is finished, you should will have a local working copy of the student branch.

Step 2. Create a private branch

Select 'Branch/tag' from the context menu of your working copy.

Use the path of your private project within the repository to create the branch.

Step 3: Forward integrate changes from the student branch

When the student branch was updated you might be interested in getting these updates into your private branch. To forward integrate these changes into your private branch, select the folder where your local working copy lives, and use the Tortoise context menu to select 'Merge...'.

Select the repository folder you want to forward integrate Probably this will be the student branch - the paths in the screenshot below will thus differ from yours. Select the revision from where the forward integration should start. Now select the revision where it should end. Usually, this will be the head revision. After merging submit the changes of your working copy to the repository and you are done.

To get some more information on Subversion, or to learn how to perform the steps above on command line, refer the Subversion book.