October 17th and 18th this year, the VBUG conference 2007 takes place at Microsoft Campus in Thames Valley Park in Reading. Here’s the official info PDF about the conference. I’ll be speaking there about LINQ as well as WPF, and if you’re interested in Developer Express technology, this is the place to be because I’ll have a booth there and I’ll be ready to demonstrate all the products and answer all your questions. Looking forward to meeting you there!

Another new thing to mention: for Basta! conference Spring Edition 2008, I’m a member of the advisory board as well as the track chair for C#. Should be very interesting, not least because C# will play a very important role in that conference in February. A call for papers is already out - please feel free to contact me if you haven’t received it but you think you should have or it would otherwise be interesting for you.

If you’re in Germany, here’s (hopefully) interesting news: starting from issue 11, my column “C# Corner” will be a regular feature in dot.net magazin. I’m looking forward to writing articles for that, on new and interesting things going on around the C# language, as well as best practices and whatever else comes to mind, really .

I just got back yesterday from the Basta! conference in Germany. It was a great event, very busy for me but also lots of fun. My sessions all went very well and I had a great time talking to people at the Developer Express booth. Thanks to everybody who stopped by the booth or came to one of my sessions!

Here’s all the content from my sessions (if you attended Basta!, you should also receive a CD shortly with all the session slides and samples):

Power Workshop: .NET 3 - The Game Challenge (314896 bytes)

VB Day - Tipps und Tricks zum DataGridView (544838 bytes)

Dynamische Sprachen mit .NET (298443 bytes)

Bluffers’ Guide to C# 3.0 (318172 bytes)

10 coole Sachen, die man mit C# 3.0 machen kann (344387 bytes)

I might be late to the party, but I’ll still try to help spread the word: DDD 6 takes place on November 24th this year, and the call for speakers has just been opened. If you’ve always wanted to find good event to do your own session at, this might be it - go here to submit your session proposal!

It’s a problem, when you work with Expression types in any way, to understand the structure of complex expressions and possibly recreate them. After all, there are 46 entries in the ExpressionType enum, many of them corresponding to their own Expression-derived type, all of those with their own specific properties… in other words, it’s not entirely intuitive.

To help visualization of Expressions, I have created the ExpressionDumper, which outputs any expression (by default) in a nice hierarchical way on the console. It shouldn’t be too hard to use the class with other output targets, and I’m placing it under GNU LGPL license for others to use (that allows commercial use, in case you’re not quite on top of all the various open source licenses <g>). I’d appreciate being kept up to date with any further development you may do on it, but you don’t have to tell me if you don’t want to.

With this source code

Expression<Predicate<Product>> expression = p => p.UnitPrice > 10;
ExpressionDumper.Output(expression);

the ExpressionDumper is going to produce this output (of course this is a very simple example, chosen for brevity):

LambdaExpression (
  Parameters:
    ParameterExpression (p)
  Body:
    BinaryExpression:GreaterThan (
      Method: Boolean op_GreaterThan(System.Decimal, System.Decimal)
      Left:
        MemberExpression Product.UnitPrice (
          Expression:
            ParameterExpression (p)
        )
      Right:
        ConstantExpression (10)
    )
)

Without further ado, here’s the download: ExpressionDumper.zip (5159 bytes) 

Have fun!

I received the feedback list for my DDD 5 sessions yesterday. Let me summarize, with comments:

Session 1 with Ian, Bluffers’ Guide to C# 3.0 - most people thought it was great. The only criticism that touched this session was more about the combination with the second one, see below.

Session 2 with Ian, 10 cool things to do with C# 3.0 - most people thought this was great, too. Some said it was a little too much content for an hour, others said they enjoyed the longest demos most while the shortest were hard to follow. So either we should have gone for, say, 6 cool things instead of 10, or the demos should have clearer somehow. Of course the background of people wasn’t the same either… in the end, it has to be said that the session didn’t have the target of actually explaining everything we showed in so much detail that every attendee would have been able to reproduce it him- or herself. It was to be a compromise - some things that people would grasp immediately, others which would just provide food for thought. It was also clear that, depending on prior experience, the line between “what I grasp immediately” and “what looks great, but I really don’t understand at all” would be moving. In the end I think the comments show that we reached that goal for the second session.

For the combination of sessions 1 and 2 there were some comments that basically dealt with the format. It was said, for instance, that the combined description of the sessions was confusing because it sounded like we would do two hours of the same, while it was really one hour’s worth of introductory material and a second hour of advanced nuggets. On the other hand somebody said that he was surprised to find that the second hour more or less required the basic knowledge of the first. I guess this just shows us that session descriptions are in fact important, and that maybe the agenda system for DDD could be a bit clearer. We’ll be sure to take all feedback on board of course, and try to do things better next time.

Finally, Session 3, the .NET Game Challenge. Feedback on this was very mixed, although positive overall. Many comments picked up on things that I realized myself during and after the session. If you were there, you know that I did this session before, and I’m sure I can say that it went better the first time round. The main reason for that was that the session was tightly packed with content, and on a very tight schedule. With the (much!) larger and very interactive audience at DDD, it turned out to be impossible to keep everything on track. As a result, I had to use more copy&paste than I would have liked, and I can totally understand the comments which said that things seemed a bit rushed. I can only offer my apologies to those of you who didn’t like the session for these reasons - at least, according to the comments, the large majority still found the content very useful. So thanks for coming, and I’ll make sure to keep the specifics of the DDD audience in mind next time!

I finally made it Here are the files with slides and sample code for the sessions Ian and I did at DDD 5.

Bluffers’ guide to C# 3.0

10 cool things to do with C# 3.0 - Ian’s stuff

10 cool things to do with C# 3.0 - Oliver’s stuff

Finally, the sample from my session .NET 3 - The Game Challenge can be found here, attached to my previous blog post.

It happened last Saturday, and feedback from attendees as well as organizers seemed to indicate that it was another major success. I was pretty busy on the day myself. Ian and I did a double session on C# 3 and related features, which was received really well, although the presentation and demo gods weren’t smiling on us - we lost our merged slide deck overnight just before the event (Ian re-merged it just before the presentation), the main projector stopped working in the middle of one of Ian’s demos and VS crashed on him as well. Nevertheless, I think everybody was very much interested in the topics we presented and we got some very good feedback.

The other session I did was .NET 3 - The Game Challenge, and it went well. The session is really tight on time for a one hour slot, and with the bigger group of people attending it at DDD (compared to doing it for a user group, for instance) I found that with lots of questions being asked it was really hard to squeeze everything in. Still, it’s the sort of overview session that doesn’t really set out to make all attendees experts at the topic in an hour - I hope everybody will now go and have a look at WPF and WCF themselves. My sample sourced code can be found at the link above.

So, where’s DDD 6? I hope to see you all there!

Technorati tags: DDD5

In case you haven’t heard about it before, the event takes place on May 23rd at Microsoft Thames Valley Park in Reading. Rafal Lukawiecki, who was voted best TechEd speaker for 7 years running, is the headline speaker. He does two sessions, and he’s joined by other interesting speakers like Lorna Brown from Microsoft Research, Mike Taulty and Daniel Moth from Microsoft’s development and platform group, and of course the NxtGenUG guys themselves, with John, Richard and Dave responsible for the keynote and the final gameshow and swag giveaway combination. I hesitate listing myself in the “other interesting speakers” category (must be a certain modesty creaping in <g>), but I am in fact speaking at the event myself, completing the lineup.

Developer Express is sponsoring the whole thing, so I’ll be there in professional capacity as well. I hope to see some of you there - feel free to stop by for a chat or a demo of something from DX!

Here’s the link again to the page about the event, where you can register. It’s free if you’re a NxtGenUG member, otherwise it costs £59.99. I’m sure it’ll be worth it either way, for a day of interesting sessions, plus food, swag and the chance to win an XBOX 360. This event is not funded by Microsoft, so obviously there’s some cost to cover. If you have any questions to the organizers, feel free to use this email: enquiries@nxtgenug.net

Finally: Another one of Zi Makki’s fantastic geek dinners is being organized for the evening before the event. Here’s the Wiki page to sign up. Looking forward to seeing you there as well!

I did a presentation recently at the NxtGenUG in Oxford, where I introduced WPF and WCF in a combined session. I created a network enabled implementation of Connect Four to do this. Here’s the download of the demo solution, as requested by some of the attendees:

  ConnectFour.zip (30668 bytes)

If you missed my presentation in Oxford, I suggest you keep an eye on the DDD 5 agenda voting page. I submitted the same session there and as soon as their voting opens, you can vote for the same session there and come see it at DDD 5 - assuming it gets selected, of course

I have this sample from a recent talk at Basta! conference in Germany, which shows (among other things) how to bind a cross table to a DataGridView (the standard .NET 2 data grid). A cross table is basically the result of transposing some data and using one of the fields for a second dimension.

The sample I have works on two tables of data. It doesn’t actually use a database and the reference that points from the list of votes to that of features is implemented as an object reference, but the relationship is like this:

 Now, let’s assume there’s this data in the two tables/lists:

In a cross table the same data could look like this:

This is exactly the kind of transformation demonstrated in my sample. Now, there are a number of other things in that program, so don’t be confused. I suggest you focus on the workings of the VoteValuePropertyDescriptor class.

Here’s the download: FeatureVoting.zip

I don’t think I’ve blogged about this yet, other than the original announcement about the event – turns out I’m going to speak at the event as well. They haven’t published their complete agenda yet, but there’s an overview of (some of?) the sessions available, including mine. This is what my session’s going to be:

Dynamic Languages and .NET
Last year Microsoft announced their future plans for dynamic language support in the .NET CLR, and existing projects like IronPython and PowerShell provide some insight into the application of dynamic principles to the .NET environment. In theory the distinction between static and dynamic languages is clear, but in today’s programming world the lines are often blurred. Do we want to be Dynamic? Why? And what is it that Microsoft is going to do for us in that regard? The session shows practical examples and explains the status quo as well as the future plans.

I’m looking forward to seeing you there!

BASTA! was a good conference with a lot of great sessions. I did two myself – advanced functionality in the DataGridView (with some non-DataGridView specific things, like a cross table implementation based on ITypedList) and a session on ORM in real-world applications, going into some scenarios that come up when the typical SQL/ADO.NET based application architecture is converted towards ORM.

For Developer Express, we also had a great time in the exhibition, where we did lots of demos and had good discussions with users of the controls and libraries. I can report that the Wow! factor of Refactor!’s Reorder Parameters refactoring is not decreasing yet

Organization was nice as well – for the VIP reception on the first day they took us to Burg Frankenstein, where we had a great introduction about how the Frankenstein we all know relates to the history of the Burg, and then dinner along with an ongoing show of medieval folklore. Free beer on two other evenings was another goodie for everyone – they did everything to keep people happy

Thanks to everybody I met there and the people who attended my sessions!

I’ll be in Frankfurt, Germany next week for BASTA!. I’m doing two sessions there and exhibiting for Developer Express. I’m looking forward to seeing you there, and please feel free to email me if you want to meet up outside the event.