Pär 0 Comments

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.

Pär 0 Comments

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.

Expert F#

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...