So, a little more adjusted to the time zone, not wakening up 4 am to watch the ceiling for an hour before going down to the Fitness Center. Today I just woke up 6.30, got a shower and then went to GWCC to meet up with Martin for breakfast.

Eventually there’s a timeslot where kind of no session seem that appealing – this was one of them and early in the morning as well. Should I pass or should I go to the Hands On Lab area to try one of them out? I did pick a session and it was

COS304 - Using Windows Azure Storage (Jai Haridas)

Actually worth going to this one, he did a good job explaining the differences between the way of storing data in the cloud: Blobs, Drives, Tables and Queues. Good demos made me understand how I’m supposed to use this in real life. He got in to all of them in enough depth so I got a felling for what they could do and what they couldn’t do – and when to use what. I really liked this session and did not at all regret going here.

DEV313 - Microsoft ADO.NET Entity Framework 4 and Beyond: Building Real-World Applications (Jeff Derstadt & Jonathan Aneja)

We’re using EF4 right now in my current project so I thought that it would be a good idea to go to some of the EF4 sessions. In this one there were a real world example from NBC. It’s nice to see that we’re not the only one to struggle with (against) EF4 – but in all a satisfactory session. One of the gems to bring home was the compiled query stuff and the ability to serialize it as JSON.

DEV338 - NuGet: Microsoft .NET Package Management for the Enterprise (Scott Hanselman)

This one wasn’t either on my original schedule, but after all the talk the first day about NuGet I just was forced to see this. On the other hand it was Hanselman so I could have picked anyway. Well, as usual he delivered a good – or actually very good – talk, an this time without demo crashes. There were some mocking on Twitter after his crash in the Monday session.

Now, I’m completely aware of what NuGet is and what it can do – 75 minutes well spent. I’ll have to start using this when I’m back home, I guess I have to show some demos for my colleagues before they accept this, but now I’m well prepared.

During this talk I also picked up other stuff to put on my must-try-list: Elmah and Mercurial with BitBucket, lets see if it’s anything to use.

DEV337 - Moving Your App and Skills from WinForms to Silverlight and WPF (Pete Brown)

Despite of the level and of the title, this felt like a 200-level talk and even if there were lots of demos the technical content was way to simple. He brought up obvious thing when shifting from WinForms to Silverlight and/or WPF – and it felt like he just jumped over the hard stuff.

DEV323 - A Taste of F#: Today and Tomorrow (Don Syme)

Not all that much new, but a decent talk. The today-stuff was more focused on beginners – I have been playing around with F# since early 2008 way before PDC 2008 so all the points of simplicity and the async/parallel reasons didn’t bring anything new to the table. And the tomorrow stuff was focused on FrebaseData – interesting for sure, but not that’s more a cool thing that a language innovation or a language development. Always nice to listen to Don Syme, though.

On the pre-conf day it feels like the conference is going to last forever, but all of sudden it is the last day…

DEV302 - Identify and Fix Performance Problems with VS Ultimate (Benjamin Day)

When I do performance coding, I do think the “fix” is the more interesting part. The “identify” is simply the boring stuff I have to go through to get to the “fix” part. This talk was totally focused on the “identify” part – and therefor for me, totally boring. And not much new stuff either, the last day could definitely have started better…

DEV335 - Improving Your Microsoft ASP.NET Application Performance with Asynchronous Pages and Actions (Tiberiu Covaci)

Ah, a fellow Swede… Good session that matched the title perfectly. Lot of things that I have been unaware of – or at some point in time had been aware of but now forgot. Yet again the full history of Begin/End, Async/Complete to the new async keyword. I don’t know if the speakers look at each other topics or if the track chair look – but this was my third session where this full history. Now, I like asynchronous programming so it really doesn’t matter that much to me – but could we use the time more effectively?

The twist in this talk was the asynchronous page directive in ASP.NET, and that was completely new to me – or perhaps as in the previous talk, something that I have been aware of but forgot because I never used it. Since I usually tends to do back-end or server stuff the async thing is on my radar, but it wasn’t really for page code. Now I have to have it there as well.

MID302 - AppFabric Caching: How It Works and When You Should Use It (Jon Flanders)

I might say that this was one of the reasons for going here. I’ve been working with AppFabric cache the last month at my current project. The bottom line for this session is that I think I got it all while working with it. Now, that might be feeling like wasting time to go to a session like this, but it’s actually kind of nice to get a confirmation that there isn’t anything else.

DEV377 - Ask Scott Hanselman

My only interactive session this year, with my favourite: Hanselman, and he delivered one more time. There were no specific topic, instead the audience asked questions from organizational questions about MS to specific technical details about lots of stuff – and lots of jokes as well.

The gem I bring with me from this session is Glimpse. I had not seen this tool before and I have to ask my more front-end focused colleagues if they use it. Hanselman describes it “like the FireBug client side debugger, except it's implemented in JavaScript on the client side with hooks in to ASP.NET on the Server Side” in a blog post.

Before the last session I ran to the exhibit hall book store to see if there were any books on sale and I bought two with 20% off.

DEV351 - Busy Microsoft .NET Developer’s Guide to the Microsoft Cloud (Ted Neward)

He started with a declaration that he would present any demos, that this would be a Power Point only talk and that anyone that was uncomfortable with this could leave if they wanted to. I remained in my seat somewhat sceptical, but it turned out to be one of more interesting talks of the week. Not the usual “hallelujah, do this and everything will be fine”, on the contrary he told us to be sceptical and careful about putting applications and/or data in the cloud.

An end session that gave us something to think about on our way home

I keep coming back to a sentence in Andy Hunt and Dave Thomas The Pragmatic Programmer and that's "Learn a new language every year". Earlier this year I started to look at F# but it's hard to keep up a good momentum when the current project just spins at full speed (or above...).

The question is here whether Oslo "M" counts as a new language or is something completely different - because the story on Oslo is that I have to learn that in a near future.

Anyway, I decided to to indulge my self and pick one or two sessions just to pick up the trend outside the ordinary imperative C#/VB way of programming (and not related to Oslo).

So going to Luca Bologneses Introduction to F# was obvious for me, first of all to catch up with stuff that have been changed since I looked at it and partly to get an indication if I understood the language at that time (and if I still do). I could not spot any differences, but there have been  new releases of CTP's so there must be something - not obvious to me. He did a great job of explaining the language and the paradigm of functional programming, at least in F# - I have nothing to compare to. It actually feels like I got it the first time, but there's always the small details that I missed and hade the opportunity to pick up this time. And he explained how the area of parallel programming is done in F#, a topic that I completely ignored earlier but as it have bee quite a buzz around it this PDC I was curious how it was done in F#. So the bottom line on this session is that if you're in anyway about to start doing F# or just curious about it - see this session!

The second session on my personal indulgence theme was John Lam's IronRuby - The Right Language for the Right Job. Ruby has been on my to-lear-list for quite a time now and I figured that John Lam was the guy to see, at least in the MS arean of Ruby. I must admit that I didn't got it all the way when sitting in this session, but to my defense I would claim that it was the last session on the first day and I was heavily jet-lagged. It was interesting, thou, and the feeling is that I'm going to look at this - eventually. I guess that I'll look at this session a couple of times and buy a book on the topic and finally put my hand on the keyboard, but with all the other new stuff here at PDC I don't think I'll have the time with Ruby in the coming 6 month.

The last reflection on this outside the box thing is a recommendation I've got from a other attendees here and that is the session on Declarative Programming Using XAML. I don't know if this qualifies as "outside the box", but it's not C# nor VB... At that time I was out of indulgence point and have to be on a real job related session. But this is one of the sessions that I'm going to see on the flight home.

Finally I'll say that I strongly agree on the theses of learning a new language every year, you don't have to master it or even just be good at it. It's just enough to look at it, pick up the idioms, the way of thinking, the way to see the world and the way to solve problems. That'll make you a better programmer in you "first language" because it'll make you a better programmer period.

Andy Hunt & Dave Thomas suggested in their book "The Pragmatic Programmer" that you should build you knowledge portfolio, for example by learning a new language every year. Further more I've had the opportunity to listen to Andy Hunt twice over the last two years and he talked more about the subject. And during the fall and winter, it have been quite noisy about functional programming on dotnetrocks and I ended being somewhat curios about it.

So I decided to start learning a functional language and since I mostly spend my days in Visual Studio with .Net it felt easier to start with F#. And after a nice download and install experience from MS Research's F# site it was all up to me...

After a couple of tries I completed an implementation of quick sort:

let rec quicksort list =
    match list with
    | []           ->   []
    | head :: tail ->   quicksort (List.filter (fun e -> e < head) tail) @ 
                        [head] @
                        quicksort (List.filter (fun e -> e >= head) tail)

It's not a problem I would have started with in another language, but I felt encouraged to look back in my old school books on recursive functions and it turned out really good.

My first impressions was quite nice and I got a lot of Lisp-flashbacks from my school days. But since it's rather unlike my normal C#-imperative way of thinking I felt that I needed some kind of guidance so I went away buying a book, "Expert F#" by Don Syme et al. and it really explains the whole thing. The only problem now is to find the time to try it all out...