Recent posts








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

    DevOps technical meeting video: Ent DevOps | Cloud Teams | Dutch harbour case | Docker containers for DevOps

    Live streamed on 16 Oct.. 2014

    Welcome to the Live stream of our DevOps technical meeting!

    Program is as follows:
    18.00-18.45u Introduction & Enterprise DevOps (Dave van Herpen, Sogeti NL)
    18.45-19.30u Cloud Team, OneShare (Clemens Reijnen, Patriek van Dorp, Sogeti NL)
    19.45-20.30u DevOps collaboration in the Dutch harbour (Peter Siepel, Schuberg Philis/Loodswezen)
    20.30-21.00u Use of Docker containers for DevOps practices (Benoît Wilcox, Laurent Guerin, Sogeti France, via webcast)

    3 Challenges when Testing from and on the Cloud.

    When adopting the Cloud for your test work it comes with several challenges. Looking at the different usages flavors of the cloud for teams, read: Cloud usage flavors for Development and Test teams, then every flavors has its own challenges.

    Challenge 1: Team Workspace in the Cloud – Test Environment On Premise.


    The scenario is that the team adopted Team Member Workspace on Azure, but the infrastructure (test environments) are staying on-premise.

    The planning, preparation, specification and execution of the test work takes place on the team member workstation which is hosted in the Cloud.

    The challenges is that the execution of test are triggered from the public cloud and the test runs on the private data center. There needs to be a connection between the team member workstation and the test environment. The same counts for automatic test runs.

    Solution: make a network connection between Azure and the On-Premise datacenter. Often a very long discussion with the internal infrastructure people is needed to get this working.

    You can create a Site-to-Site VPN, for connecting datacenters to an Azure site or Point-to-Site VPN, when connecting a single machine to an Azure site.



    Challenge 2: Acceptance Test Infrastructure in the Cloud – Production On Premise.


    the scenario, all environments (development and test) are on Azure except production, this one still lives on-premise. The challenges is to get the test and acceptance (on Azure) environments as equal as possible to the production (on prem) environment.

    Solution: The best solution is the usages of the same installation scripts for production as for acceptance and test. Make PowerShell DSC scripts for and re-use them for every environment.

    there is also a need for stubs to make testers need to focus on writing isolated tests, which will make more systems valid. Still not all tests can run on Azure Test Infrastructure (performance and load tests won’t give valid results).

    the worst case scenario is that an additional pre-production environment needs to be created on-premise for tests which couldn’t be validate in the cloud.

    see: http://blogs.technet.com/b/privatecloud/archive/2013/08/30/introducing-powershell-desired-state-configuration-dsc.aspximage


    Challenge 3: ALM Infrastructure in the Cloud – test, acceptance and production on- premise


    The scenario: The team consumes their ALM infrastructure from the Cloud and use on premise workstations.

    Actually from a technical perspective there isn’t a challenge in this scenario. The only need is reliable https connection between the Test case repository (ALM Infrastructure ) and the test environments.

    Interesting in this scenario can be the test data. There is probably a security reason why the environments (test, acc and prod) are in the local datacenter. When the test cases, test data and test results are stored on Azure, the security regulations probably also count for that data.

    Often production data is used as test data resulting in a no go for this scenario. A solution is to anonemize the test data.


    these where just three challenges for the three different components of Cloud usages for Dev and Test on Azure.

    There are many more challenges, maybe in another post.

    Posted: Oct 15 2014, 02:38 by ClemensReijnen | Comments (8) RSS comment feed |
    Filed under: ALM | Azure | Cloud

    Cloud usage flavors for Development and Test teams.

    The cloud for teams have many forms.

    Teams can simply use a virtual machine on Azure to work from, the team member workspace flavor as I call it.


    Or, they can use the bug tracking database, requirements management, and scrum board from the Cloud. In either a SaaS way, like Visual Studio Online (www.VisualStudio.com) or as an IaaS solution (see Practical guidance for TFVC and TFS on Azure IaaS). Both are the ALM infrastructure in the cloud flavor of Cloud usages by teams.


    Another way teams can use the Cloud for their work is that they use it for their Development and Test Infrastructures. For example, when you develop a system for an On-Premise SharePoint farm team members need to have a SharePoint Farm. Developers need the infrastructure for development, debugging and integration, testers for sure to run tests for the system in development. It is the Development and Test Environments flavor.


    When adopting the cloud for your Development and Test work, all three flavors are interesting to look at. You can consume them separately but when using all together you are really riding the cloud wave.

    Visual Studio Online Rest API introduction and sample on GitHub.

    Visual Studio Online opens its chest with APIs, with this creating an open platform for managing team work and collaboration. An open Application Lifecycle Management platform, for everybody to use, consume and integrate.

    Not only Rest APIs for project artifacts are available, also a notification mechanism via Service Hooks is.

    In this post an overview of the Rest APIs supported by examples and a solution, in the next one an introduction to Service Hooks.

    You can get the source over here on GitHub VSOTeams-Universal-App

    (this small project I created when we moved to Azure AD to get all our VSO users in an Excel file, with license information and mail to add them in bulk to Azure AD. Not complete and a lot of room for improvement. Below a detailed description of the scenario and video)

    Introduction Visual Studio Online Rest API’s

    Visual Studio Online Rest APIs lets you build functionality on top of Visual Studio Online with simple HTTP methods in JSON format. This makes the Visual Studio Online Rest APIs (VSO APIs) an ideal extensibility capability for Mobile and Web Apps.

    The VSO APIs opens up the Visual Studio Online SaaS platform. The Visual Studio Online platform provides functionality for teams like; Agile planning, TFS / GIT version control, test management, bug tracking, team collaboration, build management and more. All these capabilities are accessible via the VSO APIs to leverage applications or integrate with third-party ALM vendor tools.

    Getting started with Visual Studio Online Rest APIs.

    The only prerequisite needed to start building on top of the Visual Studio Online platform is a Visual Studio Online account. A free Visual Studio Online account can easily be created via www.VisualStudio.com with a Microsoft Account.


    Visual Studio Online API organization

    The VSO APIs can be grouped in three levels, with different URL formats.

    Personal Level.

    To get information about your profile as known in VSO and the VSO accounts your account has. The URL format of these calls start with:


    For example to get your profile from VSO the request will be:

    https://app.vssps.visualstudio.com/_apis/profile/profiles/me which gives a JSON response with the current signed in User.


    "displayName": "Clemens Reijnen",

    "publicAlias": "4b128a7c-0e4d-4a75-b36e-1f2151220asdad",

    "emailAddress": "clemens.reijnen@sogeti.nl",

    "coreRevision": 79,

    "timeStamp": "2014-05-05T10:50:49.77+00:00",

    "id": "4b128a7c-0e4d-4a75-b36e-1f2151220asdad",

    "revision": 1613


    For accounts of the current users the URL will look like this:


    Account level.

    VSO APIs on the account level provide information about users and licenses in the account.

    https:// {account}.vssps.visualstudio.com/_apis/…/…

    To get all users in a Visual Studio Online account with corresponding licenses you create a responds like:


    Project collection level.

    The project level APIs are most interesting for leveraging VSO functionality in Apps. These APIs provide information and actions on:

    - Work Item tracking,

    - Builds,

    - GIT,

    - Version Control,

    - Test Management,

    - Team rooms.

    Project collection level APIs have the format of:

    For example a request to get all projects in a project collection can be captured with request like:


    Which give a JSON array response with all projects in the DefaultCollection.

    "value": [


    "id": "810f92d5-cbb2-41e8-9390-08f1fc5c123",

    "name": "WIN8 Store App Development",

    "url": "https://sogeti.visualstudio.com/DefaultCollection/_apis/projects/810f92d5-cbb2-41e8-9390-08f1fc5c123",



    "id": "d62d8b1e-06b9-4132-bb09-c3b45123",

    "name": "DefaultCollection",

    "url": "https://sogeti.visualstudio.com/_apis/projectCollections/d62d8b1e-06b9-4132-bb09-c3b453",

    "collectionUrl": "https://sogeti.visualstudio.com/DefaultCollection"




    "id": "6c831d9a-f061-4bee-bd85-13c4f53d8",

    "name": "WIN8 Store App Development Team",

    "url": "https://sogeti.visualstudio.com/DefaultCollection/_apis/projects/810f92d5-cbb2-41e8-9390-0234fc5cb90d/teams/6c831d9a-f061-4bee-bd85-4f525f3d8"




    VSO Rest APIs URL property.

    The URL property found in most JSON responses gives an easy access to the underlying properties of the requested project artifact.

    For example in the JSON response of the above Projects request you will recognize the URL properties with the already populated Request URL for more details.

    For example to get from the projects array JSON responds to detailed project team information you can use the URL references.


    Note: I’m using Chrome with a JSON formatter app installed, for getting the nice readable JSON responds.

    HTTP Verbs.

    Beside the GET HTTP verb are the others, POST, PATCH and DELETE .

    With POST you can create resource as Work Items and Team Rooms.

    First get a list with Rooms, to get the RoomId.


    And then POST a message to the room with the RoomId


    and the message you want to post:


    "content": "New messages"


    PATCH can be used to update a resource and DELETE for deleting resources.


    While getting the responses in the above example doesn’t require any specific authentication mechanisms, you’re already logged on in Visual Studio Online via the browser. But, when you want to call the VSO APIs from outside the browser you need enable your secondary credentials to make us of Basic Authentication.

    Enabling your secondary credentials can easily be done from within Visual Studio Online via your “My profile”.


    Once enabled Apps can make use of these credentials to request information from the VSO APIs.

    One attention point on the usage of the Basic Authentication credentials, beside that it isn’t the most secure way, when using an automated system to request information you can run in to a block from Visual Studio Online.



    Visual Studio Online also provides a more easier, end user friendly and more secure way of consuming its API’s via OAuth. See http://www.visualstudio.com/en-us/integrate/get-started/get-started-auth-oauth2-vsi 

    Visaul Studio Online authorization page with your company and app information

    Use Visual Studio Online Rest API’s in a Universal Windows App.

    The Visual Studio Online Rest APIs are ideal for mobile apps to extend its capabilities. Scenario’s where Team members want to take a quick look at the team activity of the past day they want to see the latest build results and details, change set. The scenarios for mobile are unlimited.


    For sources used in this example application see: GitHub You can get the source over here on GitHub https://github.com/Clemensreijnen/VSOTeams-Universal-App 

    The example App scenario.

    The example solution is a Universal Windows App which displays the projects in a Visual Studio Online account with the Teams in these projects. For a Team the solution shows its team members and team room messages. For sure the solution also has the capability to post messages to the team room.


    For the team members the solution shows their person details with Visual Studio license, and teams they are member of.

    A video says more than thousand mocks… YouTube: VSO Teams

    VSO Teams

    The Rest APIs necessary are:

    - Get logged in user identity
    https://app.vssps.visualstudio.com/_apis/Profile/profiles/me this results in the JSON respond with the UserID, which is needed for the next call.

    - Get logged in user accounts
    when multiple accounts are return a selection needs to be made in the settings, this setting is used in the call to get all projects.

    - Get all projects in account

    - Get teams per project
    https:// {account}.visualstudio.com/DefaultCollection/_apis/projects/{ProjectID}/teams
    probably multiple projects are returned, so a iteration to the projects collection is needed to get all the Teams.

    - Get activities in team room
    Per Team Room the messages are captured. All the other calls are more stable, they don’t change that often, this one will be called multiple times to get new messages. A filter can be added to this call in the form of timespan.

    - Post activity in team room
    https://{account}.VisualStudio.com/DefaultCollection/_apis/chat/rooms/{roomId}/messages with the message.

    For the users screen a list of all account users with licenses is needed and user details.

    - Get All VSO Users
    https:// {account}.vssps.visualstudio.com/_apis/Licensing/Entitlement

    - Get user details, this one is a bit complex because we only can get the details from team members, so we need to iterate all teams to get a collection of team members.


    - And finally we get all account pictures.

    Very straight forward. But before we can move forward we need to create the project and authenticate the user in the App for Visual Studio Online (with secondary credentials).

    The Universal App.

    The universal app needs a bit different approach as when you’re building separate Apps for the different Windows platforms. Lucky it gets easier.



    Basic Authentication can be implemented with the “Windows.Web.Http” API as shown in the below.


    Basic Authentication is very straight forward, the HTTPClient from Windows.Web.Http can be used for asynchronous operations for various types of content to a HTTP server.

    Call VSO Rest API for projects

    With the authentication in place a call can be made to the VSO Rest API for projects. The asynchronous method “GetAsync” is used. After ensuring that there is a success (200) callback, the response is read in a string and de-serialized to a projects collection.


    The JsonConvert method is used from Newtonsoft JSON. The Project collection is an Observable Collection with Observable objects of the type project.


    The property name value is extracted from the returned JSON string. Where collections in VSO Rest API responses come with a JSON array {"value": [ … ]}

    Pretty easy to use is http://json2csharp.com/ to convert the JSON to C3 objects, although we finally we still have to make the objects observable.

    With the collection of Projects in place we now can bind them to the screens in XAML. But, first the JSON is saved in local storage. Because the projects don’t change that often, not every minute a project is added to VSO accounts, we can make starting up the project faster and we have offline capabilities.

    Now all project are loaded in the Windows 8.1 Store App


    And the Windows 8 Phone App (still some XAML work to do)


    We can repeat this for all the GET operation needed to get the proper information, except for the profile images. For the profile images not a string responds is captured but a buffer is written in a stream to get the image file.


    Also this method saves the images local, you defiantly don’t want to do this every time you load the App.

    See for more detailed implementation the Sources of this Universal App on Codeplex.

    Wrapping Up.

    Using the Visual Studio Online Rest APIs is very straight forward and easy. For the mobile apps scenario, having the data offline is defiantly a must, especially when you are loading lots of content from VSO like this example. Updating content in the Apps with Service Hooks is a very interesting scenario, which will be explained in the next post.

    But not only Mobile is the target platform for the VSO Rest APIs also web solutions can be enriched with VSO functionality or integration with SharePoint and Office 365 are interesting platforms. See the image below, where build information, team activities and member licenses are integrated in an O365 team portal. See this post:Integrate Azure, Visual Studio Online and Office 365 with VSO Rest APIs. 


    Posted: Oct 09 2014, 05:24 by ClemensReijnen | Comments (71) RSS comment feed |
    Filed under:

    Add an existing Office 365 Azure Active Directory to your Azure Subscription.

    Managing your Office 365 users via the Azure management portal works great. (http://msdn.microsoft.com/en-us/library/azure/hh967632.aspx)


    Also connecting applications (web or native) to the Azure Active Directory is perfect for the sign-on experience of the user.



    So, you want to add your existing Office 365 Azure Active Directory to your Azure Subscription. It is ‘add’ because the underlying directory for Office 365 is already an Azure Active Directory. This means that you only can add this directory to your Azure Subscription.

    While most samples / explanations let you create either a new Azure Subscription or Office 365 account.

    all very useful posts , but I wanted to use an existing Azure subscription and an existing Office 365 account. it is fairly simple.


    Be a global administrator in the Office 365 account. This will be done with your organizational ID, the onmicrosoft.com address.



    Log in to your Azure Subscription, with your Microsoft ID.

    Adding the organizational ID as co-administrator won’t work, it must be a a Microsoft account or … a user in a known Azure Active Directory. In the screenshot below I ‘m already connected to the Sogeti Azure AD, but I want to connect the ClemensReijnen Azure AD.

    just move on, forget adding a co-admin.





    This will open the dialog to add an existing Azure AD.


    Selecting the “Use existing directory” asks you if you are already signed in.


    So, don’t have different browsers open and be signed in on one for O365 and one for Azure, or have a private view open… (as I always have with that many accounts to manage)


    Just signed in the same browser on different tabs once in the Azure Management portal with your Microsoft ID and in Office 365 with your organizational ID.

    When you’re signed in to your existing Office 365 account, select OK and you will be redirected to your Office 365 account asking (sorry the screenshot is in Dutch, I accidently selected Dutch when I created the Office 365 account) if you want to map with Azure.


    And now the magic had happens, your Office 365 Azure Active Directory is available in you Azure portal.


    The process added the Microsoft Account which I use to sign in to the Azure portal as a User in the add, actually as a global admin.


    In both environments the users are now available.



    Fairly easy for so much power Glimlach

    Posted: Jul 11 2014, 02:38 by ClemensReijnen | Comments (5) RSS comment feed |
    Filed under: Azure

    Visual Studio Online Team Rooms on WP8, iPhone and Android with Xamarin Forms.

    A small  (Monday evening now, so a bit extended) weekend project, due to the contest announcement from Xamarin.

    A Xamarin 3 Forms project for Visual Studio Online Teams. Stay up to date what happens in your project with build runs, code changes, work item changes and chat with you team members. Available on three mobile platforms, iPhone, Windows Phone 8 and Android.

    You can get the source over here on GitHub VSOTeamsX


    imageThe solution is build on top of the Scott Hanselman example,  together with some examples from Xamarin.

    All logic is in the Shared Project and in the following Nuget packages:

    Microsoft HTTP Client Libraries, http://blogs.msdn.com/b/bclteam/p/httpclient.aspx (for the connectivity)

    PCL Storage, http://pclstorage.codeplex.com/ (for saving the profile images and settings in the App).

    There is still a lot of room for improvement, but I’m pretty happy with it for a weekend project. Would be cool to add notifications.

    Feel free to take a look at the sources and use it for your own solution.



    A small explanation.

    First you have to enable your secondary Visual Studio Online credentials and save them in the App.



    The App shows all your Project in Visual Studio Online and you corresponding team members.



    (on the list for email and phone integration).

    Next all team rooms are shown with messages, events and event details.



    you can also publish messages to the room.


    This is a small video from the windows Phone version:


    This all also works on an Android 


    and iPhone…
    (the text overrun is solved now)

    iOS Simulator Screen shot 16 Jun 2014 13.43.08iOS Simulator Screen shot 16 Jun 2014 13.42.14iOS Simulator Screen shot 16 Jun 2014 13.43.37


    Happy to have one code base for functionality and the UI, but we’re entering an images hell.

    Integrate Azure, Visual Studio Online and Office 365 with VSO Rest APIs.

    With the just released Visual Studio Online Rest APIs you can do some wonderful things.

    For example:
    We create a solution to support project teams who use Azure for their development and test activities. Teams who use Visual Studio Online for their ALM infrastructure and Azure VMs for their Development and Test environments (as most Sogeti Teams do :-).clip_image001

    The challenges when running heavy cloud based teams like this, is that you want to let them use the Azure and Visual Studio Online resources as efficient as possible. Give them easy to use features to create Development and Test Environments is key. But, also too often VMs keep running for weeks, while no test runs or any code change / team activity has happen. And from a few days ago, Visual Studio Online licenses you want to monitor unused licenses.

    Teams should stay Fast and Flexible, and must have insight in what they do, to be efficient. Via this portal we give Teams insight and tools to use the Azure and VSO resources as efficient as possible.

    The portal gives information about VSO Licenses used, build and test runs, Azure IaaS state and overall Azure costs, everything that costs money when running your project.

    This all works in a SharePoint O365 Provider Hosted App, with Microsoft Azure Management Libraries and the Visual Studio Online Rest APIs consumed via a WebAPI, all hosted on Azure Cloud Services and secured by Windows Azure Active Directory.


    Teams get information like:

    Azure Development and Test Environments usages.
    Beside Azure VM’s state, start, stop and RDP connect there is also the capability to add usage notifications and a schedule rule engine to the VMs. So team members are notified when a VM is unnecessary on. Mobile apps receive the notifications and have the ability to stop the VM.


    Build usages and history.
    For teams to see the build usages and to get an indication if build environments are proper used.


    Team licenses.
    Visual Studio Online License information of all the team members.


    and Team activities.


    And as last and Overall Azure subscription costs.
    Every project has its own VSO Account and Azure Subscription (in the Azure Enterprise Subscription). In this subscription they maintain the VSO licenses and their Development and Test Azure VMs. This give the team control over what they need (add licenses and developer machines when they need) and insight in the true costs of the project. We upload the terrible excel output from the Enterprise Azure Portal to an Azure SQL database.


    All in Office 365 in a single project portal to enable Fast and Flexible Teams. VSO Rest APIs Rock … Glimlach

    related info:

    The missing knowledge of testers in modern app development.

    The game has changed for testers, they need to extend their basic testing skills when they want to stay valuable. As other team members, testers need to be a full member of the team with the current skill set this isn’t.

    While supporting teams for a long time in delivering software I noticed I’m always teaching new ‘test’ team members the same skills. Skills a new team member actually already should have had before entering the team room.

    A small list.


    Agile knowledge.

    Knowledge about agile work in teams is the minimal a test team member should have.

    When they fail a basic assessment like the Scrum.org open assessment ( https://www.scrum.org/Assessments/Open-Assessments/Scrum-Open-Assessment ) I silently start to cry.


    Agile is that mainstream now a days that I even wonder why conferences like ‘The Agile Testingdays’ exists. The practice of agile test work should be crystal clear at this moment. So, mastering agile work is really the bear minimum.


    Team Tools support.

    Know your tools. Not only the common testing tool ‘Excel’ but more important the Application Lifecycle Management (ALM) tools the team uses.

    ALM Tools like Visual Studio Online and other tools mentioned in the Gartner ALM report are important.


    Magic Quadrant for Integrated Software Quality Suites


    Gartner’s Magic Quadrant for Application Lifecycle Management

    The tester isn’t alone anymore, testing isn’t the activity at the end of the waterfall what everybody skips, it is part of the delivery. Having knowledge how to use integrated team tools is a must to be valuable and not being a blocker of productivity.


    Basic programing skills

    Test automation is a must in the current fast delivery mindset of Continues Delivery. And this test automation must be, just like all the team work, integrated in the team process.

    Standalone test automation tools are useless. Test automation connected with the team sprint tasks, the team build runs, the team delivery and the code base is a must for agile teams in being efficient with a focus on quality.

    When test automation is in the same code base, in the same rhythm as the whole team, the code written for this test automation is logical the same programming language as the language the system is developed in, at least it is the most efficient.


    Having basic programming skills as a tester is a must to be valuable for the team. As the image above shows, only just a small part is manual testing. So start to learn programming.



    (Distributed) Version Control

    Every artifact a team creates should be under version control. For the codebase it is normal to use a version control system. Either a centralized system like Visual Studio Online or a distributed system like GIT, everything is under version control.


    All team members must understand the basics of version control. How to get or pull artifacts in or out and the pros and cons of the usages of branches.

    Testers need to be capable to get the version they want to test from version control them self, they need to understand what artifacts are in the version and what features are delivered at what quality.

    Knowledge of version control systems will make testers less depended on the other team members who do know what is in what version.

    A good read: Version Control for Multiple Agile Teams





    System under Test Deployment models.

    As mentioned in the previous needed tester’s skill, testers should be less depended on other team members to get their system under test. Knowing how to deploy the software is a great added value for testers. This is for all kind of systems for example, knowing how to install a Store App on a tablet for testing will make the tester immediately more productive.

    For more complex systems, knowing how PowerShell, Chocolaty, Puppet, Chef, Visual Studio Release Manager or other deployments mechanisms work would be great.

    But at least understand how to start the deployment as a tester is the minimum. In the same category understand how to setup a test infrastructure for automated testing would be very useful.





    Understanding the capabilities of current monitoring systems is a big benefit for testers. A tester who understands the behavior of the system under test is a invaluable benefit for the team. This tester helps to solve bugs as quick as possible by providing valuable usages statics, trace files or intellitrace files.



    Cloud Systems

    The last skill for a testers I want to talk about is Cloud. When a tester wants to stay in business, he or she needs to understand and usage the Cloud for testing.



    Beside easy onboarding of new team members Dev & Test in the Cloud also can be used for your complete test infrastructure and with the new gained deployment knowledge also the provisioning of test environments should be easy for testers.

    See: http://labs.sogeti.com/fast-and-flexible-with-dev-and-test-platforms-as-a-service/


    See this deck: Azure for Teams



    I can imagine you think ‘as a tester’ this isn’t my job role, these are the activities and skills of other. But as James Whittaker mentions in this post

    “For the vast majority of app development on this planet, software testing is an activity within the development process …. It’s time to bring quality into the 21st century where testing is such an integral part of software development that you’ll often forget you are doing because it has become so familiar.


    Testing is integrated in modern development, a testers must evolve. To stay valuable for teams and keep their job the in this post mentioned skills must be added to the capabilities of the modern tester.

    Not only these capabilities count for testers, all other team members should master them too. So there is also some lessons to learn for developers.

    DECK: Azure for Teams

    More business value with fast and flexible teams.

    The deck I used (parts of it) at different conferences.

    Corresponding posts:

    Posted: Apr 24 2014, 01:43 by ClemensReijnen | Comments (1) RSS comment feed |
    Filed under: ALM | Agile | Azure | Sogeti

    My Garmin Forerunner 405 died today.

    I think it is the battery which didn’t charge properly any more.

    The Forerunner 405, it was my first wearable device, connected with the internet. I also got the Heart Rate Monitor, the Foot Pod and the Speed/Cadence Bike Sensor sensors. Too much fun all these sensors when running.

    All these hypes now days around wearable computing sounds a bit strange to me, it was already there five years ago. In what stone age have all these analysts lived these years. For sure they aren’t runners, they would have know better.
    It is funny when I think back about a talk I had after I bought this Garmin device about logging my activities the guy was amazed I logged everything, he is now wearing a FitBit.  

    I had my Garmin for five years and I did run 5.390,06 km with it for 482:47:13 u:m:s. The device did cost about 300 euros (I think, not exactly), a simple math gives us that the device cost 5 cent per km, or 60 cent per hour. I can live with that.

    I did two marathons with it:


    I did many half marathons as training in the Amsterdamse Bos (my backyard)

    I ran in Dubai, slowly due to the heat.

    and in Seattle, with a beautiful view on Mnt Rainier

    Did some hiking in Norway.. beautiful 

    Many times ski touring in the Swiss and Italian Mountains

    And many many more, finally more than 500 activities have been logged with my 405 the past five years.

    I sure want a new one, apps on a mobile device can’t replace it.
    But, have to save some money first...  I like the Fenix 2