The patterns and practices team from Microsoft released recently a new compilation of architectural guidance. This time it is for SharePoint :), and can be downloaded from this url: http://msdn.microsoft.com/en-us/library/dd203468.aspx

The guidance addresses several important important subjects like:

• Feature factoring and packaging - best practices and patterns for deciding on how to consolidate functionality into SharePoint features and packages;
• How to compromise in SharePoint :)) - which are the most common tradeoffs we face when making design decisions (for example: SharePoint list vs. database ... I bet you know this one)
• Managing environments for SharePoint projects (dev, build, test, staging, production environments)
• Managing development lifecycle (dev, test, deploy, upgrade)

There are many more interesting topics covered in this guidance, so I strongly encourage you to read it.

Without a doubt, Windows is the star of PDC 2008. Be it Azure or 7, almost all the buzz around here is about Windows. Windows for the cloud, Windows for the client, Windows for the mobile. But as always, in the shadow of the giant, there are other things, some of them having the potential of a larger impact than the giant itself. You might have guessed, I'm talking about "Oslo".

I've already mentioned some of the fantastic things that we're going to see in C# (both in the new, 4.0 version, as well as beyond that). Before going on with this post let me just say that I am a huge fan of C# (I do all my coding using it) and I think it's one of the best programming languages ever. Still, I do not see myself in 10 years time writing too much C# code anymore (and that's not because I'll be too old for that :) ). The reason is simple: as powerful as C# is, I am finding myself many times doing the same thing over and over, and, despite having the patterns in my mind, I do not have the proper means to apply them while coding. Which leads to the immediate question: is C# too general for my application's specific domain? Well ... in many cases, it is. It's powerful, flexible, efficient, but ... too general.

Enters "Oslo", Microsoft's new platform for model-driven applications. It's primary goal is to bridge the gap between the "low" level of abstraction found in the programming language and the higher level of abstraction of the specific domain we are trying to support with the piece of software that we write. As a matter of fact, abstracting things is not at all new in our world. Think about IDL for COM, metadata attributes for .NET, or even XAML. If you think about them, all are attempts to increase the level of abstraction, in order to improve productivity. In other words, they were attempts to let people write down stuff in a way that is much closer to the domain of the problem they were working on than the programming language itself. Some call this modeling :D But more than that, the stuff that was written down, was also accessible to the different runtimes who where taking actions based on that content.

With "Oslo", Microsoft proposes a structured, coherent, and tool-based approach to modeling. I've witnessed some amazing demos here @ PDC 2008, where Oslo was used to create a high level, domain specific language (for implementing a certain class of WCF services for example), which in turn was used to dramatically increase the productivity of the ones producing solutions for that particular domain. Think about writing a WCF service, in your own words! If that sounds SciFi, think again ... and take a look at "Oslo" ;)

Obviously, my title is a bit far fetched, in a sense that we're not there yet ... I mean "Oslo" doesn't promise (yet) natural language modeling. But it sure opens a wide window towards to world of Domain Specific Languages (DSLs). If you're not sure about the potential value of DSLs, think about some past experiences. For example, what did VB(3,4,6) to programming Windows applications. Some say it de-professionalized the world of programming, I say it opened huge opportunities. All of the sudden, developing Windows Applications was not reserved only for those mortals capable of working with WndProc.

Having said that, I'm not saying "Oslo" is going to simplify software development. But it sure will, at least, support a huge boost in productivity...

Should any of the above make some sense to you, start by taking a look at http://msdn.microsoft.com/oslo.

I took today a break from all the excitement around Windows Azure, clouds, and services, and I attended Anders Heilsberg's session about the future of C#. Oh boy, what a brilliant idea :) 70 minutes of pure joy ... ending up with what else than services?

Now, for those of you thinking C# reached its peak with version 3.0, you might think again.

Today's trends in programing languages can be expressed in three simple words: declarative, dynamic, concurrent. We're using more declarative stuff, we're interacting a lot with things that are not statically typed, and yes, we're running code on multicore machines. The most interesting of the three is clearly the dynamic aspect. Don't get me wrong, there's nothing wrong with the static approach. On the contrary. Static programming is a very good thing and it's here for the long shot. But things are changing. Take Silverlight for example and think about calling JavaScript. JavaScript is pretty cool, but static typing was never one of its strong points :)

As a matter of fact, the new paradigm in languages is ... well ... multi-paradigm. The truth is that we see languages borrowing from each other more and more. C# has now declarative aspects as well as functional ones. The purity of object orientation is a thing of the past. Of course, there's an endless debate whether this is a good thing or not, but the everyday facts are there and cannot be ignored.

C# 1.0 was about managed programming, C# 2.0 was about generics, and C# 3.0 was about language integrated queries. So what's in it for C# 4.0? Probably the most accurate word to describe it is DYNAMIC.

Before getting into the details, let's just think a moment about the .NET Dynamic Language Runtime. The DLR is based on a few key components like Expression Trees, Dynamic Dispatch, and Call Site Caching. The stuff that glues the DLR to the different environments is commonly referred as a binder (think about the object binder, JavaScript binder, Python binder, Ruby binder, or the COM binder). On top of the DLR, we already have stuff like IronPython and IronRuby. So what's next? ... You're right! C# and VB.NET :)

This leads to the first interesting thing in C# 4.0: dynamically typed objects. For those of you that have felt at least once in your life the pain of Type.InvokeMember or ScriptObject.Invoke, the new dynamic type introduced is going to be a bliss. All you need to do is declare a variable of type dynamic and you have dynamic method invocation. What does this actually mean? Well, to quote Anders, we now have variables that are statically typed to be dynamic :D. I suggest you read the previous sentence a few times before moving on :) :) I certainly did.

How does the code look like? Something like this:

dynamic calc = GetCalculator();

int sum = calc.Add(10, 20);

Declaring calc as dynamic means that the invocation of the Add method is going to be performed dynamically, at runtime.

The second really cool thing is one that we've been crying for for a long time. You're right, I'm talking about optional and named parameters.

And of course, there are many more. To name just a few: the ability to derive from DynamicObject (becoming a player in the world of language dynamism), safe co-variance, safe contra-variance, greatly improved COM interoperability, and so on. I'll get back in the following weeks with more detailed posts about these features.

So, the story's complete: C# 1.0 was managed ;), 2.0 was generic, 3.0 was LINQ, and 4.0 is dynamic. Or... is it? Hell no! Anders and his team are already looking beyond 4.0 and what they see is nothing short of fantastic! In his talk today, he showed us just a small glimpse of things to come after 4.0. It was enough to get him a standing ovation at the end of the session!

What's the mystery feature? Common ... it's easy and obvious: it's about services. What kind of services? Compiler services, or, in other words the compiler as a service! The task at hand is to morph the black box that the compiler is today into a more transparent and accessible component. At the end of the day, this will enable you to compile pieces of source code on the fly and even use them in the context of your current app domain. In one word, amazing!

Oh yes, I almost forgot one key issue: it's the first time I heard a personality like Anders talking about language parity. It certainly looks like the C# vs. VB.NET competition's days are over.

So, the first day of PDC 2008 is over and the buzzword around the conference is Windows Azure (we're expecting tomorrow a new wave of announcements related to the client side of things - Windows 7, Silverlight, and the likes). Naturally, everybody is debating the ultimate topic: what is Windows Azure after all?

Perhaps the simplest definition of all is: Windows Azure is THE Microsoft operating system for the cloud. Think of it as the modern version of Hal designed to harness the awesome power of the hardware located in geographically distributed datacenters. Those of you who are curious enough to dig under the apparent simplicity of this definition, will find out that this cloud OS aims to abstract the complexity of infrastructure management while providing a rich API for developers. On one hand, you'll get an abstracted execution environment, a shared file system, resource allocation, and of course a programing environment. On the other hand, you'll get 24/7/365 operation, a pay as you use billing model, and the much praised simpler/transparent administration.

Of course, we're talking here about a CTP, so expect lots of changes by the time this stuff goes gold. Even those who are behind Azure acknowledge there are still things to figure out. Among them, issues like the billing model, legal challenges, localization/local issues, data privacy questions. What strikes me in a very positive way is the openness of the architects of Windows Azure. Instead of being slippery with issues like the previously mentioned ones, all speakers, with no exceptions, admitted that Azure is work in progress, and because of that, the final shape of the product will depend a lot on customer input/feedback.

Besides these types of concerns, the question asked most of the times was: will Azure be available for independent deployment by other organizations than Microsoft? The response from Microsoft is that knowledge gained in Azure will be eventually transferred into server products which in turn will be (as they are already today) available for on-premises deployment. My understanding is that Microsoft is not yet prepared to address/discuss the issue. If you take into consideration the fact that after all we're talking about a CTP, that seems a perfectly valid position.

Another interesting debate that is shaping up is the one related to on-premises vs. cloud services paradigms. As one would expect, cloud services are bringing inevitable shifts in the mindset of architects and developers as well. Think about the long way we've gone from monolithic software in the 70s, client/server in the 80s, web apps in the 90s, SOA today, to services (which are just under tomorrow's horizon). Every single step of this evolution came with the inherent paradigm shift. I'll get into more details about this subject in a future post.

Let me get back a bit to the definition of Windows Azure... there's one buzzword there that deserves close attention. Yes, you're right :) ... it's the CLOUD. What a heck is after all this cloud we're all talking about? Well, if you ask me, I'd say the cloud is basically a bunch of connected servers that enable you to install and run services on one hand, and storing and retrieving data on the other hand. Do we already have clouds today? Sort of... The catch is that today, the datacenter component of the cloud gets most of our attention while the business logic is usually the part that gets too little attention at the end of the day. By the datacenter component, I understand things like addressing HW failures, accommodating traffic fluctuation, scaling capacity, handling service failures, patching, upgrading, localization, and the list can go on and on. The big promise of the cloud is to free us from most of this pain. Still, as I already mentioned, there's going to be a price to pay for this luxury, and I'm not talking about the service fee :) Some will be ready to pay it, some not.

So far so good, but let's take a look now to the core Azure features which are:

- Automated service management

- Service hosting environment

- Scalable and available storage

- Rich developer experience

Automated service management is all about developing, modeling, deploying, running, and maintaining the health of services. Stuff like defining service topology, size, health constraints, and config settings is already available in the current CTP.

The service hosting environment is based on fundamental components like servers, load balancers, as well as concepts like virtualized and/or direct execution.

Blobs, tables, and queues are the basic primitives of the scalable and available storage. While not being exposed in the current CTP, there are also others like streams, caches, and locks. Perhaps the most important thing to understand about the storage feature of Azure is that it is not a db service in the cloud. From what I've seen so far, there are many who have a real problem understanding this fundamental aspect. Microsoft set some pretty impressive goals for Azure storage: massive scalability, high availability and durability, as well as geo-distribution and geo-replication. It's going to be pretty interesting to see how they meet these goals as they are closing to the first Azure release.

Last but not least, there is the developer experience. Since we're talking Microsoft here, everybody expects it to be exceptional. At this point, it certainly looks set to be. We're talking here about ASP.NET support, Visual Studio integration (the current CTP), and native code support, PHP support, Eclipse integration (in future CTPs). Did I mention there's also a complete cloud environment on the desktop which enables us to develop Azure applications offline?

Well, that's about it... :) I don't know how the future looks for Windows Azure, but I definitely know that we have pretty interesting times ahead. The cloud wars have just entered a new stage.

Windows Azure was just announced by Ray Ozzie during the PDC keynote, signaling the entry into the public stage of a major shift in the Microsoft Platform. The tremendous expertise acquired by Microsoft when building and operating services like MSN, MSDN, Windows Update, and many more, has been morphed into a major technology and platform release named Windows Azure.

On top of Azure, one can find a lot of services like Live Services, .NET Services (containing also the former BizTalk Services), SQL Services, SharePoint Services, and Dynamics CRM Services. As expected, Microsoft itself places a major bet on the Azure Services Platform with stuff like Windows Live, Office Live, Exchange Online, SharePoint Online, and Dynamics CRM Online.

And guess what? Yes, all PDC attendees will get their hands on the Azure Services Platform CTP, specially released for the PDC.

Well, I have to admit I'm very excited right now, sitting at the PDC keynote and watching (dare I say it?) history in the making. The technology looks awesome!! But, as someone said these days, "head in the cloud, feet on the ground". Technology is great, but it's not enough. Time will show if the "clouds" accumulating over the IT industry are here to stay :) or they'll be blown away by the first breeze :)

More on this stuff later ... time for some cool demos.

So, we're finally :) @ PDC in Los Angeles, California. The first keynote of the conference is about to begin. I'm sitting right now in the huge keynote hall at the LA Convention Center, waiting anxiously for the keynote to begin. We're supposed to hear about a lot about uber-cool stuff like clouds, live services, Windows 7, and many more. The atmosphere is fantastic, and the people are excited.

Yesterday, we've been at the RD side-meeting. Unfortunately, Kevin (our RD manager) will have to kill me if I tell you about the stuff we've discussed there, but, believe me, we're about to live fantastic times!

I'll get back later with more cool stuff from PDC...

This year, at TechEd South Africa I had a very interesting talk about Data Mining (and SQL Server 2008) with Rafal Lukawiecki. It has just ben published online here. You can also watch it together with other very interesting recordings on the http://microsoft.com/teched.

With the MS BI Conference now in full speed, a few interesting announcements were made about three major projects: code name Kilimanjaro, code name Madison and code name Gemini. There's already been quite a lot of buzz around this stuff, so let's take a closer look into it:

Kilimanjaro = BI-focused upgrade to SQL Server 2008, including two important initiatives: Gemini and Madison

Gemini = building into in-memory capabilities with Analysis Services via an Excel add-in. Millions of rows, fast-moving sorting, filtering, slice capabilities, and of course, all integrated with SharePoint. Essentially, another storage mode for Analysis Services with access via MDX.

Madison = stuff MS is doing with the recently acquired DATAllegro technology. Essentially, we're talking about warehouses up to hundreds of terabytes.

Looking at the larger picture, Microsoft joins the in-memory trend that builds up in the industry: IBM Cognos with Applix, SAP Business Objects with SAP BI Accelerator, Oracle with TimesTen, plus the independents like QlikTech for example.

Take a look to the following links for more details:

Mosha's blog:

The big news from MS BI Conference are out

So what is exactly “Project Gemini”

Watch announcements from MS BI Conference in video recording

Doug Henschen's article:

http://www.intelligententerprise.com/channels/business_intelligence/showArticle.jhtml?articleID=210700171

I was unpleasantly surprised these days by the Financial Times due to the publication of Jonathan Schwarz’s anthem to Open Source software as the engine driving a “tidal wave of wealth creation” (Digital Business Supplement, Wednesday 17 September). You can read the whole text here.

As a Romanian entrepreneur who built and developed his own IT company in the past 10 years, I am shocked to see a prestigious institution like the FT allowing for publication a blunt, insidious, and totally misleading LIE like “companies across […] eastern Europe, […] are predominantly using open source software to create enormous wealth”. According to my understanding, such a statement should be endorsed by some kind of statistics or at least a quote from a widely accepted study. Unfortunately, it is not, and the reason for this is simple: the real situation in Eastern Europe is radically different and even if you’re as ecstatic as Jonathan Schwartz is, it’s impossible to invent something that does not exist.

Just learned today the hard way that .NET framework 3.5 and PerformancePoint Monitoring Server 2007 have serious issues when they are installed on the same server. To be more accurate, when you use the Dashboard Designer to connect to PerformancePoint Monitoring Server 2007, you get the following message: "Unable to Connect to Server". Nice, isn't it? :)

The thing is that PPS Monitoring exhibits this issue when installed after .NET Framework 3.5 is installed on the same machine. A simple workaround is to uninstall both of them and then install PPS Monitoring first, followed by .NET Framework 3.5. You can find here a KB article with more details on the issue.