March 31, 2010 at 23:32
filed under Events
Tagged Events, TechDays
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:
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.
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:
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 :-).
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.
This was probably the most technical and abstract sessions, but also the most interesting one. The things I want to talk about:
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:
Why? Because “add” is passed as a string and no compilation (=verification of code) that happens.
This is how it should be:
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.
When we want to pass _i, we have to specify _str, even if it’s optional.
So in stead of:
We would be able to do this:
For now, only in C#, but maybe in AX in 201? :-).
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.
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.
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”.
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.
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…) :)