That was it! After five days stuffed with new technology, demo’s, source code, interesting people and a terrific conference,  it’s over!

Tomorrow morning, I’ll get up really early to get my flight back home. Back to my lovely wife and daughter (I’ve never been away from my daughter for more than two nights, she’s 1,5 years old now;  so I’m excited to see her and my wife again)

What was remarkable?

The organization of the PDC. Its BIG, its HUGE and there are a LOT of people involved. Every day when you walk though the convention center you see hundreds of waiters, waitresses, stewards, technicians, cleaners, bus drivers and many more.
Also all those attendees from all over the world who come here to listen to the same thing... It was fun to see and hear people from Israel, Scotland, Germany, The Netherlands, Norway, America and many more countries that come to enjoy themselves with listening to talks and doing what they like most.
Last but not least, there was a total of 209 sessions spread over 4 days, all recorded so check them out at https://sessions.microsoftpdc.com/public/timeline.aspx (look for the video tab when you select a session)

(I’ll post an overview of all the sessions I attended and direct links to their recordings soon)

See you Saturday!

This was my first PDC, and I liked it! :)

This was the my final session of this day and the end of PDC 08 :(

This session was about the “.NET Services” piece of the Azure Services Platform

With .NET 3.0 you had to host your workflow yourself, on your premise.
This PDC, we heard of two other options we now have:

You could use Dublin, also on-premise but provides with a lot of tools
You could now also use the .NET Workflow Service, a host for you workflow in the cloud!

So what does the Workflow Service consist of:

And what new activities do we get?

• The HttpSend activity is all about sending a request and getting a response.
  
• The HttpReceive is getting a request and sending a response
  
• The ServiceBusSend will let you send a message to the ISB
  
• The XPathRead will let you do an XPath on a piece of XML and act accordingly; so very suitable for content based routing

How will we be able to deploy and maintain our workflows to the cloud?

So you can do this by using the Azure portal, using .NET client API’s, calling the Azure SOAP web services directly and you can deploy a workflow from Visual Studio with just one mouse click (right click, deploy)

Again an Oslo session :)

By the way, I really like how Chris Anderson presents these subjects. We saw him (also together with Don Box) a couple of times, and there talks are very good. This is because they know how to wrap the message they want to spread in a very, very humorous way. (Or does Oslo make them funny, because the same applies to the “A Lap Around Oslo” by Douglas Purdy, which was also quite some fun!)

This session was about MGrammer, the Text to Data bits of Oslo.

MGrammer fits in right here:

And it’s made to transform Text input to MGraph output:

Here is a small example of an MGrammer language:

Left is the “Contact” textual data input. In the middle is the “Contact” language. To the right is the output of the language.

So what do we see within the language?

• syntax is the definition of an entity. The entry point of the language is “Main” and it defines that it contains a Contact entity.
• The Contact entity is made op of the string “Contact” followed by “:” and an Alias and the shape of this entity is the Alias contained in the Contact. Then, you see a pipe. This means that the Contact entity can also be of the following syntax:
  again the string “Contact” followed by “:” and an Alias and then “-” and then a PhoneNumber and the shape will then be that the Contact contains an Alias entity and a Phone entity.
• a token defines what the engine should match on. So an Alias is defined an string of A..Z and a..z
• A Digit is a character of 0..9
• A PhoneNumber consists of three Digits, then “-”, again three Digits, again “-“ and four Digits.
• The interleave defines what the language engine should discard in the input data.

It is also possible to define parameterized rules:

This looks like a function in functional programming;  It states that a CommaList list of certain Element entity could be either on instance of that entity, or it is a list of that entity followed by another instance of that entity. This reminds me of my Prolog days during my study : http://en.wikibooks.org/wiki/Prolog/Lists Look for the Head Tail stuff.

When the language is ready, they compile it with mg.exe to an mgx file.
This mgx file can than be picked up by a run time and used. We were shown how this is done within Visual Studio:

It’s a bit hard to see, but here they load the mgx file from the assembly resources and create a DynamicParser instance. Then, the parser can be fed with a textual input and the input gets parsed through the language and the output is an object (this is an object, because the output of the language could mean anything, text,c#,bytes….)

Then, a GraphBuilder is created which is used to iterate over all successors (in this case Contacts) within the output. Then each Contact will get iterated and the “Alias”  label will be sought and its value displayed.

So how can you use MGrammer with the CLR:

You can use a build task to transform the MGrammar language into an MGX.
You can use the MGrammarCompiler to create an MGX in memory.
You can use the DynamicParser to parse the input text data though the mgx in memory.
And you can use the IGraphBuilder to read and build MGraphs

Joshua Goodman gave this talk and he did it in a humorous way. The overview he gave was a good one, and just about all the new .NET features he described were very interesting.

So what is new?

The .NET 2.0 and 4.0 CLR’s can now run in the same process:

Using an old Native application within a .NET environment will become less of a hassle:

We will get a new type, the BigInteger:

We will get Tuples (like in functional languages), and these tuples can be used in C# in a very convenient way:

Also, garbage collection is improved in .NET 4.0:

This is on the client side:

Watch the new background compilation, this improves performance of your apps, because Gen0 and Gen1 collection can be simultaneously done with Gen2 collection.

On the server side, garbage collection is also improved. When you’re on a web farm behind a load balancer, you will be able to subscribe to an event that Gen2 collection is going to take place. You can then notify the load balancer to stop sending requests to you, let the gen2 collection finish, and then notify the load balancer to start sending the requests again.

Also new are corrupted state exceptions:

This means certain exceptions cannot be caught any more (overridable with a switch)

Also new and very interesting are the Code Contracts:

So how does this work?

The Requires will be called when entering the method. The Ensures will get called after processing the method. So you can define entry and exit rules within your method! You can even get a parameter “rolled back” when an exceptions occurs (see the last EnsuresOnThrow rule)!

So here’s it.. the last day of PDC 08; of course still some good sessions to visit, but nevertheless it’s been a rush.

I started this morning with Nikola Dudar speaking about Web Services in Native Code

This is what it says it is.. web services without the .NET framework, just writing native code.

As the session past by, and more C++ code within the demo’s was shown, I realized that this was not my kind of session. I have hardly written C++ and couldn’t think of a scenario in my field where this would really be an option. Where I do my work, a .NET framework is always installed and to me the C# language and the System.ServiceModel WCF base classes provide everything I wish for.

  We walked back to the hotel today, so it was a good opportunity to take some shots:

This is the before-final day of the PDC and I must say, the most interesting pieces of technology to me are Azure, Dublin and Oslo.
So this session was the more practical Dublin one. How do you use it, and what does it do.

So where does Dublin fit in?

And if we take a close look at Dublin itself?

Dublin extends IIS. You get new functionality there, where you can watch persisted instances of your service. Or look at the tracking data.
Dublin gives you Visual Studio templates for WF and WCF, so creating services using Dublin will be very easy.
Dublin allows you to Import and Export service applications within IIS!
Dublin will provide a “Model Deployment To Dublin” feature for Quadrant
Dublin will provide powershell commands
Dublin will provide tracking, monitoring, discovery out of the box

Also new is the forwarding service. It forwards messages based on filters (this can be content based rules!!) to different endpoints. So how cool is that? Just relay your message to different services without the service consumer ever notice?!

The overall message of this session : It Just Works

I guess you’ve heard of Oslo by now. This session was all about Quadrant. The Oslo tool to manage your Oslo data.

Quadrant itself us totally running model-driven. It can be extended in every sense, and be customized to whatever user’s needs. You can view your data in different standard ways (table, treeview, diagram…) but also define your own custom views. You can traverse your data by clicking on the HyperIcons. Each Workpad is like a internet browser and contains it’s own history engine; so jumping back and forward is easy.

We will hear a lot more about this tool… it will enable us to give a GREAT user experience to manage data for people in whatever role. You can make it as easy or complex as desired.

I hurried from the key note to this session room to be able to video call home a moment. Luckily, my little daughter wasn’t sleeping yet (time difference is 8 hours), and she still recognized me as her ‘papa’.
In this picture I made while the session had just begun, you can see here walking to her room to go to bed.

Anyway, Ed Pinto gave a great talk about this subject:

As a reminder: what is WF?

New in WF 4.0 are Arguments and Variables.
Arguments: types that flow in and/or out of your Activity
Variables: you can store values in variables while running an Activity

Activities have user defined Variables for data storage:

Activities bind Arguments to in-scope Variables:

So here is an example of a Parallel Activity within the new WF 4.0 designer:

And a Sequence with a Try Catch:

A BIG new thing within WF is extended Correlation. You can now define CorrelationHandle’s and bind your SendMessage and ReceiveMessage to it:

Finally, Ed told us that Dublin will easy all this tremendously. I’ll visit a Dublin session later on.

When should you write WCF Services using Workflow? And what are the other WCF 4.0 improvements?

To me it’s interesting that that WF is not positioned as just a Human Workflow engine any more. It’s now very suitable to use in your messaging applications and make use of it’s parallelism, correlation and tracking!

So, it’s Wednesday. My fourth day at the PDC.. Time is going fast….

This morning the key note is done by Rick Rashid; Mr. Channel 9 dude is also there to… hmm to do what? Ah well, he looks funny and if you’re lucky you get a petit small Channel 9 dude.

Mr Rashid told us about Microsoft Research. What does the organization look like, what do they do and where do they do it.

Two to most interesting things from his talk to me were the CCR and DSS Toolkit 2008 and DryadLINQ.
Trevor Taylor gives a nice summary of what this toolkit is, and you can get more information on the toolkit’s homepage.

The other interesting subject was DryadLINQ, which is a programming infrastructure designed to supports large scale computations over clusters. A technical report with sample programs can be found here.

At the end of the key note, we were shown “SecondLight”.. no, not Second Life, but Second Light.
It’s a multi touch display (you know, Surface), but is capable of displaying more information on a second display. It’s a bit hard to explain, so see it for yourself! I was stunned by the demo; really, really cool stuff!