Recap: TechDays 2010 Antwerp – Day One

March 31, 2010 at 23:32
filed under Events
Tagged ,

Hi everyone. Today was day one of two at TechDays 2010 in Antwerp for me, and I would like to share my thoughts.

First of, the organization of the event was good and professional, and although it was a bit crowded at times, everything went pretty smooth and relaxing.

I attended the following sessions:

  1. Developer Keynote – Trends and future directions in programming languages by Anders Hejlsberg
  2. Branching & Merging strategies with Team Foundation Server 2010 by Pieter Gheyses
  3. XNAstroids: How To develop the asteroids game in 30 minutes with the XNA framework by Timothy Vanherberghen
  4. C# 4.0 and beyond by Anders Hejlsberg
  5. ORM With ADO.NET Entity Framework in .NET 4.0 by Kurt Claeys
  6. A lap aound Visula Studio 2010 Application Lifecycle Management by Brian Keller
  7. Making TDD work using Virtual Studio 2010 by Bart Wullems

I’ll go into detail a bit, but as I didn’t take any notes during these session, I will only talk about the things that really stuck and that I found interesting.

1. Developer Keynote – Trends and future directions in programming languages by Anders Hejlsberg

In his keynote, Anders Hejlsberg talked abou the trends that he sees in programming languages and where it is all going in the future.
The things that I found interesting (and remembered :-)) the most were:

  1. Programming languages will become a mix between dynamic languages and imperative languages. This means that we will see languages that will compile certains things at compile time, while also compiling things at runtime.
  2. Because processors will have more and more cores, program languages will have to provide a way perform parallel processing in a more developer friendly than is the case now. We’ll also have to find a solution to concurrency (= running one task on multiple cores/processors)

2. Branching & Merging strategies with Team Foundation Server 2010 by Pieter Gheyses

Wow, this is interesting, and impressive. Well, maybe it might not be for .NET developers, but it is for me as an AX developer. If you don’t know what branching with TFS is, you can read about it here for starters. From what I’ve seen today, it allows you to do parallel development, and provides a proper way of maintaining release build and hotfixes on these (which can be bundled to a service pack).

That’s way better then what I was picturing when thinking about a version control system for AX, but definitely something that should be supported in future versions of AX. It’s just so much more than a version control system, that makes you wish you were a .NET developer :-).

3. XNAsteroids: How To develop the asteroids game in 30 minutes with the XNA framework by Timothy Vanherberghen

This was actually a half an hour session during the lunch break. I must say, while it was impressive to see Timothy build a game in such a short time, there was a lot of copy and pasting involved, and you probably couldn’t write this game in a half an hour when starting from scratch.

Nevertheless, XNA looks like a powerful tool for creating games, even for those who are just game enthusiasts and not ‘real’ programmers.

4. C# 4.0 and beyond by Anders Hejlsberg

This was probably the most technical and abstract sessions, but also the most interesting one. The things I want to talk about:

  1. “Dynamic” in C#
    After lecturing us about how good strongly typed languages are and such, Anders introduced the “dynamic” keyword (I keep typing Dynamics, don’t know why…). There’s a nice blog entry about it here, so I won’t try to explain myself.

    Personally, while this ‘looks cool’ and such, I think it’s stupid (there I said it :-)) and you should strongly type it. While you could argue that ‘dynamic’ is a type itself, basically all it does is tell the compiler that it shouldn’t compile the code we write when calling methods and properties of this variable.
    I’m totally against the kind of (meta) code below:

    calcobject.callfunction("add", {1, 2});

    Why? Because “add” is passed as a string and no compilation (=verification of code) that happens.
    This is how it should be:

    calcobject.add(1, 2);

    And this is how it *IS* with ‘dynamic’ variables, but it doesn’t do any good when the ‘add’ doesn’t get compiled (verified) imho.
    It’s exactly the same, it just looks better, but I’m not impressed with some new fancy syntax.

  2. Named and optional parameters
    Anyway, what I did agree with (and want in AX), are named parameters (optional parameters we already have). There are numeral articles on the web explaining this, so I wont do it here. Basically, if we had named parameters in AX, this would mean that we don’t have to specify all optional parameters that are declared before the parameter you want.
    Concider this:

    public void doSmth(str _str = "", int _i= 0)

    When we want to pass _i, we have to specify _str, even if it’s optional.
    So in stead of:

    doSmth("", 1234)

    We would be able to do this:

    public void doSmth(_i:1234)

    For now, only in C#, but maybe in AX in 201? :-).

5. ORM With ADO.NET Entity Framework in .NET 4.0 by Kurt Claeys

Well, I haven’t really become a fan of ADO.NET EF during this session, so I will be brief about this. I would conciser using this for small applications that I know wont have a significant load on the sql side, but for big applications, I think the framework will just be to slow. You probably could optimize by writing stored procedures, but that’s a bridge to far for me.

Also, on principle, I’m against ADO, as in AX (at least by default) it only runs on client side, and not on server.

6. A lap around Visual Studio 2010 Application Lifecycle Management by Brian Keller

This session was partially about branching with TFS that was also covered in the session by Pieter Gheyses, but zoomed out a bit to the lifecycle level. This session confirmed how brilliant the TFS solution is. I was also impressed with the interaction between these applications and the office suite, sharepoint, etc.

7. Making TDD work using Virtual Studio 2010 by Bart Wullems

I thought this was an interesting sessions, as it made me think about methodologies like TTD (Test driven design), but also SCRUM, etc. I believe that you shouldn’t be to fanatic about what methodology to use, because these methodologies only really define the “how”. How what? How to implement certain design/programming principles and best practices.

I think it is more important to understand the ‘why’ of these principles exists, so you really understand why you are doing things the way you do them. Everyone can do things as there told (how), but only the best understand it (why). When you understand the basic principles and patterns, you can benifit from them always, no matter what methodology you are using.

The weak point of TDD is that you can’t use it in all circumstances. In some cases, you can’t write unit tests so you can use TDD. One benefit is that it helps you understand principles and patterns better (like encapsulation). Or as Bart says it: “You get all of that for free”.

Part 2: Recap: TechDays 2010 Antwerp – Day Two

2 comments

RSS / trackback

  1. Jeroen Doens

    on April 2, 2010 at 07:25

    Did you take the session ‘Software Testing with Microsoft Visual Studio 2010’? This was a really interesting one with a lot of examples.

  2. Klaas Deforche

    on April 2, 2010 at 16:08

    Hi Jeroen,
    I didn’t attend the session on software testing with VS.NET as I already did the Test Driven Design session.
    I’m looking forward to talking to you about that, or reading about it on you blog (hint…) :)

respond