Intégrer SonarQube à vos projets .Net

On est tous confronté à l'exigence d'avoir une certaine qualité de nos applications. Mais souvent pris par les délais, on cherche à minimiser (voir négliger) la charge demandée par cela. Ainsi, je vous propose dans cet article un moyen rapide de mettre en place Sonar sur vos projets .net et par la suite de concentrer votre charge surtout sur l'analyse et suivi des indicateurs. Mais avant de commencer, il semble nécessaire de rappeler quelques notions liées à la qualité logicielle.

Démarche d’amélioration des performances Drupal

Améliorer les performances d'un site (Drupal ou non) peut se révéler être une tâche complexe puisque, par définition, tous les niveaux d'architecture matérielle et logicielle sont potentiellement concernés (Apache, PHP, MySQL, infrastructure).

Une démarche rigoureuse et méthodique est impérative afin de ne pas se lancer dans des optimisations en aveugle. En voici les principales étapes :

Constater, Reproduire, Diagnostiquer, Prioriser, Corriger, Mesurer, Itérer

Pour chaque étape, nous mentionnerons certains outils classiquement utilisés, sans être exhaustif. Chacun d'entre eux mériterait un développement à part.

Outils pour la qualité logicielle en PHP

Cet article est une suite logique de l’article « Culture pour la qualité logicielle PHP », lequel vous a présenté les différents aspects à appréhender chaque jour afin d’avoir une culture de conception de produits de qualité. Aujourd’hui nous  verrons les outils  les plus utilisés à notre disposition afin de mettre en pratique ces aspects, nous n’expliquerons pas en détails l’installation, ni l’utilisation de ces outils mais nous vous les présenterons de manière globale afin de percevoir leurs importance dans la qualité logicielle. Nous vous présentons une liste, non exhaustive, des outils ayant des versions open source.

La qualité logicielle en PHP

Quality_icon-checklist

Aujourd’hui, les développeurs passent beaucoup de temps à faire et défaire du code, à toujours écrire des fonctionnalités similaires de projet en projet, à s’arracher les cheveux sur le code d’un autre, à développer des fonctionnalités complètement inutiles pour le client, à faire des var_dump, print_r, die, exit régulier pour debugger.

Pourquoi tant de souffrance quotidienne et de perte de temps ?

Mon propos portera sur une notion beaucoup utilisée en génie logiciel, qui peut permettre à chacun d’atténuer ses souffrances, à savoir la qualité logicielle qui est, selon moi, un réflexe que doivent avoir toutes équipes projet durant la vie du projet.

La qualité logicielle peut se définir comme étant un ensemble de tâches à effectuer et de moyens mise en place afin de donner une satisfaction optimale aux besoins du client, des utilisateurs, en somme, à toutes les équipes et de tendre vers le zéro défaut.

L’interface fluide : vers un code orienté métier

Introduction

La maintenabilité d'une application dépend fortement de la lisibilité du code source sous-jacent. Cette lisibilité peut être améliorée par : 

  • l'introduction (mesurée) de commentaires dans le code
  • la présence sysématique de Javadoc
  • la vérification automatique à l'aide d'outils comme CheckStyle et PMD (règles de nommage, mesure de complexité...etc)
  • la revue de code effectuée par un développeur tiers

L'objectif de ce billet est de présenter une technique supplémentaire permettant d'améliorer la lisibilité du code : l'interface fluide

Exemple

public class Person {
    
    private String firstName;
    private String lastName;
    private Person father;
    private Person mother;
    public void setFirstName(String firstName){
        this.firstName = firstName
    }
    public void setLastName(String lastName){
        this.lastName = lastName
    }
    public void setFather(Person father){this.father = father}
    public void setMother(Person mother){this.mother = mother}
  
    //Getters volontairement omis pour plus de clarté
    ...
}

Ceci est une classe Person pouvant servir d'entité dans une application d'arbre généalogique. Créons un objet de ce type : 

//La personne
Person person = new Person();
person.setFirstName("Youri");
person.setLastName("Gagarine");
//Le papa
Person father= new Person();
father.setFirstName("Alexeï");
father.setLastName(" Ivanovitch");
//La maman
Person mother = new Person();
mother.setFirstName("Anna");
mother.setLastName("Timofeïevna");
//La famille
person.setFather(father);
person.setMother(mother);

Premier constat : ce code est verbeux. On aimerait qu'il ressemble à : 

//La personne
Person person = new Person().setFirstName("Youri").setLastName("Gagarine");
//Le papa
Person father= new Person().setFirstName("Alexeï").setLastName("Ivanovitch");
//La maman
Person mother = new Person().setFirstName("Anna").setLastName("Timofeïevna");
//La famille
person.setFather(father).setMother(mother);

Notre code est désormais à la fois moins verbeux et beaucoup plus lisible. Même une personne non-technique pourrait lire : 
  • Créer  une première personne dont le prénom et le nom....
  • Créer  une deuxième personne dont le prénom et le nom....
  • Créer  une troisième personne dont le prénom et le nom....
  • Lier la première personne au deux autres à l'aide des liens de paternité et de maternité.
Pour pouvoir bénéficier de cette "expressivité", il suffit de modifier les setters de la classe Person afin que chacun de ces setters renvoie l'objet this

public class Person {
    .....
    public Person setFirstName(String firstName){
        this.firstName = firstName; 
        return this;
    }
    public Person setLastName(String lastName){
        this.lastName = lastName;
        return this;
    }
    public Person setFather(Person father){
        this.father = father ;
        return this;
    }
    public Person setMother(Person mother){
        this.mother = mother ; 
        return this;
    }
    ...
}

Ici, on renvoie l'objet this mais rien n'empêche de renvoyer un objet d'un autre type. L'objectif de cette approche est de concevoir une API centrée sur le métier de l'application que l'on désire développer (Domain Specific Language). A titre d'exemple, L'API Criteria dans JPA 2.0 utilise cette technique pour construire les requêtes.

Conclusion

L'interface fluide aide à concevoir un code concis et orienté métier.

Références