Recent posts








    The opinions expressed herein are my own personal opinions and do not represent my employer's view in anyway.

    Visual Studio Launch Roadshows and Workshops in the Netherlands


    Get teams up to speed with the new Visual Studio 2012 Application Lifecycle Management tools with free roadshows from Sogeti for customers.

    imageSogeti has been involved with the Visual Studio 2012 release from the first early stages till the launch 12 September. Two and a half year ago Sogeti joined the Visual Studio 2012 Strategic Design Review (SDR) and was enabled to use Team Foundation Service as one of the first companies. This early involvement together with the Visual Studio 2012 Technical Adoption Program (TAP) result in a deep knowledge of the Visual Studio 2012 capabilities, usages practices and adoption strategies at the moment of release. Sogeti will be part and on stage of the international launch in Seattle.

    This knowledge we want to share with your teams. We offer a variety of free roadshows delivered by Sogeti’s Microsoft Most Valuable Professional (MVP) ‘Clemens Reijnen’ and a team of subject matter experts.

    The roadshows will be delivered on location at a time that suites the team. The session will take between one and two hours, depending on the available time. There can be selected from four different topics.


    What’s new in Visual Studio 2012.image
    An overview of the new capabilities for team members. It covers topics like Product Backlog / Task Board, My Work, Local workspaces, Code Review, Code Comparison, Rollback, etc.


    Team Foundation Server Agile Planning Tools.image
    An in-depth session about agile software development with Team Foundation Server. It covers topics like Teams / Product Backlog / Kanban Board / Scrum Board / Bug backlog / Master Child Backlogs.


    Agile Testing with Visual Studio 2012. image
    This session focusses on areas and activities to achieve good quality. Topics like Backlog, Storyboarding, Task board, Exploratory Testing, Feedback, Unit Testing & Fakes.


    Building Windows 8 Store Applications.image
    Develop Windows 8 store applications by using Visual Studio 2012 templates and how to enable Windows 8 features in your applications like search everywhere.


    Select you’re location, you’re time and the topics and we will deliver a knowledge sharing session. Contact your account manager to make reservation.

    Hands-on Workshops

    Beside these ‘on location’ roadshows we also organize three evening workshops on Sogeti location covering the same topics. During the workshops attendees will be enabled to try the scenario’s them self. All attendees will get an Azure Virtual machine pre-configured with Visual Studio 2012 Ultimate and connected to Team Foundation Service. A team of Sogeti subject matter experts will guide them. A perfect way to feel the value of Visual Studio 2012 Application Lifecycle Management tools for team development.

    Attendees should bring their own laptop with remote desktop enabled.
    Depending on availability a maximum per company can be set.

    Select the date and topics at www.Sogeti.nl or call your account manager.

    Developer Tools Deployment Planning Services

    Sogeti delivers Developer Tools Deployment Planning Services (DTDPS), a 3 to 5 days service based on Microsoft Software Assurance benefits, designed to help organizations plan effective Visual Studio deployments. Ask your local Microsoft contact for details.



    Posted: Sep 22 2012, 01:46 by ClemensReijnen | Comments (1) RSS comment feed |
    Filed under: ALM | Sogeti | VS2012 | win8

    Visual Studio 2012 Launch | Sogeti

    It was great to be part of the Visual Studio 2012 launch. (picture below taken from my Edgewater hotel room, with on the left side a view on the event location)

    photo (3)

    A lot happened the past weeks, video recordings, interviews, photo shoots and a trip to Seattle the launch event. Below some pictures and links to launch resources.




    The Sogeti Launch video (shown between keynote 2 and 3).


    Here you can watch the ‘Modern Apps’ panel discussion and keynotes. (link)

    13-9-2012 16-22-26


    On this blog post you can read the Sogeti VS2012 written case study.



    Summer 2010 during the onsite strategic design review in Redmond the first dev11 ideas where discussed. great to see how it evolved.




    We’re running several vs2012 launch events (and hands-on workshops) around the globe, keep watching this blog for updates, where to attend and signup. 

    Sogeti Visual Studio 2012 case study

    See below the written case study bout our early adoption work for Visual Studio 2012, Improved Application Lifecycle Management Tools Help IT Firm Speed Development.



    The case study is also available on Microsoft.com.



    And this is the, still relevant, 2012 case study.


    September 18 IASA Netherlands Meeting


    Third Tuesday in September is always a special event in The Netherlands. This time especially so since it will host the third Meetup for this year of IASA NL this time at ASML in Veldhoven. We think we have an interesting program with interesting speakers. We hope you will join us!

    Agenda for September 18:

    • 16.00 - ontvangst met koffie
    • 16.15 - welcome, IASA update
    • 16.30 - Viktor Grgic - Agile Architecting, doing more with less
    • 17:45 - Buffet
    • 18:30 - ASML architecture presentation, topic yet to be announced
    • 19:30 - Fishbowl/Open Space
    • 20:30 - Closing and drinks
    • 21:00 – End

    Aanmelden bij Meetup:

    Meetup logo

    Posted: Sep 01 2012, 06:42 by ClemensReijnen | Comments (0) RSS comment feed |
    Filed under: IASA

    Sogeti Labs introduction Video

    An introduction to SogetiLabs telling the story about this initiative connecting our technology leaders to the world.


    MTM Coded UI Test automation investment, when to use what.

    All validation (test) activities cost money. So, every activity to test a system should be executed as efficient as possible (see also the ‘testing in sprint’ series on this blog). Adding automation to the execution of these validation saves execution time, which saves money. But, specifying, creating and maintaining these automation cost money. So, the hard question is where is the balance, where the break-even point of test automation.

    Not that easy to answer question but lets give it a try. All quadrants in the ‘Agile Testing quadrant’ have some kind of Visual Studio tool support (No automation with out tool support).


    For the technology focused tests, the ROI of test automation is a kind of clear. Developers create unit tests conform a specific code coverage level, proven the implementation is still correct, which give the team some comfort and quality level. For the load tests its of no discussion that there is a ROI.

    But, when we look at the ‘top - business facing’ tests, ROI of test automation is a bigger challenge. We have to think of how long is the validation member of our project (for example not all functional tests aren’t executed every sprint, only a sub set, only the most important, see this post ‘only meaningful tests’) and how many times is the validation executed (how many times over time but also on different environments). This gives us indications how much effort we must put in our test automation.

    Basic there are three test automation levels:

    1. No Automation
    2. Record and Playback
    3. Test Scripts

    Visual Studio adds two other levels to it.image
    (slide from the testing roadshow)

    All these automation levels have an invest, and a maintainability level. The better you can maintain a test case the longer you can use it for you ever evolving software system. That is the connection between ‘how long’ and ‘how well maintainable’, another connection is the effort it takes to create the automation. the resulting benefit is, you can execute your script over and over again.

    The ideal situation: a test script with very small investment to create, for a test which needs to be executed the whole life of the application which doesn’t change overtime. No investment, no maintainability issues, maximum amount of executions. Result:  maximum ROI.

    Too bad, we’re not living in the ideal world. So some tradeoffs need to make. 

    image No automation.

    No need for maintainable test scripts, no automation investment. I have customers who use MTM for Test Case Management only, and they are happy with it. maintaining thousands of test cases and their execution gathering information about the test coverage of the implemented functionality.  

    In most situations, this is an ideal starting point for adopting MTM and starting to look at test case automation. As a test organization getting used to the benefit of integrated tools the support of different ALM scenario's.

    image Shared Steps with Action Recording | Record Playback parts.

    Collecting an action recording takes some effort. You have to think upfront what you want to do, and often you have to execute the test case several times to get a nice and clean action recording. So there is some investment to create an action recording which you can reuse over and over again. 
    You can’t maintain an action recording. When a application under tests changes or when the test cases changes you have to record every steps again. A fragile solution for automation.
    Using Shared Steps (reusable test steps) with their own action recording solves this a bit.
    Find the test steps which appear in every test case, make a shared step of these steps and add an action recording to it. Optimize this action recoding and reuse the shared step in every test case. This definitely improves the ROI. Now you can fast forward all the boring steps and focus on the real test.

    The good thing, when a shared steps changes, you only have to record that one again.

    Creating multiple shared steps with action recoding and compose a test case is also a good scenario.

    After the zero investment, this is a good next step. You get used to the behavior of action recordings and have the benefit of reusing them throughout the project.
    Action recordings of shared steps keep their value the whole project, there is some effort to create and maintain them but you will execute them for every test case, a good ROI.

    image Test Cases with Action Recordings | Full Test Case Record Playback.

    The same activity as for the Shared Steps action recordings. But, you will use the action recording less and it is harder to maintain (more test steps). So defiantly the ROI is much lower as in the Shared Steps situation.

    The scenario where you create the action recording and execute often, for example on many different environment will bring some benefits. MTM action recordings can be recorded on one environment and playback on another environment.

    Another reason you might want to go with this scenario, is that you want to reuse the action recording for test script generation. See next step.
    image Generate test script from action recording.

    A really nice scenario for quickly creating test automation scripts.
    See this video for a quick how to:

    The maintainability of the generated code is hard. There are some tools in place to react on UI changes, which make it easier. Also challenging are some common development practices like branching, merging and versioning of the test script. See this presentation

    Conclusion, the creation of test scripts generated from action recordings is really fast but hard to maintain. This together with the recording of the action recording (number 2) has its influences on the investment. 
    image Write your own Test Script ( by using the Coded UI Framework ).

    Write the test automation script your self, following all the good coding principles of maintainability and reusability.  like: Separation of concerns, KISS principle, Don't repeat yourself, etcetera.

    Code First API Library is a good starting point.

    This automation scenario is completely opposite of the generated test script (3). This one is hard to create, it will take some effort, but is (if implemented well) very maintainable. and you can follow all the coding practices and versioning strategies. 

    So, MTM with Coded UI support different test automation scenario’s. From fast creation with hard maintainability (2 and 3) to hard to create with good maintainability (4). It is a good to think up front about test automation before random start using the tools.

    My rules of thumb are:

    • Use 2 and 3 in a sprint and maybe in a release timeframe, but not longer. Maintainability will ruin the investment.
    • Use 4 for system lifetime tests.
      They run as long as the system code runs and should be treated and have the same quality as that code. Don’t use it for tests you only run in a sprint, the effort will be to big.
    • Use 0 and 1 always when ever you can. it supports several ALM scenario’s and the shared steps action recording really is a good test record-playback support with some good ROI.

    After a small investigation on a test tool conference I made the conclusion that no tool which supports test script generation (or something similar) all have some kind of workaround to make it maintainable. Only a good test automation framework (for example the Coded UI Framework or Selenium )will make test automation (I’m still talking about business facing tests) code maintainable. Test script generation is nice but you don’t want to maintain it. 

    Het Test Tool Event



    11. Getting Testing Done in the Sprint - The Customer Test Team

    I don’t mean the acceptance test team, although many think and organize it as if it is the same.

    On a test conference a few weeks ago I heard the story of moving testing out of the sprint, or adding a specific test sprint after a development sprint. Both ‘worksrrounds’ I dislike, you lose the flexibility and feedback loop. It was something like the ‘IndependentParallelTesting’ story, also not my favorite solution.

    During the conference I posted a tweet, and got replies from Sander and Marcel. Lucky me I’m not alone Emoticon met brede lach (I like the last comment from Sander, the process just should support and embrace it, see: http://www.smartusecase.com.)



    The most clear characteristic of the customer test team is that they aren’t part of the scrum team. You could call them early adopters, power users or the customer test team. Often they execute real life scenario’s, play around in the application or when they are early adopters they do some real work with it.

    Beside the question, “do we really need them” is the challenge with these disconnected test teams is, how to get them and their information in a sprint. Threat them as operational findings is a way. But doesn’t solve the challenge of getting their usages data, their findings and reports back on our backlog and in a sprint.

    A nice explanation can be found in this video from ‘Groeten uit Delft’ where Rob van Lanen (www.agilestudio.nl) explains how they work together with operations.


    Beside the solution of giving the ‘disconnected’ customer test team a copy of Microsoft Test Manager 2012 and let them execute their test cases in a ‘structured’ exploratory way. http://msdn.microsoft.com/en-us/library/hh191621(v=vs.110).aspx
    Microsoft Test Manager - start exploratory test

    A nice work around to get the findings and knowledge from the customer test team in your teams project, is create a separate backlog for them (read this old post – will update it soon).

    Two other interesting technologies which can help teams with this scenario (findings found outside the team) are:

    1. PreEmptive Analytics for TFS.
      PreEmptive Analytics for TFS CE offers a free, lightweight way to integrate feedback-driven development processes into your development workflow. Your applications will automatically send back exception report data to your PreEmptive Analytics endpoint service as errors occur during their execution

    2. Collecting IntelliTrace Data Everywhere
      The collector saves IntelliTrace data as a recording that contains details about exceptions, threads, Web requests, modules, and other system information that is collected while your application runs. In most sections of the recording, you can select one of these items and start debugging with IntelliTrace in Visual Studio Ultimate.


    Past Tips:
    01. Getting Testing Done in the Sprint - The Team and Activities
    02. Getting Testing Done in the Sprint – Regression Test Sets
    03. Getting Testing Done in the Sprint – Test Automation
    04. Getting Testing Done in the Sprint – Undone Backlog Item
    05. Getting Testing Done in the Sprint – No Double, Triple Testing
    06. Getting Testing Done in the Sprint – PBI Implementation Sequence
    07. Getting Testing Done in the Sprint – Risk and Business driven Tests
    08. Getting Testing Done in the Sprint – Write Logical Acceptance Tests
    09. Getting Testing Done in the Sprint – Test Tasks on the Board
    10. Getting Testing Done in the Sprint – the Definition of Done

    Next Tips:
    12. Getting Testing Done in the Sprint – The Test Branch


    Posted: Jul 10 2012, 08:02 by ClemensReijnen | Comments (3) RSS comment feed |
    Filed under: ALM | Agile | VS2012

    Sogeti Windows 8 Metro Application Demo

    cross post from: Darren W Baker

    This video is a compilation of Windows 8 Metro Applications that Sogeti consultants are working on world wide. Sogeti was asked to put together a small video to be played at WPC 2012 during one of the Keynotes, and we are all very excited to see our hard work on the big screen.<<read more>>

    Posted: Jul 07 2012, 02:20 by ClemensReijnen | Comments (1) RSS comment feed |
    Filed under: Sogeti | win8

    Test Automation Day Deck - Agile ALM - Getting testing done in a sprint

    Below my http://www.testautomationday.com/ presentation (demo’s will follow next week on my YouTube channel).

    Agile teams find it hard to get the testing effort in sync with the other development activities. Not only development tests are executed during sprints, all other kind of testing activities are part of done. This session will give guidance how Microsoft Visual Studio ALM tools can support agile teams. How to run sprints and get testing done in a sprint.