Last thursday, the last PDC Report Back event was held at Logica Rotterdam. It was the third and final time I held my 'Introduction to Oslo' talk.

As promised, here you can find the audio recording, screencast and the powerpoint slide deck.

- Slide deck

- Audio recording (beware: in Dutch!)

- Screencast, see the flash movie below (beware: it's also in Dutch!)

Enjoy!

And tell me what you think of it.

Yesterday, the first of three PDC feedback evenings was held at Logica, Amstelveen.

Rutger de Vries, Rene Schrieken and myself gave talks about three different subjects; we had a great time sharing our thoughts and knowledge. First Rutger talked about Visual Studio 2010 as Cameron Skinner did on the PDC. Rene presented the .NET framework 4.0 and it’s new features and I gave a talk about Oslo.

Two more feedback evenings will be held: next week we will be in Eindhoven and in march we will visit Rotterdam. Hope to see you there!

After the last talk, I’ll share the slide deck here.

Here are the sessions I attended, with links to my blog posts an to their recordings:

Sunday	Pre Conference : Working With WCF - Juval Lowy & Ron Jacobs
	Pre Conference : Working With WCF (Continued)
Monday	Key Note  – Ray Ozzie …	http://channel9.msdn.com/pdc2008/KYN01/
	A Lap Around VSTS 2010  – Cameron Skinner	http://channel9.msdn.com/pdc2008/TL47/
	Dublin and .NET Services  – Jacob Avital	Download High Quality WMV
	The Future of C# - Anders Hejlsberg	http://channel9.msdn.com/pdc2008/TL16/
	Team Foundation Server 2010 Cool New Features - Brian Harry	http://channel9.msdn.com/pdc2008/TL52/
	Microsoft .NET: Overview and Applications for Babies - Scott Hanselman	Download High Quality WMV
Tuesday	Key Note  - Ray Ozzie & Scott Guthrie…	Download High Quality WMV
	Key Note - Don Box & Chris Anderson	Download High Quality WMV
	WCF Zen of Performance and Scale - Nicholas Allen	http://channel9.msdn.com/pdc2008/TL38/
	A Lap Around Oslo - Douglas Purdy & Vijaye Raji	http://channel9.msdn.com/pdc2008/TL23/
	“Oslo”: The Language - Don Box & David Langworthy	Download High Quality WMV
Wednesday	Key Note - Rick Rashid	http://channel9.msdn.com/pdc2008/KYN04/
	Building WCF Services with WF in .NET 4.0 - Ed Pinto	http://channel9.msdn.com/pdc2008/TL06/
	PDC – Day 4 – Oslo, Customizing and Extending the Visual Design Experience - Florian Voss & Don Box	http://channel9.msdn.com/pdc2008/TL18/
	Dublin, Hosting and Managing Workflows and Services - Dan Eshner	http://channel9.msdn.com/pdc2008/BB18/
Thursday	Web Services in Native Code - Nikola Dudar	http://channel9.msdn.com/pdc2008/TL04/
	Microsoft .NET Framework : CLR Futures - Joshua Goodman	http://channel9.msdn.com/pdc2008/PC49/
	“Oslo” Building Textual DSL’s - Chris Anderson & Giovanni Della-Libera	http://channel9.msdn.com/pdc2008/TL31/
	Microsoft .NET Workflow Service - Moustafa Khalil Ahmed	http://channel9.msdn.com/pdc2008/BB27/

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