ADO.NET Data Services is Microsoft’s new services framework for accessing data from remote clients using HTTP and other disconnected protocols by sending either LINQ or URI’s queries to a specialized DataService<T>. DataService<T> is connected to the underlying data source and can perform read, update, delete and create operations against any data framework with a sufficient data context implementation, for example LINQ-to-SQL or the ADO.NET Entity Framework.

While it is possible to create components that intercept the data operations at the service level, ADO.NET Data Services has been specifically designed to support CRUD operations performed by remote clients. That means, for the time being, there is no support for accessing and invoking business logic components over DataService<T> or for returning custom response messages based on data structures that are not managed by the underlying data context. That in turn means that business logic has to reside on the client (maybe even written in JavaScript) and can easily be manipulated. It also means that arbitrary clients can run all operations against every exposed interfaces of DataService<T> (which is a matter of configuration).

WCF and the DataTransferObjectManager on the other hand allow you to selectively open your API to external clients and provide a consistent interface for business operations beyond create, read, update and delete scenarios, regardless of the underlying data structures and without any affiliation to a specific data framework. They also allow you to invoke service operations that access repositories and business logic components while still returning only the necessary parts of large object graphs to the client.

ADO.NET Data Services (and the upcoming .NET RIA Services) are great frameworks with a lot of potential value, but for the time being they do not solve the problem of accessing any kind of API call through service operations without having to worry about large and deeply interconnected object graphs. This is where DTOM and the ServiceToolkit.NET step in, which we will release in a couple of days on CodePlex.

In a previous post we took a look at an early preview version of the DataTransferObjectManager, a library we developed at netzkern to integrate WCF with O/RM tools. Today we will take a look at how nk.DTOM solves the problem of mapping updates from clients to entity objects. Here is how to do this:

// This object represents an update request from an external client.
HouseDTO updateHouseParam = new HouseDTO();
updateHouseParam.ID = “6”;
updateHouseParam.Name = “176 Wallstreet”;
updateHouseParam.Price = “10 Million Dollar”;

// Read the corresponding entity from the data source.
House houseEntity = houseRepository.GetHouse(updateHouseParam.ID);

// Map the properties of the DTO to the entity.
DataTransferObjectManager.Map(updateHouseParam, houseEntity);

// Update the data source.
houseRepository.Save(houseEntity);

Pretty straight forward, right? Remember, by default nk.DTOM only maps value type properties from the source object to the destination object, and that’s exactly what we need here.

Now, let’s consider our entity “houseEntity” contains a property that should be readonly for external clients. In our case, the price of our house is fix and we don’t want it to be changed. In this case, we use the support for selective updates in nk.DTOM. The “Map”-Method contains a fourth parameter that allows us to specify certain properties that we want to preserve in the destination object.

// Create an empty PropertyPathCollection as third parameter, as we do not want to include any references.
PropertyPathCollection includeSourceReferenceProperties = new PropertyPathCollection();

// Create a PropertyPathCollection containing all the PropertyPaths we want nk.DTOM to skip during the mapping, which means preserving the original value.
PropertyPathCollection skipDestinationProperties = new PropertyPathCollection();
skipDestinationProperties.Add(“Price”);

// Call Map() with all four parameters.
DataTransferObjectManager.Map(updateHouseParam, houseEntity, includeSourceReferenceProperties, skipDestinationProperties);

By combining the third and the fourth parameter, nk.DTOM even enables us to update certain values of complete graphs of entity objects. We just need to preserve the original reference to the entity object and maybe some other properties. Take a look:

// Update a referenced DTO on the client-side.
updateHouseParam.Owner.Name = “Some new guy”;

// Create a PropertyPathCollection on the server-side that allows the client to update the referenced entity “Person” in the property “Owner” as well.
PropertyPathCollection includeSourceReferenceProperties = new PropertyPathCollection();
includeSourceReferenceProperties.Add(“Owner”);

// Create a PropertyPathCollection containing all the PropertyPaths we want nk.DTOM to skip, in this case especially the property “Owner” (as the client is not allowed to change the Owner itself and we don’t want nk.DTOM to initialize the property with a new instance) the Owner’s ID.
PropertyPathCollection skipDestinationProperties = new PropertyPathCollection();
skipDestinationProperties.Add(“Price”);
skipDestinationProperties.Add(“Owner.ID”);

// Call Map().
DataTransferObjectManager.Map(updateHouseParam, houseEntity, includeSourceReferenceProperties, skipDestinationProperties);

The service developer can even decide which properties can be changed based on the identity of the caller, for example by relying on WCF authentication features.

We’re currently planning to release netzkern.DataTransferObjectManager as part of a small toolkit on CodePlex. We hope, you’re going to use and like it.

I love reading books. Usually that means one, sometimes two or three books per week. In the last four years I extended my personal library to several self-development and management books and I have to say, I’m glad that I read most of them. Below you can find my personal top ten list in those two categories:

Getting Things Done
The 7 Habits of Highly Effective People
Brain Rules
Slowing Down to the Speed of Life
How To Be Brilliant
Behind Closed Doors
Good to Great
Speed Reading for Professionals
First Things First
Mind Performance Hacks

Additionally I own several other books that I haven’t read yet but that might make it to this list, maybe even replacing one or two of the ones listed above. Here are those I’m eager to read:

Think And Grow Rich
How To Win Friends And Influence Others
Your Money or Your Life
The Power Of Less

For a complete list of all my books, please visit my website at www.juliusganns.com.

(Version 1.1 – March 20th, 2009)

Developing with today’s platforms, a developer can utilize great tools and libraries to increase development speed and software quality. Two very common in the .NET space are WCF and LINQ to SQL, besides various other O/RM tools like NHibernate and the ADO.NET Entity Framework.

Unfortunately, using a messaging framework like WCF that has to perform quite a lot serialization work in combination with a tool to automatically retrieve data from data sources and create deeply nested object graphs like LINQ to SQL creates some pretty hard challenges. The reason for this is that WCF has to transform the graph into a “flat” message representation. If the graph contains cyclic references, WCF has two options to avoid running in circles (and kill your App) when it encounters an object it already has processed:

1. Abort the whole serialization. This is the default behavior and it is very reasonable to throw an exception here.
2. “Mark” that part of the message as “reference” to an earlier serialized part. This behavior can be introduced using your own WCF components (see the links at the bottom).

For service developers that want to use object-relational mapping tools to automate database queries, neither of one is really sufficient. Although the latter part may be an option in a strict .NET to .NET scenario, it does not implement any standard (because there is none) and thereby makes it nearly impossible for other platforms to use the serialized message with reasonable effort.

Even worse, in the Web 2.0 area more and more WCF services create JSON and XML output for client-side components like ASP.NET AJAX, JQuery, Silverlight and Flex. Therefore it is essential to provide client-side developers with all necessary information in a strctured way without the need to blow up the server side development.

Taking a look at the .NET framework, Microsoft currently does not offer any solution for this in its primary frameworks WCF and LINQ.

After re-designing and overworking our Reference Architecture over the last week, we finally managed to develop an approach here at netzkern to integrate both technologies with each other in a pragmatic and pretty “clean” way. We created a utility called the DataTransferObjectManager that is able to dynamically fill DTOs with the values and copies of all requested references. The trick here is that it does only selectively chooses the right references by letting the client-side developer provide a configuration parameter that indicates which properties he really needs to do his work. All other references are ignored and not returned to the client, they are usually not even loaded from the database.

Let’s have a look. First, we create two entity classes as part of our model. They don’t need to be public as they are never used outside of the core assembly.

namespace App.Core
{
    class House
    {
        public string Name { get; set; }
        public Person Owner { get; set; }
    }

    class Person
    {
        public string Name { get; set; }
        public House Residence { get; set; }
    }
}

Let’s pretend that instances of these classes are being tracked by an O/RM manager component that automatically detects changes and performs updates. Now, let’s create the corresponding DTO’s:

namespace App.DTO
{
    public class HouseDTO
    {
        public string Name { get; set; }
        public PersonDTO Owner { get; set; }
    }

    public class PersonDTO
    {
        public string Name { get; set; }
        public HouseDTO Residence { get; set; }
    }
}

These classes are basically message definitions. In WCF you would use these as DataContracts and annotate them with the appropriate attributes. Instances of these classes are somewhat “dumb”, they only contain data.

Now let’s consider, we have the following object graph:

House h1 = new House();
h1.Name = “House No. 1”;
Person p1 = new Person();
p1.Name = “Person A”;
h1.Owner = p1;
p1.Residence = h1;

This creates a graph with just two objects and a cyclic reference. When you try to serialize “h1” using WCF’s default DataContractSerializer, you get the above mentioned exception. Now let’s use the netzkern.DataTransferObjectManager (or nk.DTOM for short) and see what it can do for us:

// Create an empty base DTO.
HouseDTO h2 = new HouseDTO();

// Call the nk.DTOM and copy the contents of h1 to h2.
DataTransferObjectManager.CreateDataTransferObject(h1, h2);

What we get from this is the following “filled” DTO message object:
h2.Name: “House No. 1”;
h2.Owner: null;

So far we created a flat copy of “h1” with all references excluded. Now let’s include a copy of “h1.Owner” as part of “h2”:

// Create an empty base DTO.
HouseDTO h2 = new HouseDTO();

// Tell the nk.DTOM to include the following properties.
PropertyPathCollection includePaths = new PropertyPathCollection();
includePaths.Add(“Owner”);

// Call the nk.DTOM and copy the contents of h1 to h2.
DataTransferObjectManager.CreateDataTransferObject(h1, h2, includePaths);

The result now includes a copy of “p1” that has been mapped to a PersonDTO type:
h2.Name: “House No. 1”;
h2.Owner: [PersonDTO];
h2.Owner.Name: “Person A”;
h2.Owner.Residence: null;

We can now even include “deeper” properties, that are being copied equally by the nk.DTOM:

// Create an empty base DTO.
HouseDTO h2 = new HouseDTO();

// Tell the nk.DTOM to include the following properties.
PropertyPathCollection includePaths = new PropertyPathCollection();
includePaths.Add(“Owner.Residence”);

// Call the nk.DTOM and copy the contents of h1 to h2.
DataTransferObjectManager.CreateDataTransferObject(h1, h2, includePaths);

That creates the following result:
h2.Name: “House No. 1”;
h2.Owner: [PersonDTO];
h2.Owner.Name: “Person A”;
h2.Owner.Residence: [HouseDTO];
h2.Owner.Residence.Name: “House No. 1”;
h2.Owner.Residence.Owner: null;

So, how do we use this in WCF? After you have successfully loaded entities in your service operation using an O/RM, you just call the nk.DTOM and return the DataTransferObject as result. The trick is to let the client(!) choose which parts of your internal object graph are necessary to do its work. A simple service call might look like this:

IHouseService service = new HouseServiceClient();
HouseRequest req = new HouseRequest();
req.HouseID = houseID;
req.IncludeProperties = “Owner.Residence”;
HouseResponse resp = service.GetHouse(req);

That’s basically it. By using the netzkern.DataTransferObjectManager, you can define your data transfer objects independently of your internal entity objects. You can even omit certain properties and nk.DTOM will ignore them. We will now test this component internally and make it available on CodePlex as soon as it reaches BETA status. We also would love to hear your thoughts, just send a mail to blog@juliusganns.com.

Update
I’m currently writing an article for a leading German .NET magazine about the above mentioned topic. The article will contain more details about the architecture and more samples how to use the library. I will post an update here when it has been published in a couple of weeks.

Update
Microsoft has just announced the .NET RIA Services framework which also targets parts of the above mentioned problems, but solves them in a different way. As far as I understand the library, it may be possible to combine both approaches. When more bits and bytes come available, I will definitely try to integrate those with our framework.

I’ve read about 30 books about Time Management and Productivity over the last few years and there are a couple of things all the techniques in these books have in common. One of them is: Do one thing at a time. This is one of the main reasons why I stay disconnected most the time, and it is also the basic idea behind this post.

This post is about all the little applications and programs you can install on your notebooks and desktops as companion to various online services and websites. Although they come with a lot promises and large feature lists, I have a pretty strict opinion regarding all these little tools: If you can do it on the web, don’t use software.

Not only do they slow down your PC, they also distract you constantly from the one really important thing you should be doing right now. Using your browser to access those services gives you a lot of advantages, that may not be that obvious. Here are my top three reasons not to use desktop counterparts for web services:

1. You are in control of your time and you avoid distractions. The reason for this is pretty simple: If you need to access a website, it is totally up to you not to do so. So there is no chance for any of these services to make that decision for you. This means, you don’t get interrupted (or maybe even disturbed) by all these “tiny little helpers” hiding in your system tray (that is the area right next to your clock in the lower right corner on your desktop).
2. You focus on one thing at a time. As you probably use one browser window in fullscreen mode to access different websites and services, you are automatically focused on one tool at a time. This makes your work much more efficient and effective.
3. You don’t waste time for installing, configuring and maintaining an application that doesn’t work offline anyway, so why not accessing the native website instead? Just put a bookmark on your browser for fast access and enjoy the web.

This doesn’t mean that desktop versions of popular web services are inherently a bad thing. They’re not. But if you use them, you should consider the basic idea this post is based on: Do one thing at a time.

The following list contains the most important applications I use on my desktop although there are web-based counterparts: Windows Live Messenger (because there is no support for advanced features like File Sharing or Video Conferencing in web-based clients like Meebo), Skype (because there is no real web equivalent), EverNote and MindManager (because I need to be able to offline access my stuff and because of the great integration with other applications).

Finally, after 10 years of HTML 4.01, a W3C working group is going to publish a new HTML standard, hopefully cleaned up and bringing more "native" support for the Web Applications without the use of JavaScript for standard behavior (like editing, drag'n'drop and so on). The following Working Draft summarizes the differences between HTML 4.01 and HTML 5.0.

When I started reading Getting Things Done back in 2007, I would have never expected it to change the way I work that fundamentally. There are those things that immediately kick in and help you to structure your day like the Mastering Work Flow Model, but there is even more to GTD than that basic process. This post is about the things I learned in the last 1.5 years and that are easily forgotten.

When you start to implement GTD, especially if you're a techie like me, you will immediately create all these fancy lists, install all these feature-rich tools and register for every web 2.0 productivity application you can find. This "learning by playing around" is an important part of getting familiar with the methodology.
In the beginning, your new tools and your new process will definitely slow you down. And that's okay, because you have to find your way of doing things without violating the core GTD principles. Just remember yourself from time to time, why you're doing the whole thing. GTD is not your new hobby. It's not a new reason to procrastinate. And it's definitely not your new purpose of life.
You're implementing this productivity process to get more done with less thinking and with less effort. Don't stumble around and rework your GTD infrastructure every week by setting up new tools, creating more rules or cramming more fancy "appointments with myself" in your calendar. At some point you should be done with your system (at least for a certain amount of time) and return to the really important things.

Tip #1: Allow yourself to have fun with GTD. Cut yourself some slack and experience with your new process and your new tools. But make sure that you don't get lost in the fancy world of GTD tools and practices. Don't forget the reason you're doing all this stuff.

Playing around is also important because it helps you with another important thing: Do one step at a time. In the very beginning implementing GTD "to the fullest" seems to be the greatest thing on earth. Trust me, doing it all at once is not possible. Give yourself time to learn, to adjust and to integrate the principles into your life. GTD (and every other "habit") only sticks if it fits naturally in your day, without distracting or hindering your way of doing things.

Tip #2: Do one step at a time and keep it simple. GTD is a simple thing, but reading about it and implementing it is not the same. Give yourself the time to learn and don't overwhelm yourself.

Another common problem is the thing with the weekly review. I am aware of that because I had it myself. I put in on my calendar, I wrote reminders and I read numerous blogs about the importance of the review process, but I just never really did it. I talked to my friends who are also familiar with GTD, but their response was even more frustrating: No, I don't do it and I don't think it's really that important.

It was about that time I also discovered my enthusiasm for Steven Covey, especially The 7 Habits of Highly Effective People and First Things First. The latter one also contains great productivity and time management principles, but instead of starting at the profound organizing level, it helps you to get a new perspective of your life and focus on those things that are really important for you. One of these principles is "Plan Weekly - Adjust Daily". While reading that particular chapter, it suddenly hit me: Why do you always try to do your "Weekly Review" Friday afternoon? Why perform such an important control task when you are exhausted from the week, tired, looking forward to the weekend, hungry and already mentally out of the office?
So I decided to merge my "Weekly Review" with my "Weekly Planning" appointment, Monday Mornings at 10:00 AM. It worked great. I was able to review all the stuff I had and hadn't done in the last week with maximum energy and because of that, it usually didn't take longer than 10 minutes. It also helped me to plan my upcoming week more accurately by defining new projects and actions.

Driven by the success of my idea, I even decided to create a recurring breakfast meeting with all executives at netzkern before my personal Weekly Review and Planning session, every Monday at 9:15 AM. This so called Central Operations meeting still exists and it is a great establishment. So this brings us to our first tip...

Tip #3: Do the Weekly Review. It's not only important, it's critical for the successful implementation of GTD, especially in corporate environments. In the beginning, you may be able to manage a smaller amount of projects without it, but the earlier you start to review your stuff, the better. Set aside 15 to 30 minutes per week and make sure that you're neither tired nor have something "more important" to do at that moment. Use the Weekly Review to plan your upcoming week as well and start right away afterwards with the most important thing on your updated list, ideally one that helps you to conquer one of your "Big Rocks".

As I mentioned earlier, there is more to GTD than just the Mastering Work Flow Model. It is more than just projects and actions, although most people might perceive it that way. GTD also includes two higher level models that are easily forgotten, yet they are even much more powerful.

The first one is called the Natural Planning Model and is intended to help you with the management of all kind of projects. David often refers to projects as "everything that needs more than one action to complete". The problem with that sentence is that because of that statement, a lot of people tend to think of projects primarily as "containers" for actions. But in GTD, projects are much more than that, especially when they do not have a clear outcome or already defined next actions.

I will not repeat the Natural Planning Model here, but I want to make sure that everybody understands how important this part of GTD really is. Following its five step process, Purpose and Principles - Vision - Brainstorming - Organizing - Next Actions, is a great way to conquer your own thoughts and I do it every day.

Tip #4: Don't stop halfway between, there is much more to GTD than the Mastering Work Flow Model. Study and implement the Natural Planning Model and the Horizons of Focus Model for maximum effectiveness and efficiency in your day-to-day productivity work.

Alright, these are my most important tips so far. I could go on a while longer, but instead of just telling you about them, I find it more important that everyone experiences certain parts of the learning process himself. In the end, I really recommend that you read GTD at least twice and maybe revisit it every couple of years. It gets better every time...

Everyone knows, I’m a pretty “connected guy”. I have several Notebooks, Netbooks, PDA’s, my iPhone, my HTC smartphone and plenty of other gadgets that are usually constantly connected to the internet. There is practically no IM service and no community I’m not registered at. Although this perception is largely correct, several years ago I discovered that while these communication services can make your life a lot easier and they help you to stay in touch with your people, they are usually a real productivity killer and a constant distraction.

Let’s be honest, 95% of all IM conversations, community messages and even most of your emails fall in one of two categories: They are pretty meaningless, if not stupid -or- they contain important information that really can wait. But yet every single “connection attempt” pops up, “plings” and demands your immediate attention. That’s true for Outlook, Windows Live Messenger, ICQ and even your browser showing Google Talk or Facebook. Everything screams “here, here, read me” and implies “quick, write something back, it doesn’t matter what it is”. So most people just “take a short look” again and again and they wonder why they don’t get anything done…

So how should we deal with that? Although communication is a great thing, the first step is to disable everything… Yep, everything, just shut it off. Don’t let your IM applications connect to the internet automatically on windows startup, do not open Facebook first thing in the morning and leave it running in the back and don’t reply to every SMS right after it has been delivered to your phone. Turn off any annoying “you have new mail” notification on your desktop and for god’s sake, do not update constantly all twenty-something services with meaningless status messages like “Having fun with…”, "Just decided to..." and "Thinking about...". Trust me, nobody really cares, except those people that have the same addiction to those things you might currently experience.

The second step is to define a communication pattern that does not get in the way of your work and your life. The truth is, having all your communication service enabled all day long is like having 10 people in your office and being constantly interrupted because every 10 minutes someone asks you something. It is really the same.

My personal communication pattern is pretty strict. I have three regular times during the day on which I enable all my communication services: When I start my day at the office, right after lunch and when I leave the office. During those periods which usually last about 30 minutes, I open all “channels” to the world, check my email and chat a little with colleagues. I read through my SMS, reply to my friends and return calls. I update my twitter status, take a look at Facebook and check for new messages at studiVZ. After 30 minutes my timer interrupts me, I finish my conversations and disable all tools, sites and features completely.

Of course, this is my way and it’s only working pretty great for me. You have to find your own way, but I strongly encourage you to work more disconnected and don’t get trapped in unimportant, apparently urgent but surely mindless things. Turn off the noise in your life.

I followed the ASP.NET MVC development since it first appearance on the ALT.NET conference in the end of 2007 and as you can see from various posts, I'm a big fan of it (ASP.NET Web Development - some thoughts... -and- A Conceptual Alignment of Sitecore, ASP.NET WebForms, ASP.NET MVC and the Microsoft AJAX Client-side Library). From an architectural point of view as well as from a lead developer point of view, MVC is and has always been the best server-side pattern for web applications (and as long-standing Java EE and Rails developer I'm allowed to say that). In combination with event-driven GUI frameworks on the client side like ASP.NET AJAX, JQuery and Silverlight it should always be the first choice for every serious web developer in 2009. It is also an important building block of our Reference Application Architecture and Microsofts Application Architecture Guidance 2.0, especially in combination with WCF.

The question is now: When will Sitecore finally adopt ASP.NET MVC as supported framework? Clearly there is no doubt that the development model of ASP.NET MVC and Sitecore are even closer aligned than the development model of ASP.NET WebForms and Sitecore and that there are enormous synergistic effects by integrating both frameworks. This is true for various parts of the system, especially routing and rendering (where XSLT was - beside other reasons - chosen because "inline code" was a bad thing back than). I personally expect not only basic support for ASP.NET MVC but even a complete switch to use it as primary base framework instead of ASP.NET WebForms over the next couple of months, maybe a year.

(Version 2.0 - October 10th, 2009)

In this series, I'm going to compare the functionality of SharePoint and Sitecore from a developer perspective in each area and both candidates can collect "points" from 0 (has nothing to contribute) to 10 (great integration and functionality).

This series will cover the following areas:
- Introduction (Part 1)
- Installation and General Architecture (Part 2)
- Configuration (Part 3)
- Customization and Designer Experience (Part 4)
- Integration with Developer Tools (Part 5)
- Feature Deployment (Part 6)
- API und Data Model (Part 7)
- Integration with other systems (Part 8)
- Conclusion (Part 9)

Integration with Developer Tools

In the last part of this series I examined features and tools both framework offer in terms of customization and web designer support. This part of the series is diving deeper into the world of web development with SharePoint and Sitecore.

One of the main reason for an organization to invest in enterprise-class Content Management Systems is to build extended functionality on top of those frameworks. At netzkern we have several customers that made significant investments into their IT infrastructure to enable enterprise application and business process integration, especially using open standards like XML (SOAP, REST, POX). Because of that, extensibility and integration are critical parts of Content Management Systems today and both SharePoint and Sitecore have various integration features and extension points. The question is, however: How easy is it to use those features and interfaces as developer to plug in my own code? Do I need to change the way I'm used to work? And how does the system support me?

As SharePoint comes as part of Microsoft's server family, the tool to develop SharePoint functionality is of course Visual Studio. So, how do we get started? Well, as developer with some experience in the Microsoft space, you might expect the following procedure: Install SharePoint, install Visual Studio, download the appropriate SDK (in this case called "Visual Studio 2008 Extensions for Windows SharePoint Services, Version 1.3", or just VSeWSS for short), take a short look at some API samples, create or open an appropriate sample file, write three lines of code, hit "F5" and see your first shiny "Hello World". And since we're talking about version 1.3 of VSeWSS, that's finally the way it works.

While getting started with VSeWSS is pretty straight forward by now, manually deploying custom SharePoint solutions is surprisingly complex. But before we talk about that, there is one important thing to mention regarding SharePoint development in general. That is, to install either MOSS2007 or WSS 3.0, you need a Windows Server operating system. Although it is possible to use special third party tools to install WSS 3.0 on Windows Vista (see Bamboo Solutions), this way is not supported by Microsoft and may cause problems during development or after deployment to a "real" SharePoint installation. As developer you usually choose one of the following solutions: Install Windows Server on your workstation, use a virtual machine (VMware, Virtual PC, etc.) with Windows Server or use a central Windows Server with Remote Desktop for development. Although you can use Visual Studio on your WinXP for local development, you need to deploy your code on a server machine for execution and remote debugging (which, by the way, is not that straightforward in most scenarios).
The most important feature that VSeWSS brings to the table is finally the ability to hit F5 in your Visual Studio and see the results of your work right away. This alone is a huge advancement when compared to the way SharePoint development used to be. There are a lot of things, VSeWSS takes care of in the background. Let's take look at what happens:
As I briefly described earlier, the way to add functionality to SharePoint is by developing so called Features. Features can be deployed manually by copying all necessary files into the "12 hive" folder and executing a few commands on the command line -or- by using a so called Solution Package (a "WSP"). A Solution Package is basically a .CAB-File (Microsoft's ZIP format) with a specialized internal file structure, additional configuration files and a .WSP extension. Back in the old days you had to create that .CAB file by yourself, but today VSeWSS creates it for you and even allows you to inspect and change its contents live in Visual Studio. If you wanted to create the .CAB file manually (which you don't need to anymore), the first thing to do would be to create a DDF configuration file for the MakeCAB.exe command which would be used to create the .CAB archive (and later be renamed to .WSP). Then you would have to create the Solution Manifest (named manifest.xml), which contains information about all contents of the .WSP and directives about how to deploy the contained Features to a SharePoint farm. A Solution Package can contain several Features in separate folders and each of those Features needs to have a Feature Definition file (named feature.xml) and optionally additional files (Elements files for lists and list items, resource files, etc.).
But that's not the only thing, VSeWSS manages for you. It also takes care of adding your compiled code all additional resource files to the Solution Package, extends the configuration files appropriately, deploys and installs the package in your SharePoint farm and activates the Feature so that you can get your results very fast. In case you would like to know more about what happens under the covers (and you should, if you want to be a real SharePoint developer), I recommend reading the following articles on MSDN (part 01, part 02) and to take a look at the WROX SharePoint Box, which I highly recommend.
While it has been quite painful and complex to deploy custom code using the Solution Framework, VSeWSS makes it significantly easier and developing SharePoint solutions is actually fun again. All steps can also be automated and integrated with various software configuration management and build tools.

Advantages

1. SharePoint provides a Visual Studio extensions that helps the user significantly by providing Visual Studio templates and automating the complete packaging and deployment process. This makes it easy for developers to get started as long as everything goes well.
   
2. SharePoint provides a full-features deployment system called the Solution Framework that developers can use to deploy their code within a SharePoint farm. We will cover that in more detail in the next part of the series.
   

Drawbacks

1. Deploying custom SharePoint solutions is still very complex under the covers. All artifacts need to be described using various XML files and packaged using specialized tools, as well as deployed, installed and activated in the target environment, which would mean to use a combination of console tools and the SharePoint Administration in addition to creating the .WSP file and all its contents manually. Fortunately, that complexity is largely hidden from the developer, but if something goes wrong, finding the source of the problem requires some time.
   
2. SharePoint cannot be developed completely on a usual WinXP or Vista workstation because it is at least necessary to use Windows Server with an installed SharePoint as runtime environment (or to use unsupported third party software). To have a reasonable development lifecycle, using Windows Server as development platform (be it native, in a virtual environment or on a central server) is strongly recommended.

As you know, Sitecore is based on .NET, and so the tool to develop extended Sitecore functionality is of course Visual Studio as well. So, let's see how to get started here... Again, as developer your expectation might be the following: Install Sitecore and VS2008, download the SDK, take a short look at some API sample, create or open an appropriate sample file, write three lines of code, hit "F5" and see your first shiny "Hello World". And guess what? That's exactly the way it works - and it strong contrast to SharePoint, that's all there is to it.

From the perspective of .NET, Sitecore is just a well integrated ASP.NET web application with advanced functionality and you can even run it using the WebDev.exe development server that is coming with Visual Studio, regardless whether you're running WinXP, Vista, Windows 7 or Windows Server (2003 and 2008 are supported). You can also use the local IIS coming with those operating systems (yes, even IIS 5.1 in WinXP), it is totally up to you.
This means you get all the things you're familiar with: Debugging .NET code (and even XSLT code) without any additional tasks, deploying additional assemblies to the /bin folder, using source code management tools and experience no limitations while doing your job. The integration of Sitecore and ASP.NET is really seamless. Another great thing is that you're not limited to Visual Studio, but you can even use Microsoft Expression Web to run Sitecore and choose every external editor (e.g. for editing your XSLT files) to change Sitecore solution and resource files.

In contrast to SharePoint, Sitecore provides you with a couple of additional developer tools within the system that can dramatically improve the quality of your results and your personal productivity. By using the integrated debugger tool to debug your web pages, you get a lot of useful information about your code, your renderings and your design, right where you need it. You can also use the Sitecore Developer Center to edit your XSLT code, your layouts and even your .NET code, so you don't need to use Visual Studio for very simple task like a short bugfix or minor update. Sitecore's Package mechanism makes it ease for you to deploy the code you created in your local or central development environment to integration, test and production environments (more about that in the next part of the series) and you can use the integrated log4net to trace the flow of your application without configuring and maintaining a separate logging framework or the Windows EventLog. While creating a reusable content type usually involves a lot of XML hacking, deploying, installing, activating and configuring within SharePoint, using the Template Manager in Sitecore to create your own information structures is a breeze.

Advantages

1. Sitecore behaves like an usual .NET application during development and deployment. Developing for Sitecore is exactly like developing with any other .NET library, as it is fully integrated with Visual Studio and the WebDev server. You can even use the free editions of Visual Studio or Expression Web - or any other tool you prefer as long as it runs on the Windows platform.
2. Sitecore offers additional developer tools as part of the distribution and in form of additional tools through the Sitecore Developer Network.
3. Visual Studio is your one-stop place for developing Sitecore features, there is no need to switch to any other application, except you want to.

Drawbacks

1. For the time being it is not possible to rollback Sitecore package installations. This would be a very, very nice feature for the future, although I'm aware of the complexity of that request.

So let's draw our conclusion here. Developing Sitecore and SharePoint is not that different anymore thanks to VSeWSS, although there are still some minor drawbacks in Microsoft's web content and collaboration platform. Of course, no framework is ever complete nor perfect, but Sitecore has managed to create a great developer experience and a pretty great framework.

Sitecore: +10 points = 34 points total
SharePoint: +8 points = 25 points total

See you soon for part six...

I just relaunched my website at http://www.juliusganns.com. My blog posts will be published in this blog as well as in on my new website. Tell me what you think...

I guess, I own a couple of computers. At the time of this writing I have a Windows Vista Notebook for developing software (Dell Latitude E6500), a TabletPC for designing software, training and consulting (ThinkPad X61), a Netbook for the agile manager (Samsung NC10), a Media Center (Sony VAIO), three XP Desktops for gaming with my friends and surfing at home, a Windows Server 2008, a MacBook Air and a Mac Mini.

As I want to have all my files with me all the time, a sync software is mandatory for me. In the past I used AllSync with a central fileshare via VPN on my server, FolderShare (which is now Windows Live Sync, see http://sync.live.com), Microsoft Office Groove and BeInSync (http://www.beinsync.com/). A couple of months ago I moved to Dropbox (http://www.getdropbox.com). For the moment, it is just working fine, I really love the versioning support and that it runs on both Windows and Mac, but there are some drawbacks. First of all, I cannot choose multiple specific folders to sync between my systems, there is just the one "My Dropbox" folder. Second, I cannot limit certain folders to certain systems - bad for large stuff like music and pictures that I don't need on any system. Last but not least, I cannot choose an existing folder after I have reinstalled my OS that already contains most of the synced data, so I have to choose an empty one and wait until Dropbox has downloaded everything to my newly installed system.

As .NET developer and Microsoft guy, Live Mesh (http://www.mesh.com) seems to be the ultimate tool for the future, although it is still in Beta. Except for lack of version support in the current release, it seems to bring everything to the table that I need (including Mac support) - and it is more than just another online file sync service. As you can read for yourself in one of my previous posts, Live Mesh is a whole sync eco system that can transparently manage all kinds of data, including the one you need in your own applications.

I will also try out Syncplicity (http://syncplicity.com/), just to make sure that I don't miss anything. :-)

I just read J.D. Meier's blog post regarding the new p&p App Arch Guide 2.0 which includes the new Microsoft Reference Application Architecture. I was not very surprised but to be honest, I was very pleased to see that it is about 95% the same as our internal Reference Architecture at netzkern, which I presented about 3 months ago in an internal technical training.

It seems that Microsoft also agrees in other areas with our methods. This post on Microsoft's Agile Architecture Method is nearly identical with parts of our Software Project Lifecycle Guide, an internal hands-on booklet for specifying requirements, estimating, managing projects and creating solution architectures.

This is just a short post to everyone who is waiting for part 5 of my SharePoint and Sitecore series. Of course I received your mails and I'm aware of the fact that it is eagerly awaited, but I have to put all of you off for another week. My article series already produced three additional projects in consulting and to keep business going I had to handle those jobs with priority. Thank you very much for your patience and stay tuned!

Taking a look at Microsoft .NET these days, I'm really glad that I've chosen to make it my primary platform about four years ago. Although I still tend to miss some enterprise features in the platform like EJB 3.0, ESB frameworks and Web Beans ("JBoss Seam") in Java EE, I have to say that the technologies presented at PDC are really exciting.

There is, however, a certain "gap" in Microsoft's philosophy: The integration of the managed world and the operating system. As we know now that Windows 7 is based on MinWin, an initiative of Microsoft to "clean up" the base system of the Windows kernel and to decouple the layers of the system, some of us start to think about when Microsoft will eventually replace the Win32 API with a managed API on top of a completely revised CLR. Microsoft already implemented Singularity, a "managed" operating system with an extended C# language called Sing# (which is basically Spec# with some OS extensions). I think, they learned a lot of stuff in this project and they learned a lot of things from RedDog, also known as "Windows Azure" these days.

Combining that knowledge from all those projects like Singularity, Windows Azure and the work on MinWin, I would expect Microsoft to put additional effort in building "RedHawk" (which is the code name for the managed Win32 replacement). I for myself have never been a low level guy, although I developed some Linux kernel modules for fun. I love the Web, I love SOA and I love to work with managed platforms like .NET and Java EE - but I have to admit that from time to time it would be great to be able to do some "basic things" using my preferred languages without having to switch to C++.

Optional and Named Parameters: http://www.infoq.com/news/2008/10/CSharp-Optional
Dynamically Typed Objects and Duck Typing: http://www.infoq.com/news/2008/10/CSharp-Dynamic

Thank you, Anders.

Okay, the Keynotes are over and everyone is flashed... What have we seen in the last 24 hours?

Windows Azure & Azure Services - Microsoft's Cloud Operating Platform with several enhancements for .NET developers like .NET Services, Live Services and SQL Services.

Oslo - The next generation modeling platform for service-oriented applications.

Windows 7 - How Windows Vista should have been: Fast, reliable and with new productivity features.

Microsoft Office Web Applications - Microsoft has finally brought his Office suite to the web and added a couple of synchronization and integration features.

Windows Live ID with OpenID support - Finally you can use your Windows Live ID to login to OpenID sites.

.NET Framework 4.0 and ASP.NET 4.0 - A couple of cool new features, especially around the MVC Framework and Silverlight, but also extend VS2010 functionality and new programming language features.

These are in my opinion the really huge things from PDC and there are a lot of more. I just registered for the Azure and the Live Services SDK and I will try it out today.

Microsoft's cloud operating system running the infrastructure of Live Mesh will most likely be named Windows Azure in the future. Check our the following Channel 9 videos:

Introducing Windows Azure
Windows Azure for Developers

Enjoy.