Today was the pre-conference day of the DevDays 2011. I’ve been attending the ALM track and have had some interesting insights.
Adapting SCRUM – by Rene van Osnabrugge
The first part of the day was a session by Rene van Osnabrugge. For me personally there was not much new information. It was a lot of information about SCRUM and a small bit on how to use it with TFS. Since I’m already very familiar with SCRUM, I would have liked to see some more demo’s on how to integrate this with TFS and the reports etc. that are delivered a part of the SCRUM template of Microsoft. Guess I’ll be doing that some evening when I’ve got some time left.
Improving the developer workflow – by Dennis Doomen
The second session was hosted by my colleague Dennis Doomen. Since I’ve been working quite a while together on a project with him until a year ago and soon will be joining him again on another project, most of the things he mentioned were not new to me. He pointed out some adjustments he made to the team project template (you can find that info also here). A quick look at code metrics and code analysis was also done. I do agree with one thing he mentioned about those, that you can force your team to do all these things before checking in using check-in policies, but it will result in lesser check-ins. The good thing about checking in regularly is that the amount of merging (hopefully) will be less. So I can only agree on this one to not be too strict on all the check-in-policies you set.
He also mentioned a lot of patterns he uses, which can be very helpful when developing software, but I stick to my opinion that you should also be careful in what way you use them. I’ve seen software where a lot of patterns were used, but the software was almost unreadable because of that. In most cases I will prefer not following a pattern to the letter if it makes the code more readable. Of course the abbreviations like SOLID, DRY, etc. were also mentioned .
Adopting Continuous integration – by Ewald Hofman
After the lunch break Ewald Hofman did a talk about team build and continuous integration. This was the talk I was most interested in, since I have been doing several things with team build in the 2008 edition, but I haven’t been playing with the 2010 edition much. Off course Gated checkin was one of the topics that passed by, since it was a new addition in 2010. He mentioned one important thing to keep in mind is that gated chekins can be very useful, but there is a catch. When checking in, changes are not immediately in source control, they are shelved. If you continue working on another task which touches the same file and the build fails it gets difficult to keep track of which changes were new (after the checkin) and which were from the checkin. Especially when the build takes a long time, this can get tricky, so it was good that he mentioned this. So two practices were mentioned, which are pretty logical:
- Define build ( s) for Continious Integration or Gated checkin, but make sure those builds are fast, so they should only compile your code and run fast unit tests
- Define nightly build ( s) which may take longer and which are more extensive, like running code analysis, integration tests, etc.
Another interesting part (at least in my opinion) was the part about customizing the build workflow and adding custom build activities. It was good to see that it’s pretty easy to customize the flow, since it’s WF when you’re used to the WF interface and also to add custom activities.
Agile testing with VS 2010 – by Marcel de Vries
Last but not least Marcel de Vries did a talk about testing in an agile team and how VS2010 could support this. I liked the fact that he showed a lot during demo’s so I’ve got an idea how to use the VS 2010 client for testers. I’ve seen a few things about it last year also, but I haven’t had any more time to look at it so it was a good refresher. During the talk it became clear that it’s a great tool for testers and developers, since it can support the developer in fixing bugs found by the testers. On the other hand it was clear that there are a few things that are not working as smooth as you would like it, so I’m very curious for the next version of this client for testers.
Altogether it was an interesting day. I had hoped that we were going a bit deeper into capabilities of the VS2010 ecosystem and how it can support agile teams, so I hope that if there will be another pre conference next year, that it will be more on TFS and hopefully on some new features of the vNext of Visual Studio and Team System.
I’m looking forward also to tomorrow, day 1 of the DevDays. There are some interesting topics, like Reactive extensions, jQuery and NuGet, so I hope to learn a lot tomorrow. I’ll try to write another post on my experiences of day 1.