samedi 30 novembre 2013

Migrer de TFS 2008 SP1 vers TFS 2012

Si vous avez encore votre serveur TFS en version 2008 SP1, il faudra migrer d'abord celui-ci vers TFS 2012 avant éventuellement de le migrer vers TFS 2013. Voici un résumé des principales étapes pour cette migration et celle de votre contenu SharePoint (WSS3.0).
  1. Préparer les nouvelles machines avec : (Dans la plupart des cas, il n'est pas possible de migrer sur place)
    1. Windows 2008 R2 SP1
    2. SQL Server 2008 R2 SP2
    3. SharePoint 2010 SP2
    4. TFS 2012 Update 3 (une de mes migrations avec l'update 4 a échouée)
  2. Préparer les outils et Team Build
    1. migrer vers VS2012 autant que possible les solutions.
    2. migrer vos taches et outils de Build vers vers le nouveau modèle objet client.
    3. migrer une build .Net : à priori pas ou peu d'actions (sauf migration optionnelle de MsTest vers Test Runner et des personnalisations du 2.)
    4. migrer une build Cpp en conservant une solution et projets VS2008  :
      Voici les points que j'ai rencontré, vous en aurez surement de supplémentaires,
      Sur la machine de Build :
      • Installer Windows SDK 6.1A
      • Installer la fonctionnalité du serveur .Net 3.5.1
      • Installer VS2008 avec Team Explorer puis le SP1
      • Ajouter au PATH : "C:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\bin\amd64"
      Sur la définition de Build et les projets, il faut parfois s’assurer que l'"OutDir" personnalisée soit utilisée (et les fichiers bien envoyés dans le répertoire de dépôt)
  3. Sauvegarder, puis Restaurer les bases vers le nouveau serveur de base de données
    • tfsXXX (toutes les bases de TFS)
    • Wss_Content (la base de contenu SharePoint)
    • ReportServer et ReportServertempdb (base des rapports).
      Cette restauration est à réaliser si vous avez des rapports personnalisés. Les nouveaux rapports sont créés automatiquement lors de la migration.
  4. Migrer les bases TFS en choisissant l'option Mise à jour dans la boite de dialogue.
    Suivre les instructions pour migrer les bases TFS et le reporting. (Je préfères migrer SharePoint séparément)
    La migration est longue voire très longue suivant la taille de votre base de code et le nombre d'éléments de travail. L'idéal est de la tester une première fois avant de réaliser la migration définitive.
  5. Configurer SharePoint 2010.
    Lancer une configuration standard en créant une nouvelle ferme de serveur et un nouveau site d’administration centrale. Puis lancer l'assistant d'installation pour configurer les applications et service, sauter la création d'un site de haut niveau.
  6. Installer les extensions TFS pour SharePoint depuis la console d'administration de TFS.
    (Ou les installer directement depuis les sources TFS si SharePoint est sur un serveur séparé)
  7. Ajouter la base de données de contenu. Pour cela, il faut utiliser la ligne de commande  (impossible de puis l'administration centrale)
    cd c:\Program Files\Common Files\microsoft shared\Web Server Extensions\14\BIN
    stsadm.exe -o addcontentdb -url http://SPSserveur/ -databasename WSS_Content -databaseserver DBServeur
  8. Vérifier l’association du serveur SharePoint avec le serveur TFS depuis la console d’administration de TFS, activer l'association si nécessaire. Fixer les liens entre les projet d''équipe TFS et leur site SharePoint depuis la section Paramètres de Visual Studio Team Explorer 2012. 
  9. Si vous migrez de domaine, changer les identités dans TFS et SharePoint.
    Mon billet disponible ici détaille les opérations.
  10. Vous pouvez alors appliquer l'update 4 de TFS sur les serveurs.
    Ou bien choisir de migrer vers TFS 2013, la procédure sera plus simple et détaillée sur MSDN.
  11. Pour bénéficier des nouvelles fonctionnalités du Web Access dans vos projets d'équipes existants, il vous faudra bien-sûr suivre la procédure de mise à niveau.
have a nice day.

dimanche 27 octobre 2013

10 astuces pour garder son TFS en bonne santé

Dans un article et dans le livre Professional TFS 2012, Grant Holliday explique comment bien maintenir une instance de TFS. Même s'il indique des priorités, la liste des actions est très longue. Je souhaite proposer ici une liste restreinte et ordonnée d'astuces qui permettent de conserver une instance TFS 2010/2012/2013 fonctionnelle pour une équipe jusqu'à 20 personnes.
Pour ce type d'instance, la personne dédiée à l'administration de TFS a souvent très peu de temps à y consacrer, il s'agit rarement de son travail principal. Il lui faut aller à l'essentiel. J'ai donc mis de côté tout ce qui concerne des installations complexes ou l'optimisation des performances.
  1. Sauvegarder l'instance TFS
    • cela vous permettra de restaurer votre instance en cas de crash
    • les bases sont paramétrées par défaut pour une restauration complète, cela signifie qu'un fichier journal de transactions est généré, si vous ne sauvegardez pas régulièrement ceux-ci, ils vont prendre une taille énorme.
    • la sauvegarde est très facile avec l'outil de sauvegarde et restauration. (inclus dans TFS2012/2013, pour 2010 installer les TFS Power Tools Dec. 2011, pour le réaliser à la main suivez bien les instructions ici)
  2. Exécuter l'outil Best Practice Analyser (chaque mois)
    • il permet de détecter des problèmes dans votre architecture
    • l'outil est inclus dans les TFS Power Tools, et s'exécute en quelques minutes seulement. 
  3. Mettre à jour les machines SQL Server et TFS
    • la mise à jour des machines permet d'éviter des failles de sécurité et une mise à jour très longue au moment d'une montée de version.
    • pour TFS l'idéal est d'être toujours sur la dernière mise à jour un mois après sa sortie. Il arrive qu'une ou 2 régressions soient corrigées rapidement. Profitez-en pour mettre aussi à jour Visual Studio sur les postes de développement.
    • installer la version la plus récente possible de SQL Server (TFS 2010 = SQL2008R2SP3, TFS 2012.4 = SQL2012 SP1, TFS 2013 = SQL2012 SP1)
  4. Installer un environnement de taille suffisante
    • sans rechercher la performance, il faut un minimum de puissance, de mémoire, et d'espace disque ! Suivez les indications du TFS Planning Guide 
    • la santé des disques hébergeant les fichiers des bases de données est souvent un facteur clé du bon fonctionnement. Vous pouvez les surveiller en effectuant un échantillonnage à l'aide de l'analyseur de performance sur l'objet "Disque logique" ou "Disque physique" et le compteur en pour 1000 "Moyenne disque s/transfert" (échantillonner toutes les 30 secondes). Les résultats ne doivent pas dépasser 0.050.
  5. Vérifier la bonne santé de l’instance de bases de données SQL Server
    • la majorité de la logique de TFS est implémentée dans des procédures SQL. La santé de TFS est donc largement dépendante de celle de l’instance des bases de données SQL Server.
    • exécuter régulièrement DBCC CHECKDB pour vérifier leur intégrité
    • vous pouvez aussi utiliser les DMV (Dynamic Management Views) à partir du script de Jimmy May disponible ici pour vérifier qu'il n'y pas de problème majeur.
  6. Vérifier et modifier les paramètres du pool d'application IIS
  7. Vérifier régulièrement le journal d'activité et les travaux depuis http://monserveur:8080/tfs/_oi/
    • cela permet de vérifier si des travaux posent problèmes
    • cela permet aussi de verifier la santé de l'entrepôt de données et et du cube OLAP
  8. Vérifier et sauvegarder les Builds
    •  sauvegarder régulièrement le répertoire de dépôt des Builds TFS (sauvegarder aussi votre répertoire de symboles, si vous en avez un)
    • vérifier aussi que l'espace disponible sur les machines de Build est suffisant.
  9. Vérifier ou désactiver les journaux IIS
    • cela permet d'éviter de remplir le disque ...
    • pour les désactiver, exécuter  la commande suivante sur l'application-Tier en tant qu'administrateur local :
      %windir%\system32\inetsrv\appcmd set config -section:system.webServer/httpLogging /dontLog:"True"  /commit:apphost
  10. Nettoyer les éléments non utilisés de TFS
    • avec Team Foundation Sidekicks, supprimer les espaces de travail et mises sur étagères non utilisés.
    • avec witadmin, lister puis supprimer les champs inutilisés :
      witadmin listfields /unused /collection:http://monserveur:8080/tfs/DefaultCollection
      witadmin deletefield /n:referencechamp /collection:http://monserveur:8080/tfs/DefaultCollection
    • avec le Test Attachement Cleaner, supprimer les fichiers attachés inutiles. Il est inclus dans les TFS Power Tools. Le détail des opérations est bien expliqué ici.
Il existe d'autres astuces que je trouve aussi intéressantes dans ce cadre, mais il faut tenir la limite.
Qu'en pensez-vous ? A votre avis, quelle autre astuce devrait se trouver dans cette liste ?

have a nice day.

vendredi 27 septembre 2013

Supprimer le Lab Management de la configuration

Un client avait configuré le Lab Management pour tester ses fonctionnalités. L'équipe a ensuite décidée de stopper son utilisation car la solution de virtualisation au niveau entreprise, fraîchement choisie, n'est pas SCVMM. Cette fonctionnalité n'est donc plus utilisée. Après un changement de domaine et une migration vers TFS 2012, une erreur était déclenchée très régulièrement sur les jobs intitulés LabManager VMM Server Background Synchronization Job

La description de l'erreur est assez claire "TF259194: System Center Virtual Machine Manager Admin Console is not installed on your Team Foundation server"
J'ai essayer de supprimer la configuration Lab Management via la console ou l'utilitaire TFSConfig Lab. La même erreur apparaît. Les étapes suivantes permettent de stopper ces erreurs puis supprimer les objets et configuration du Lab Management de TFS 2012.

Installer le SCVMM Administrator Console

Votre compte MSDN vous permet de télécharger le produit "System Center Virtual Machine Manager 2008 R2" (TFS 2012) . Il vous faut l'installer sur une de vos machines Application Tier. Lancer le setup.exe et dans la page d'accueil sélectionner VMM Administrator Console. Suivez les instructions et réaliser l'installation.
Une fois l'installation réalisée les erreurs s'arrêtent. Et vous pouvez à nouveau configurer le Lab Management.

Naviguer vers http://serveurTFS:8080/tfs/_oi/_jobMonitoring puis défiler vers le bas jusqu'au dernier graphique.

Supprimer les objets Lab Management au niveau des collections

Pour cela il suffit d'utiliser la commande suivante  sur chaque collection :
cd "C:\Program Files\Microsoft Team Foundation Server 11.0\Tools"
.\TfsConfig Lab /Delete /CollectionName:NomdelaCollection

Une fois l'ensemble des suppressions réalisées, vous avez alors le message suivant dans la console d'administration :

Supprimer complètement le Lab Management

Cette possibilité ne semble pas offerte par la console d'administration ou l'outil TfsConfig. La commande suivante fonctionne mais ne change pas la configuration en réalité :
.\TfsConfig Lab /Settings /ScVmmServerName:"" /NetworkLocation:"" /IpBlock:"" /DnsSuffix:""
Pour la supprimer, il est possible réaliser une modification directement dans la base de données de configuration, je ne le recommande pas évidemment. L'autre possibilité, plus laborieuse mais utilisant les outils fournis, est de réaliser une nouvelle configuration sur place :
  • Se connecter sur un serveur application Tier en tant qu'adminitrateur de TFS et lancer une console PowerShell avec les droits élevés
    cd "C:\Program Files\Microsoft Team Foundation Server 11.0\Tools"
  • Arrêter les services TFS et sauvegarder les bases de données
    .\TfsServiceControl quiesce
    .\TfsBackup
  • Supprimer les objets Lab Management des collections comme ci-dessus
  • Détacher toutes les collections (cela permet de les rendre portables)
    .\TfsConfig Collection /detach /collectionName:NomdelaCollection
  • Désinstaller les configurations (pour reconfigurer les Application-tier)
    .\TfsConfig Setup /uninstall:ALL
  • Supprimer la base de configuration actuelle,
  • Configurer à nouveau le serveur TFS à l'identique, pour configurer sur place lancer
    .\TfsMgmt configure
  • Attacher à nouveau toutes les collections
    .\TfsConfig Collection /attach /collectionName:NomdelaCollection /collectionDB:"Machine\SqlInstance;NomBasedeDonnees"
  • Vérifier, configurer pour chaque collection l'intégration à SharePoint, Reporting Services, et les contrôleurs et agents de Build
Mais cela n'est en rien gênant sauf si vous souhaitez absolument pouvoir désinstaller SCVMM Administrator Console.

have a nice day.

samedi 31 août 2013

Changer le compte de domaine associé à une identité dans TFS

Depuis la version TFS 2010, l'ensemble des identités est listé dans la base Tfs_configuration.
Tous les comptes et groupes ayant un droit d'accès à TFS ont automatiquement une identité créée (qu'ils s'y soient un jour connectés ou non). Il n'est pas possible de supprimer ou fusionner des identités. Cependant il est possible de modifier le compte/groupe de domaine associé à une identité.
Pour cela, il suffit d'utiliser la commande suivante sur un des serveurs Application-Tier :
cd "C:\Program Files\Microsoft Team Foundation Server 11.0\Tools"
.\TFSConfig identities /change /fromdomain:olddomain /todomain:newdomain /account:oldlogin /toaccount:newlogin

Si vous migrez de domaine, vous pouvez utiliser la commande simplifiée suivante. Elle permet de changer les comptes/groupes pour toutes les identités listées à condition que les nouveaux logins soient identiques aux anciens (il faut aussi qu'ils soient d'abord créés dans le nouveau domaine).
cd "C:\Program Files\Microsoft Team Foundation Server 11.0\Tools"
.\TFSConfig identities /change /fromdomain:olddomain /todomain:newdomain

Il arrive parfois qu'une nouvelle identité soit créée par erreur, souvent par ricochets via les groupes Windows. Le nouveau compte cible newdomain\newdidier est alors déjà connu dans TFS. La migration de l'ancien compte olddomain\olddidier vers newdomain\newdidier ne fonctionnera pas.
Comme l'utilisateur newdomain\newdidier n'a en fait réalisé aucune action dans TFS, il est facile de supprimer ce doublon en utilisant un compte local temporaire srvTFS\tmpdidier.
cd "C:\Program Files\Microsoft Team Foundation Server 11.0\Tools"
.\TFSConfig identities /change /fromdomain:newdomain /todomain:srvTFS /account:newdidier /toaccount:tmpdidier
.\TFSConfig identities /change /fromdomain:olddomain /todomain:newdomain /account:olddidier /toaccount:newdidier
Affecter le compte intermédiaire srvTFS\tmpdidier à l'identité créée par erreur de newdomain\newdidier permet de supprimer ce dernier de la liste. Il suffit alors de migrer normalement l'identité de olddomain\didier vers newdomain\newdidier.
Lors d'une migration, j'ai eu un problème de synchronisation des comptes au niveau des éléments de travail. Le Job plante sur une identité, l'accès aux éléments de travail n'est alors plus disponible pour certains utilisateurs. Pour l'éviter, il suffit de forcer après le changement d'une identité la synchronisation en lançant le Job correspondant (ne pas changer 2 fois de suite une identité sans exécuter ce job). Un billet de Neno Loje explique comment ici.

Nous avons aussi souvent un serveur SharePoint associé au TFS et les noms de comptes suivent souvent une règle différente en changeant de domaine. Je vous propose un script PowerShell permettant de migrer rapidement les comptes individuellement. 
Param(
     [string] $csvlogins = "C:\mappageLogins.csv",
     [string] $domainOld = "olddomain",
     [string] $domainNew = "newdomain",
     [string] $SharepointWebApp = "http://srvsps"
    )

$TFSConfig = "$Env:ProgramFiles\Microsoft Team Foundation Server 11.0\Tools\TFSConfig.exe"

$loginList=IMPORT-CSV -Path $csvlogins -delimiter ";"

Foreach ($Account in $loginList) {
    $old = $Account.AncienLogin
    $new = $Account.NouveauLogin
    write-output "$domainOld\$old"
    & $TFSConfig identities /change "/fromdomain:$domainOld" "/todomain:$domainNew" "/account:$old" "/toaccount:$new"
    $user = Get-SPUser -web $SharepointWebApp -Identity "$domainOld\$old"
    Move-SPUser -Identity $user -NewAlias "$domainNew\$new" -IgnoreSID -Confirm:$false
}
Le script fonctionne si TFS est installé sur le serveur et les commandlets de SharePoint sont chargées dans la console PowerShell. Pour lister les identités actuelles de TFS, il suffit d'exécuter TFSconfig identities. Ensuite, il vous suffit de créer un fichier CSV avec les colonnes "AncienLogin" et "NouveauLogin" :
AncienLogin;NouveauLogin
didier;newdidier

Comme toujours, soyez prudents, les changements d’identités peuvent avoir des effets de bord. Vous ne devez jamais utiliser ces commandes sur votre instance de production sauf si vous les avez testées sur l’environnement de test au préalable.

have a nice day.

Mise à jour 01/12/2013 : Ajout remarque sur la synchronisation des identités au niveau des éléments de travail.

dimanche 21 juillet 2013

Ajouter l'effort au bogue et le gérer dans le Web Access 2013

Je vais décrire comment intégrer le temps estimé, effectué et restant sur un bogue dans le modèle de processus Msf Agile 7.x en langue Fr-Fr et Team Foundation Server 2013. Les modifications permettront aussi de visualiser les bogues dans le tableau du Web Access, et gérer la capacité de l'équipe sur le travail restant des tâches et bogues. Enfin, les bogues seront directement utilisables dans la page "Mon travail" sous Visual Studio 2013.
Globalement, la démarche nécessite de modifier le type d’élément de travail Bogue afin de lui ajouter les champs de références, les états et transitions nécessaires. Puis, il faudra modifier le fichier de configuration du processus et les catégories. Pour effectuer ces mêmes opérations sur TFS 2012 (ou TFS en en-US), vous pouvez vous reporter à mes précédents messages Ajouter l'effort au type bogue et Afficher le bogue dans le Web Access

Modifier le fichier bogue

Exporter la définition du Bogue depuis votre projet d'équipe basé sur le processus Msf Agile 7.x :
$NomProjetEquipe = "TestProjMsfAgile7"
$UrlCollectionTfs = "http://VSTFS2013FR:8080/tfs/DefaultCollection"
$WitAdmin = "${env:ProgramFiles(x86)}\Microsoft Visual Studio 12.0\Common7\IDE\witadmin.exe"
$Reptemp = "C:\temp"
 
#Exporter le WIT Bogue
& $WitAdmin importwitd /collection:$UrlCollectionTfs /p:$NomProjetEquipe /f:"$Reptemp\Bogue.xml" /n:Bogue
Le type d'élément de travail Bogue n'a pas ou peu évolué dans cette version 7.x de Msf Agile. Les modifications à réaliser sont à peu près identiques aux précédentes versions à savoir :
  • ajouter les champs de référence Microsoft.VSTS.Scheduling.Xxxx et Microsoft.VSTS.Common.Activity
  • <FIELD name="Activité" refname="Microsoft.VSTS.Common.Activity" type="String" reportable="dimension">
     <HELPTEXT>Type de travail concerné</HELPTEXT>
     <SUGGESTEDVALUES expanditems="true">
      <LISTITEM value="Développement" />
      <LISTITEM value="Test en cours" />
      <LISTITEM value="Spécifications" />
      <LISTITEM value="Design" />
      <LISTITEM value="Déploiement" />
      <LISTITEM value="Documentation" />
     </SUGGESTEDVALUES>
    </FIELD>
    <FIELD name="Travail restant" refname="Microsoft.VSTS.Scheduling.RemainingWork" type="Double" reportable="measure" formula="sum">
     <HELPTEXT>Estimation du nombre d'unités de travail restantes pour terminer cette tâche</HELPTEXT>
    </FIELD>
    <FIELD name="Estimation d'origine" refname="Microsoft.VSTS.Scheduling.OriginalEstimate" type="Double" reportable="measure" formula="sum">
     <HELPTEXT>Valeur initiale du travail restant - à définir au début du travail</HELPTEXT>
    </FIELD>
    <FIELD name="Travail effectué" refname="Microsoft.VSTS.Scheduling.CompletedWork" type="Double" reportable="measure" formula="sum">
     <HELPTEXT>Nombre d'unités de travail consacrées à cette tâche</HELPTEXT>
    </FIELD>
  • ajouter les états Nouveau et Supprimé
  • <STATE value="Nouveau">
     <FIELDS>
      <FIELD refname="Microsoft.VSTS.Common.ActivatedDate">
       <EMPTY />
      </FIELD>
      <FIELD refname="Microsoft.VSTS.Common.ActivatedBy">
       <ALLOWEXISTINGVALUE />
       <EMPTY />
      </FIELD>
      <FIELD refname="Microsoft.VSTS.Common.ClosedDate">
       <EMPTY />
      </FIELD>
      <FIELD refname="Microsoft.VSTS.Common.ClosedBy">
       <ALLOWEXISTINGVALUE />
       <EMPTY />
      </FIELD>
      <FIELD refname="Microsoft.VSTS.Common.ResolvedReason">
       <EMPTY />
      </FIELD>
      <FIELD refname="Microsoft.VSTS.Common.ResolvedBy">
       <ALLOWEXISTINGVALUE />
       <EMPTY />
      </FIELD>
      <FIELD refname="Microsoft.VSTS.Common.ResolvedDate">
       <EMPTY />
      </FIELD>
     </FIELDS>
    </STATE>
    <STATE value="Supprimé" />
  • ajouter et modifier les transitions essentielles permettant de naviguer d'un état donné à un autre. Pour la lisibilité de ce message, vous les trouverez à la fin de celui-ci.
  • ajouter des contrôles dans l'interface correspondants aux champs de référence Microsoft.VSTS.Scheduling.Xxxx et Microsoft.VSTS.Common.Activity
  • <!-- interface ajouter dans le groupe avec la Planification et la Classification 
         et  Ajuster les pourcentages-->
    <Column PercentWidth="20">
     <Group Label="Effort (en heures)">
      <Column PercentWidth="100">
       <Control FieldName="Microsoft.VSTS.Scheduling.OriginalEstimate" Type="FieldControl" Label="Estimation d'origine" LabelPosition="Left" />
       <Control FieldName="Microsoft.VSTS.Scheduling.RemainingWork" Type="FieldControl" Label="Restant" LabelPosition="Left" />
       <Control FieldName="Microsoft.VSTS.Scheduling.CompletedWork" Type="FieldControl" Label="Terminé" LabelPosition="Left" />
      </Column>
     </Group>
    </Column>
    <!-- et activité dans la colonne Planification en dernière ligne + ajustement des pourcentages -->
    <Control FieldName="Microsoft.VSTS.Common.Activity" Type="FieldControl" Label="Activité" LabelPosition="Left" EmptyText="&lt;Aucun&gt;" />
Importer cette nouvelle définition du Bogue dans votre projet d'équipe basé sur le processus Msf Agile 7.x :
$NomProjetEquipe = "TestProjMsfAgile7"
$UrlCollectionTfs = "http://VSTFS2013FR:8080/tfs/DefaultCollection"
$WitAdmin = "${env:ProgramFiles(x86)}\Microsoft Visual Studio 12.0\Common7\IDE\witadmin.exe"
$Reptemp = "C:\temp"
 
#Exporter le WIT Bogue
& $WitAdmin importwitd /collection:$UrlCollectionTfs /p:$NomProjetEquipe /f:"$Reptemp\Bogue.xml"

Modifier les catégories et la configuration du processus

Exporter la configuration du processus et les catégories du projet d'équipe :
$NomProjetEquipe = "TestProjMsfAgile7"
$UrlCollectionTfs = "http://VSTFS2013FR:8080/tfs/DefaultCollection"
$WitAdmin = "${env:ProgramFiles(x86)}\Microsoft Visual Studio 12.0\Common7\IDE\witadmin.exe"
$Reptemp = "C:\temp"
 
#Exporter la configuration du processus et les catégories
& $WitAdmin exportprocessconfig /collection:$UrlCollectionTfs /p:$NomProjetEquipe /f:"$Reptemp\ProcessConfiguration.xml"
& $WitAdmin exportcategories /collection:$UrlCollectionTfs /p:$NomProjetEquipe /f:"$Reptemp\Categories.xml"
Modifier le fichier des catégories pour ajouter le Bogue dans la catégorie de tâche :
<CATEGORY refname="Microsoft.TaskCategory" name="Catégorie de tâche">
 <DEFAULTWORKITEMTYPE name="Tâche" />
 <WORKITEMTYPE name="Bogue" />
</CATEGORY>
Modifier le fichier de configuration du processus pour introduire les modifications réalisées :
<BugWorkItems category="Microsoft.BugCategory" pluralName="Bogues" singularName="Bogue">
 <States>
  <State type="Proposed" value="Nouveau" /> <!-- Ajouter l'état Nouveau -->
  <State type="InProgress" value="Actif" />
  <State type="Complete" value="Fermé" />
  <State type="Resolved" value="Résolu" />
 </States>
</BugWorkItems>
<!-- ... -->
<TaskBacklog>
  <!-- remplacer les éléments States du TaskBacklog par les suivants -->
  <States>
  <State type="Proposed" value="Nouveau" />
  <State type="InProgress" value="Actif" />
  <State type="Resolved" value="Résolu" />
  <State type="Complete" value="Fermé" />
 </States>
</TaskBacklog>
Importer les catégories puis la configuration du processus dans le projet d'équipe :
$NomProjetEquipe = "TestProjMsfAgile7"
$UrlCollectionTfs = "http://VSTFS2013FR:8080/tfs/DefaultCollection"
$WitAdmin = "${env:ProgramFiles(x86)}\Microsoft Visual Studio 12.0\Common7\IDE\witadmin.exe"
$Reptemp = "C:\temp"
 
#Importer les catégories et configuration du processus
& $WitAdmin importcategories /collection:$UrlCollectionTfs /p:$NomProjetEquipe /f:"$Reptemp\Categories.xml"
& $WitAdmin importprocessconfig /collection:$UrlCollectionTfs /p:$NomProjetEquipe /f:"$Reptemp\ProcessConfiguration.xml"
Vous pouvez maintenant profiter de votre tableau tout frais affichant les bogues et tâches associées aux récits utilisateurs de l'itération choisie. Un tableau est désormais disponible pour chaque itération (plus uniquement celle en cours). Notez que le lien a été déplacé en conséquence.

Quelques Réflexions

J'ai utilisé ici un script PowerShell pour l’exécution des commandes. Même si celles-ci restent très simple, j'ai trouvé cela plus facile qu'une invite de commandes sans compter les possibilités plus vastes disponibles.
La configuration du processus avec un seul fichier est une réelle avancée pour la personnalisation. Les changements sont plus faciles à réaliser et il n'est plus besoin de réfléchir à l'ordre d'importation des fichiers.

have a nice day.

dimanche 30 juin 2013

Visual Studio ALM 2013 Preview et Scrum Boat

Le mercredi 26/06 fut une sacrée journée. A la Build 2013, les sorties de Visual Studio 2013 et Team Foundation Server 2013 en version Preview ont été officialisées, avec en parallèle la sortie de l'Update 3 de Visual Studio 2012. La soirée était aussi riche côté Agilité avec la soirée Scrum Boat.

Visual Studio 2013 Preview et TFS 2013 Preview

Je ne vais pas énumérer l'ensemble des nouveautés excitantes de cette nouvelle version. Je vais citer mes 5 préférées.
  • Les améliorations de l’éditeur de code : il permet désormais de prévisualiser la valeur de retour d'une fonction, visualiser les indicateurs de code "tête haute" en début de fonction : références, dernières modifications et auteurs, état des tests et testé par, et enfin la visualisation en ligne de la définition d'une fonction (Peek definition)
  • Editer et continuer la session de débogage sur une plateforme x64, vous permettra de gagner du temps en évitant de redémarrer une session de débogage pour une petite correction du code.
  • Le support pour les applications Windows Store écrite en Xaml des tests codés de l'interface utilisateur (Coded UI)
  • Le début de la gestion de portefeuille Agile avec la gestion d'une hiérarchie de backlogs et le nouveau type d'élément de travail Fonctionnalité (Feature)
  • Le rachat de InRelease qui étend et facilite l'automatisation des processus d’intégration et de déploiement des applications.
Pour tester les nouveautés, vous pouvez profiter dans Windows Azure de la nouvelle image d'ordinateur virtuel pré-configurée avec Visual Studio 2013 Preview et Windows Server 2012. Les comptes MSDN n'ont maintenant plus l'obligation de  fournir les informations d'une carte bancaire à l'inscription et bénéficier de 150€ le premier mois puis chaque mois de 40€ (Professionnel), 75€ (Premium) et 115€ (Ultimate) . La preuve en images :
150€ chaque mois

Scrum Boat

J'ai eu le bonheur de participer à cette soirée organisée par le French Scrum User Group sur une péniche parisienne.
Mon premier atelier fut un rafraîchissant Open Space. Même Merci à Guillaume, Emilie, Yannick, Raphaël, Sébastien, Marine et les invités ponctuels pour ce bon moment et ces échanges. J'en ai retenu quelques points :
  • Nous aimons l'Agile pour le travail en équipe (non en groupe), le sentiment de fierté du produit réalisé, la performance de la méthode 
  • Le top management pousse de plus en plus à l'adoption  de méthode Agiles  L'équipe de développement n'est plus systématiquement à l’initiative de l'adoption
  • Pour promouvoir l'Agilité au top management, il vaux mieux évoquer les intérêts financiers : ROI, efficience, time to market, dette technique réduite (les anomalies détectés en production coûtent chères) ou encore le bénéfice pour l'image de l'entreprise par l'extérieur, par ses employés. L'introduction des concepts via des Serious Games peut accélérer la compréhension des bénéfices.
  • L'Agilité est une innovation de processus et de rupture. Elle est donc encore nouvelle, il faut aussi la promouvoir au travers d’exemples de réussites concrètes.
Le deuxième atelier portait sur l'expression du besoin et la création rapide d'une maquette fonctionnelle à l'aide d'un outil de User eXperience Domain Driven Devlopment. La démonstration de la méthode est assez convaincante. En un peu moins d'une heure, il a été possible de capter l'expérience utilisateur attendue pour la création d'une application permettant à des équipes distantes de réaliser un Speed Boat.

Après cette soirée studieuse et ludique, le bateau est parti pour une croisière nocturne d'environ 1 heure sur la seine avec au programme échanges et networking.

have a nice day.

dimanche 23 juin 2013

Faciliter la création et le partage de vos interfaces

Pour accélérer et obtenir une bonne cohérence entre les différentes interfaces sur des applications Windows Store et Windows Phone, je pratique régulièrement 2 astuces. La première permet de créer des pages à partir d'un ou plusieurs modèles partagés, la deuxième permet de partager au maximum les styles entres les différentes plateformes cibles d'une même application.

Créer vos modèles de page

Je décris ci-dessous une procédure vous permettant de créer un modèle de page. Celui peut alors être simplement réutilisé lorsque vous choisissez "Ajouter un nouvel élément", il apparaît dans le formulaire de création comme ci-dessous.

Bien que la procédure détaillée porte sur une page d'application Windows Store avec XAML/C#, la même procédure pourra être appliquée pour des pages d'applications Windows Store avec HTML/CSS, ou encore Windows Phone 7 et 8.
  1. Exporter votre page comme modèle de nouveaux éléments.
    Cliquer dans le menu sur Fichier > Exporter le modèle pour ouvrir le la fenêtre de dialogue. Choisissez ensuite "modèle d'élément" et le projet dans lequel la page à exporter comme modèle est située. Choisissez l'élément à exporter. Choisissez les références à exporter (elles sont ajoutées au moment de l'import dans le projet). Choisissez le titre, la description, l'icône et décochez l'importation automatique.
  2. Dézipper le fichier créé dans un sous-dossier du même nom que le fichier zip. Vous pouvez supprimer le fichier zip d'origine. Ouvrez le fichier MyTemplate.vstemplate quelques modifications y sont à réaliser.
  3. Indiquer le groupe de plateforme auquel appartient le modèle.
    Il vous suffit d'ajouter la ligne suivante dans la balise TemplateData pour une application Windows Store:
    <TemplateGroupID>WinRT-Managed</TemplateGroupID>
    pour une application Windows Phone 7 ou 8 utilisez :
    <TemplateGroupID>Windows Phone</TemplateGroupID>
  4. (Rendre le modèle non-visible par défaut)
    Lorsque vous ajouterez un élément dans un site site Web par exemple ce modèle n'apparaîtra pas. Il faut ajouter la ligne suivante dans le noeud TemplateData.
    <ShowByDefault>false</ShowByDefault>
  5. Faire apparaître le modèle de page dans la catégorie supérieure.
    Si vous souhaitez voir le modèle dans votre catégorie personnalisée et aussi dans la catégorie parente Visual C#, il suffit d'ajouter la ligne suivante dans le noeud TemplateData.
    <NumberOfParentCategoriesToRollUp>1</NumberOfParentCategoriesToRollUp>
  6. Importer le modèle dans Visual Studio.
    Enregistrez les modifications précédentes. Naviguez vers le répertoire "C:\Users\nomutilisateur\Documents\Visual Studio 2012\Templates\ItemTemplates". Créez un nouveau répertoire "Mes Modèles". Et déplacez le répertoire contenant le modèle dans celui-ci.
Vous pouvez maintenant ajouter de nouvelles pages à votre application suivant votre nouveau modèle. Pour aller plus loin, vous pouvez envisager d'intégrer vos modèles de page à une extension de Visual Studio .vsix afin de les diffuser largement.

Répartir et partager vos styles dans différents fichiers

L'idée est de construire plusieurs fichiers de styles qui seront plus ou moins partagés avec les différentes plateformes. Pour le développement d'une solution sur les 3 plateformes en XAML/C#, j'utilise la configuration suivante avec trois types de fichiers selon leur niveau de partage :
  • Les couleurs. L'ensemble de color, brush, .. constituent une partie importante de la charte graphique, le fichier contenant celles-ci est partagé sur l'ensemble des applications Windows Store, Windows Phone 7 et 8. Pensez simplement à retirer la référence xmlns:local qui est ajoutée automatiquement à la création d'un dictionnaire de ressources.
  • Les styles de textes, boutons, et contrôles de base : Même s'ils sont en général communs aux  3 plateformes, vous ne souhaitez pas utiliser la même taille de texte pour un titre sur la tablette que sur le téléphone. 1 fichier est créé pour l'application Windows Store. 1 autre fichier du même nom est créé et partagé entre les applications Windows Phone 7 et 8.
  • Les styles et modèles d'un composant spécifique à une plateforme. Le fichier correspondant est bien entendu créé uniquement pour la dite plateforme par exemple le contrôle Pivot de Windows Phone.
    Remarque : le contrôle Pivot  existe sur Windows Phone 7 et 8 mais dans une librairie différente. Pour partager le fichier de style, il faudra déclarer l'espace de nom controls pour la réutilisation dans l'application Windows Phone 7 comme dans l'exemple ci-dessous. Notez aussi les références aux dictionnaires de ressources précédents.
    <ResourceDictionary
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:controls="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone.Controls"
        xmlns:phone="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone">
        <ResourceDictionary.MergedDictionaries>
            <ResourceDictionary Source="CustomColors.xaml"/>
            <ResourceDictionary Source="CustomStyles.xaml"/>
        </ResourceDictionary.MergedDictionaries>
        <!-- Pivot's style -->
        <Style x:Key="MainPagePivotStyle" TargetType="controls:Pivot">
            <Setter Property="Margin" Value="0,50,0,0" />
        </Style>
    </ResourceDictionary>
Pour partager un même fichier, il suffit de les créer dans le premier projet de "base" (je choisis celui de Windows Store, puis Windows Phone 8). Ensuite, il suffit d'ajouter de les Ajouter en tant que lien dans les autres projets compatibles.
Cliquer sur Ajouter un élément existant. Dans la fenêtre de choix, naviguez vers le projet de "base" et choisissez le fichier souhaité à importer, enfin cliquer sur "Ajouter en tant que lien".

Le partage des styles complète bien les librairies portables et le modèle d'architecture MVVM afin de partager un maximum de code. Vous pouvez consulter l'article du MSDN magazine de juin 2013 à ce sujet ici.
have a nice day.

vendredi 31 mai 2013

Créer des maquettes efficaces en collaboration

J'ai enregistré une nouvelle émission dans la série Bon App!. Je vous y présente les outils à disposition pour la réalisation des maquettes dynamiques dans la suite Visual Studio ALM et comment les créer en collaboration.

Les avantages d'une maquette dynamique

La création d'une maquettes dynamique (storyboard, animation, mockup) permet de clarifier les fonctionnalités d'une application à développer. Elle permet aux utilisateurs de se projeter dans la future application afin de valider les fonctions à implémenter. Si vous y intégrez la charte graphique, vous pourrez aussi la valider à l'avance!

Les outils Storyboard et SketchFlow

Visual Studio 2012 Premium installe un Add-In PowerPoint. Celui-ci vous permet d'étendre les fonctionnaltés de PowerPoint et vous fourni beaucoup de formes prédéfinies pour accélerer le maquettage (PageWeb, controles Windows UI, Windows Phone, ...).
Dans l'update 2, Microsoft a inclus SketchFlow un outil de mockup intégré à Blend. Celui-ci vous permet d'aller encore plus loin en créant une véritable maquette interactive avec une expérience utilisateur très proche de celle de l'application finale (clique et sélection d'éléments, navigation libre dans les différents écrans, réutilisation de composants, ...)

La collaboration et l'implication des utilisateurs

Pour obtenir une maquette de la meilleure qualité et acceptée par tous, il est important d'obtenir des retours et commentaires de la part de l'équipe et des utilisateurs. Les outils de collaboration sont variés : TFS, SharePoint, FeedBack Client, Yammer.... Dans ma société, nous avons mis en place un processus pour nos outils internes. Il permet un premier retour par l'équipe via SharePoint puis une deuxième boucle par les utilisateurs finaux via Yammer.

lundi 20 mai 2013

Afficher le bogue dans le Web Access

Dans un billet précédent Ajouter l'effort au type bogue, j'ai expliqué comment ajouter le suivi des temps au type Bogue. Afin de tirer parti des nouvelles fonctionnalités du Web Access, je vous propose de réaliser les modifications nécessaires pour l'y ajouter. A nouveau, je précise que cet ajout n'a de sens que dans le cadre de l'utilisation du processus Msf Agile 5.x ou 6.x
Celui-ci affiche l'ensemble des éléments de travail dont le type est dans la catégorie Task. Si vous souhaitez intégrer le type Bogue à l'outil de planification Agile, il faut l'ajouter à cette catégorie. Vous aurez alors la possibilité de gérer la capacité de l'équipe sur l'ensemble du travail restant des tâches et bogues.

Modifier le type bogue

Avant de l'intégrer, il nous faut à nouveau modifier le type Bug/bogue. Il est indispensable d'ajouter un champ Activity utilisé dans la planification agile et il est intéressant d'ajouter l'état New/Nouveau au type Bug/Bogue pour obtenir une meilleure cohérence entre les 2 types.

Ouvrez une console de commande en tant qu'administrateur et tapez les commandes suivantes pour télécharger les définitions du type Bug/Bogue et Task/Tache :
cd %programfiles(x86)%\Microsoft Visual Studio 11.0\Common7\IDE
witadmin exportwitd /n:Bug /f:C:\Bug.xml /collection:http://tfsserveur:8080/tfs/DefaultCollection /p:TestProj
witadmin exportwitd /n:Task /f:C:\Task.xml /collection:http://tfsserveur:8080/tfs/DefaultCollection /p:TestProj
Si ce n'est pas déjà fait, vous devez Ajouter l'effort au type bogue en ajoutant les champs de référence Microsoft.VSTS.Scheduling.Xxxx.
D'abord, vous copiez la définition de champ de référence Microsoft.VSTS.Common.Activity depuis le fichier Task.xml et les collez dans le fichier Bug.xml sous le noeud FIELDS. Vous devez aussi ajouter le contrôle correspondant dans la colonne Planning dans la définition de l'interface.
<FIELD name="Activity" refname="Microsoft.VSTS.Common.Activity" type="String" reportable="dimension">
    <HELPTEXT>Type of work involved</HELPTEXT>
    <SUGGESTEDVALUES expanditems="true">
        <LISTITEM value="Development" />
        <LISTITEM value="Testing" />
        <LISTITEM value="Requirements" />
        <LISTITEM value="Design" />
        <LISTITEM value="Deployment" />
        <LISTITEM value="Documentation" />
    </SUGGESTEDVALUES>
</FIELD>
Vous ajoutez l'état "New" au noeud STATES en le copiant à partir de l'état "Active" du type Bug/Bogue :
        <STATE value="New">
          <FIELDS>
            <FIELD refname="Microsoft.VSTS.Common.ResolvedDate">
              <EMPTY />
            </FIELD>
            <FIELD refname="Microsoft.VSTS.Common.ResolvedBy">
              <ALLOWEXISTINGVALUE />
              <EMPTY />
            </FIELD>
            <FIELD refname="Microsoft.VSTS.Common.ResolvedReason">
              <EMPTY />
            </FIELD>
            <FIELD refname="Microsoft.VSTS.Common.ClosedDate">
              <EMPTY />
            </FIELD>
            <FIELD refname="Microsoft.VSTS.Common.ClosedBy">
              <ALLOWEXISTINGVALUE />
              <EMPTY />
            </FIELD>
          </FIELDS>
        </STATE>
Puis, vous remplacez la transition de l'état "" à l'état "Active" par les suivantes:
        <TRANSITION from="" to="New">
          <REASONS>
            <DEFAULTREASON value="New" />
            <REASON value="Build Failure" />
          </REASONS>
        </TRANSITION>
        <TRANSITION from="New" to="Active">
          <REASONS>
            <DEFAULTREASON value="Work started" />
          </REASONS>
          <FIELDS>
            <FIELD refname="Microsoft.VSTS.Common.ActivatedBy">
              <ALLOWEXISTINGVALUE />
              <COPY from="currentuser" />
              <VALIDUSER />
              <REQUIRED />
            </FIELD>
            <FIELD refname="Microsoft.VSTS.Common.ActivatedDate">
              <SERVERDEFAULT from="clock" />
            </FIELD>
            <FIELD refname="System.AssignedTo">
              <DEFAULT from="currentuser" />
            </FIELD>
          </FIELDS>
          <ACTIONS>
            <ACTION value="Microsoft.VSTS.Actions.StartWork" />
          </ACTIONS>
        </TRANSITION>
        <TRANSITION from="Active" to="New">
          <REASONS>
            <DEFAULTREASON value="Work halted" />
          </REASONS>
          <ACTIONS>
            <ACTION value="Microsoft.VSTS.Actions.StopWork" />
          </ACTIONS>
        </TRANSITION>
Enfin, vous ajoutez au minimum la transition de l'état "Closed" à "New" dans le noeud TRANSITIONS. Vous pouvez copier la transition depuis celle de l'état "Closed" à "Active". Vous pouvez aussi ajouter toutes les transitions depuis/vers l'état "New", cela permettra de déplacer depuis/vers n'importe quelle colonne du tableau le bogue:
        <TRANSITION from="Closed" to="New">
          <REASONS>
            <DEFAULTREASON value="Regression" />
            <REASON value="Reactivated" />
          </REASONS>
          <FIELDS>
            <FIELD refname="Microsoft.VSTS.Common.ActivatedBy">
              <ALLOWEXISTINGVALUE />
              <COPY from="currentuser" />
              <VALIDUSER />
              <REQUIRED />
            </FIELD>
            <FIELD refname="Microsoft.VSTS.Common.ActivatedDate">
              <SERVERDEFAULT from="clock" />
            </FIELD>
            <FIELD refname="System.AssignedTo">
              <COPY from="field" field="Microsoft.VSTS.Common.ResolvedBy" />
            </FIELD>
          </FIELDS>
        </TRANSITION>
Ouvrez une console de commande en tant qu'administrateur et tapez les commandes suivantes pour télécharger sur le serveur la nouvelle définition du type Bug/Bogue dans le projet d'équipe :
cd %programfiles(x86)%\Microsoft Visual Studio 11.0\Common7\IDE
witadmin importwitd /f:C:\Bug.xml /collection:http://tfsserveur:8080/tfs/DefaultCollection /p:TestProj

Modifier les catégories

Vous allez ajouter le type Bug/Bogue à la catégorie Task pour qu'il apparaisse dans le tableau de taches. Ouvrez une console de commande en tant qu'administrateur et tapez les commandes suivantes pour télécharger en local le fichier des catégories :
cd %programfiles(x86)%\Microsoft Visual Studio 11.0\Common7\IDE
witadmin exportcategories /collection:http://tfsserveur:8080/tfs/DefaultCollection /p:TestProj /f:C:\Categories.xml

Vous allez ensuite modifier la catégorie Task pour lui ajouter le type Bug/Bogue comme suit.
  <CATEGORY refname="Microsoft.TaskCategory" name="Task Category">
    <DEFAULTWORKITEMTYPE name="Task" />
    <WORKITEMTYPE name="Bug" />
  </CATEGORY>
Ouvrez une console de commande en tant qu'administrateur et tapez les commandes suivantes pour télécharger sur le serveur la nouvelle définition des catégories.
cd %programfiles(x86)%\\Microsoft Visual Studio 11.0\Common7\IDE
witadmin importcategories /collection:http://tfsserveur:8080/tfs/DefaultCollection /p:TestProj /f:C:\Categories.xml

Modifier la configuration du processus :

Ouvrez une console de commande en tant qu'administrateur et tapez les commandes suivantes pour télécharger en local le fichier de configuration du processus :
cd %programfiles(x86)%\Microsoft Visual Studio 11.0\Common7\IDE
witadmin exportcommonprocessconfig /collection:http://tfsserveur:8080/tfs/DefaultCollection /p:TestProj /f:C:\commonConf.xml
Vous ajoutez à la categorie Bug l'état "New" en "Proposed" :
  <BugWorkItems category="Microsoft.BugCategory">
    <States>
      <State type="Proposed" value="New" />    
      <State type="InProgress" value="Active" />
      <State type="Complete" value="Closed" />
      <State type="Resolved" value="Resolved" />
    </States>
  </BugWorkItems>
Et vous ajoutez à la categorie Task  le statut "Resolved" en "Resolved" afin de visualiser aussi cette colonne dans le tableau de taches :
  <TaskWorkItems category="Microsoft.TaskCategory">
    <States>
      <State type="Proposed" value="New" />
      <State type="InProgress" value="Active" />
      <State type="InProgress" value="Resolved" />
      <State type="Complete" value="Closed" />
    </States>
  </TaskWorkItems>
Ouvrez une console de commande en tant qu'administrateur et tapez les commandes suivantes pour télécharger sur le serveur la nouvelle configuration du processus:
cd %programfiles(x86)%\Microsoft Visual Studio 11.0\Common7\IDE
witadmin importcommonprocessconfig /collection:http://tfsserveur:8080/tfs/DefaultCollection /p:TestProj /f:C:\commonConf.xml
Note : Si nous n'avions pas ajouter le champ Activity au Bug/Bogue, nous aurions l'erreur du type suivant:
The following element contains an error: TypeFields/TypeField[type='Activity'].
TF400501: The value of this element is set to: Microsoft.VSTS.Common.Activity. Y
ou must set the value to a field that exists in the work item types that are def
ined in: TaskWorkItems. These work item types must also have the following field
 defined:  TypeFields/TypeField[type='RemainingWork']. The field does not exist
in the following work item types: Bug.

Afficher et gérer les bogues

Vous pouvez maintenant planifier la capacité de votre équipe en considérant le temps restant sur les bogues et visualiser ou modifier ceux-ci depuis le tableau de tache du Web Access.
Il vous faudra tout comme pour les taches vous assurer que le bogue est attaché en tant qu'enfant à un User story/récit utilisateur et qu'il est bien assigné aux bonnes zones et itérations. Je conseille de créer le lien et vérifier les infos au moment du triage.

have a nice day.

mardi 30 avril 2013

Retour sur le Scrum Day 2013

Je vous expose (enfin!) mon retour d'expérience sur le Scrum Day du 11 avril 2013. Tout d'abord, mon impression générale est très positive, l'ambiance est chaleureuse avec énormément d'échanges. Je sens personne de "perdu" ou qui se soit retrouvé ici par hasard.

Après une session d'ouverture pleine d'excellentes idées et conseils pour travailler sur soi, et ses pratiques en équipe par Rorbert Richman. J'ai ensuite effectué une matinée très REX avec les 3 sujets :
  • Expérimentation de l'agilité au CNES, 
  • Projet Mobile chez Cetelem en Scrum,
  • 5 ans d'agilité à la DSI d'Orange.
Ces retours d'expérience mettent en lumière des points communs. L'effort et le courage sont essentiels pour l'adoption d'un processus agile puis son amélioration continue. La mise en place des bonnes pratiques se fait par étapes (presque une après l'autre). Globalement les équipes travaillent mieux ensemble et avec une meilleur satisfaction au travail.

L'après-midi fut moins terre à terre : embarquement et décollage pour objectif Mars ... version 2. Cet "Agile Game" montre bien l'équilibre délicat entre la production de valeur (le code), la réduction de la dette technique, l'analyse fonctionnelle/technique et la formation de l'équipe. La forme est à la fois très proche d'un jeu de société et des conditions de réalisation de Sprints. Ces 2 éléments transforme l'atelier en un moment convivial et passionnant.

La session de clôture m'a semblé comme le bouquet final de cette journée. Elle fut très animée et présentée par un excellent orateur Dominique Dupagne. De part son métier de médecin, il fait un intéressant parallèle entre le Vivant et l'Agile. Le système immunitaire serait par essence Agile (auto-organisation, création des anti-corps par itérations), nous serions des Sprints. L'idée est poussée très loin, voir jusque une certaine forme de provocation : l'agilité? c'est le retour à la vie !

have a nice day.

lundi 15 avril 2013

Ajouter l'effort au type Bogue

A plusieurs reprises, des clients m'ont demandé : comment intégrer le temps estimé, complété et restant sur une anomalie ? Vous pouvez traiter cette question facilement de 2 manières :
  1. ajouter une tache liée sur laquelle vous gérer les temps
  2. modifier le type Bug/Bogue pour y ajouter les champs nécessaires
Pour les modèles de processus Scrum v2.x et CMMI v2.x, je conseille d'utiliser la première (la seconde ne suivant pas la démarche et les principes de ces processus). Pour le modèle Msf Agile v5.x ou 6.x, les 2 approches peuvent être utilisées. La première est triviale à mettre en place. Pour la seconde, vous trouverez ci-dessous les étapes vous permettant d'intégrer la gestion des temps au type Bug/Bogue.
Pour réaliser les opérations, vous devez disposer des autorisations nécessaires le projet d'équipe. Les membres du groupe Project Administrators (ou plus) ont les autorisations nécessaires. Vous devez aussi installer Visual Studio 2012 Team Explorer sur votre machine.
Vous pouvez aussi effectuer les modifications à l'aide du Process Template Editor inclus dans les TFS Power Tools.

Télécharger en local les types Bug et Task

Ouvrez une console de commande en tant qu'administrateur et tapez les commandes suivantes pour télécharger les définitions des types Bug et Task:
cd %programfiles(x86)%\Microsoft Visual Studio 11.0\Common7\IDE
witadmin exportwitd /n:Bug /f:C:\Bug.xml /collection:http://tfsserveur:8080/tfs/DefaultCollection /p:TestProj
witadmin exportwitd /n:Task /f:C:\Task.xml /collection:http://tfsserveur:8080/tfs/DefaultCollection /p:TestProj

Modifier le type Bug/Bogue

D'abord, vous copiez les 3 définitions de champs de référence Microsoft.VSTS.Scheduling.xxx depuis le fichier Task.xml et les collez dans le fichier Bug.xml sous le noeud FIELDS.
<FIELD name="Remaining Work" refname="Microsoft.VSTS.Scheduling.RemainingWork" type="Double" reportable="measure" formula="sum">
        <HELPTEXT>An estimate of the number of units of work remaining to complete this task</HELPTEXT>
      </FIELD>
      <FIELD name="Original Estimate" refname="Microsoft.VSTS.Scheduling.OriginalEstimate" type="Double" reportable="measure" formula="sum">
        <HELPTEXT>Initial value for Remaining Work - set once, when work begins</HELPTEXT>
      </FIELD>
      <FIELD name="Completed Work" refname="Microsoft.VSTS.Scheduling.CompletedWork" type="Double" reportable="measure" formula="sum">
        <HELPTEXT>The number of units of work that have been spent on this task</HELPTEXT>
</FIELD>
Puis, vous copiez aussi la définition de l'interface pour ces 3 champs depuis le fichier Task.xml (cherchez Effort). Vous collez ensuite ces définitions dans le fichier Bug.xml  dans une nouvelle colonne sous le même Group que la colonne Planning. Vous pouvez remaniez l'interface comme vous le souhaitez.
Pour le type Bug de la version Msf Agile v5.x, indiquez 50 pour les attributs percentwidth des 2 colonnes contenant Planning et Effort (Hours).
(Pour le type la version Msf Agile v6.x, indiquez 25 pour les attributs percentwidth des 4 colonnes  du groupe contenant Planning et Effort (Hours) )
        <Group>
          <Column PercentWidth="50">
            <Group Label="Planning">
              <Column PercentWidth="33">
                <Control FieldName="Microsoft.VSTS.Common.StackRank" Type="FieldControl" Label="Stack Ran&amp;k:" LabelPosition="Left" NumberFormat="DecimalNumbers" MaxLength="10" />
              </Column>
              <Column PercentWidth="33">
                <Control FieldName="Microsoft.VSTS.Common.Priority" Type="FieldControl" Label="&amp;Priority:" LabelPosition="Left" />
              </Column>
              <Column PercentWidth="33">
                <Control FieldName="Microsoft.VSTS.Common.Severity" Type="FieldControl" Label="Se&amp;verity:" LabelPosition="Left" />
              </Column>
            </Group>
          </Column>
          <Column PercentWidth="50">
            <Group Label="Effort (Hours)">
              <Column PercentWidth="33">
                <Control FieldName="Microsoft.VSTS.Scheduling.OriginalEstimate" Type="FieldControl" Label="Original &amp;Estimate:" LabelPosition="Left" />
              </Column>
              <Column PercentWidth="33">
                <Control FieldName="Microsoft.VSTS.Scheduling.RemainingWork" Type="FieldControl" Label="Re&amp;maining:" LabelPosition="Left" />
              </Column>
              <Column PercentWidth="33">
                <Control FieldName="Microsoft.VSTS.Scheduling.CompletedWork" Type="FieldControl" Label="Comp&amp;leted:" LabelPosition="Left" />
              </Column>
            </Group>
          </Column>
        </Group>

Mettre à jour le type Bug/Bogue dans TFS 

Ouvrez une console de commande en tant qu'administrateur et tapez les commandes suivantes pour télécharger sur le serveur la nouvelle définition du type Bug/Bogue dans le projet d'équipe :
cd %programfiles(x86)%\Microsoft Visual Studio 11.0\Common7\IDE
witadmin importwitd /f:C:\Bug.xml /collection:http://tfsserveur:8080/tfs/DefaultCollection /p:TestProj

have a nice day.

vendredi 5 avril 2013

Sélectionner les projets pour l'analyse de code

A l'origine, j'ai eu cette problématique car Code Analysis génère une erreur sur l'analyse d'une librairie portable (l’anomalie est signalée sur le site connect ). J'ai donc cherché une première solution de contournement pour lancer l'analyse de code lors d'une compilation automatisée.

L'objectif est de lancer l'analyse de code sur les projets lors de la Build automatisée. Je souhaite aussi  sélectionner le jeu de règles utilisé pour chaque projet.

Configurer l'exécution de l'analyse de code

Pour que l'analyse de code ne soit pas lancée à chaque fois que le développeur compile, je vais la paramétrer uniquement sur une configuration particulière: Release et Any CPU. Celle-ci n'est habituellement pas utilisée sur les postes de développement.
Pour le mode Release et Any CPU, j'active pour chaque projet souhaité l'action exécuter l'analyse de code à la compilation.
Vous pouvez changer le paramètre dans l'interface des propriétés du projet sous Visual Studio (onglet Code Analysis).
Vous pouvez aussi utiliser votre outil de recherche/remplacement de texte préféré sur les fichiers .csproj. Il suffit d'ajouter dans le noeud suivant :
<propertygroup condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
</propertygroup>
le contenu suivant
<RunCodeAnalysis>true</RunCodeAnalysis>

Choisir les ensembles de règles à vérifier

Il nous faut encore choisir l'ensemble de règles à vérifier pour chaque projet.
Vous pouvez le faire d'un coup pour tous les projets et toutes les configurations depuis les propriétés de la solution et sélectionner Common Properties > Code Analysis Settings. Vous pouvez aussi ouvrir la fenêtre d'analyse de code depuis le menu Analyse > Windows > Code Analysis et cliquez sur Configure
Il reste plus qu'à choisir les jeux de règles pour chacun des projets dans l'interface ci-dessous
Le développeur peut alors lancer l'analyse de code sur son poste, il doit basculer temporairement en Release et compiler à nouveau la solution (Rebuild)

Configurer la définition de Build

Enfin, vous configurez la définition de Build pour compiler la solution en configuration Release et plateforme Any CPU. Éditez la définition, modifiez le paramètre Items to Build :
Il vous reste à mettre en file d'attente une nouvelle compilation pour vérifier le paramétrage.

have a nice day.

mardi 2 avril 2013

Session TechDays 2013

Aux Techdays 2013, j'ai présenté avec Cristal Union notre retour d’expérience sur le développement d’applications Windows Store avec Visual Studio ALM 2012.

Au cours de la session, nous avons abordé l'ensemble des aspects qui nous ont permis la réussite et la qualité des développements :
  • expression du besoin via storyboard et feedback, 
  • méthodologie Agile,
  • déploiement et automatisation des tests techniques,
  • plan de recette et tests fonctionnels,
  • points à retenir et perspectives de la plateforme.
Vous pouvez accéder à la vidéo et aux diapositives sur le site des TechDays 2013 :
http://www.microsoft.com/france/mstechdays/programmes/2013/f…

have a nice day.

jeudi 21 mars 2013

Témoignage sur TFS 2012

Il y a quelques mois, j'ai eu la chance d'accompagner avec ma société la coopérative Comptoir agricole contrainte de concevoir son propre progiciel de gestion intégré.
La coopérative a retenu Team Foundation Server 2012 pour garantir la qualité de ses développements et parvenir à une solution évolutive.
Lors des deux premières phases (4 mois) au forfait, réalisées par ma société, nous avons posé  les bases techniques et le processus Agile. Evidemment, je me suis focalisé sur la configuration de TFS, la gestion de projet Agile, l'automatisation des processus.
A l'heure où j'écris, une équipe Comptoir agricole/ma société continue activement le développement du progiciel.

les bénéfices principaux :
  • Elaboration d'une solution évolutive et adaptée aux besoins métier très spécifiques du groupe
  • Automatisation de processus complexes
  • Démarche structurée
  • Qualité des développements
  • Contrôles automatisés des règles de développement
  • Uniformisation et optimisation des pratiques
Pour en savoir plus, je vous invite à lire le Témoignage sur TFS 2012.

have a nice day.

dimanche 17 mars 2013

Formation en francais Visual Studio ALM

L'équipe DPE Microsoft France propose un ensemble très intéressant de +20 ateliers et de cours pour découvrir les outils de la gamme Visual Studio ALM.
Si vous démarrer avec l'utilisation de Team Foundation Server, je vous conseille vivement d'y investir un peu de votre temps. Vous gagnerez aussi beaucoup de temps, si vous souhaitez découvrir les nouveautés apparues depuis les versions 2008 et 2010.

Les ateliers proposés se basent sur une  machine virtuelle. Vous pouvez télécharger son guide d'installation et d'utilisation depuis le site. Les ateliers abordent des sujets très divers comme :

  • gestion de projets Agile
  • révision de code
  • l'exécution d'un plan de test
  • les outils d'architecture de code
  • le débogage avec Intellitrace

Pour démarrer avec l'ALM, rendez-vous dans la section Scénarios > Formation Exclusive sur ALM du site visualstudio.fr.

Si vous avez des remarques ou ne trouvez simplement pas l'atelier souhaité. Je pourrai sans doute compléter par un billet sur ce blog ou proposer un nouvel atelier. J'ai relu l'ensemble des documents avant publication, alors votre avis m’intéresse!

have a nice day.

dimanche 10 mars 2013

Agile Tour 2012 Paris

A l'occasion de l'Agile Tour 2012 Paris, j'ai eu la chance d'animer une session sur les outils de la suite Visual Studio ALM.
Celle-ci détaille les principales nouveautés apportées par la version 2012.

  • le prototypage et storyboarding, 
  • la définition et l'ordonnancement du Backlog,
  • la planification Agile des itérations,
  • le suivi (tableau des taches, kanban, burndown chart),
  • la traçabilité des spécifications/code source,
  • les tests (ATDD, les tests de l'interface),
  • le feedback client en continu.

mardi 5 mars 2013

Emissions techniques Bon App!

En novembre 2012, j'ai enregistré 3 émissions techniques. Celles-ci sont disponibles sur le site Visual Studio France.
Pour les lire, il vous faudra naviguer vers la page Bon App ! / L'emission puis cliquer sur le bouton Connectez-vous pour voir les émissions techniques.

Sur le thème Qualité du code et tests techniques, j'ai présenté 2 émissions :
  • Intégration des Tests unitaires et couverture de code au processus de Build, en bref j'explique sur un cas concret comment réaliser ses tests unitaires, mesurer la couverture de code associée et intégrer le tout dans un processus de Build
  • Visual Studio 2012 : outils de diagnostic, en bref j'explore une application Web concrète avec les 5 principaux outils qualité (analyse de code, métriques de code, clones de code, révision de code et validation de l'architecture)
Sur le thème Tests fonctionnels, j'ai présenté 1 émission :
  • Le Feedback en continu, en bref j'explique pourquoi/comment/quels outils nous avons utilisés pour tester en continu une application Web et donner un retour au plus tôt à l’équipe de développement.
have a nice day.

dimanche 3 mars 2013

Démarrer avec TFS 2012


Les diapositives d'un webcast où je présente les points importants pour démarrer ou migrer vers la version 2012 de Team Foundation Server.

Attention cette présentation a été réalisée en avril 2012 avant la sortie officielle du produit. Il peut y avoir quelques différences avec la version finale.
have a nice day.

mercredi 27 février 2013

Actionner ses processus qualité


L'idée de premier webcast réalisé début 2012 est d'expliquer un méthode simple pour améliorer les compétences et la maîtrise de l'équipe sur divers sujets de la gestion du cycle de vie de l'application.
L'ensemble est illustré avec concrètement par avec des processus supportés par Visual Studio ALM.

les diapositives du webcast :

have a nice day.