cours_projets_l3_old/CM2/CM2.md

---

title: "Projets, CM2"

date: 2016-05-21

Conception d’un logiciel

Quoi-qu’est-ce ?

• « plan du code » (diagrammes de classes...)
• au début du projet, permet de prévoir le code à écrire
• pendant le projet, permet de suivre l’avancée du projet
• à la fin du projet, permet de documenter le code (maintenance)

$\rightarrow$ doit correspondre aux fonctionnalités prévues et au code réel

En pratique

• représentation graphique + explications
• si possible, utiliser un formalisme classique (UML)
• utiliser plusieurs niveaux d’abstraction (vue d’ensemble, vues détaillées)

## Étape de conception

• étape très importante, à faire avant le développement
• évite ”d’avoir à tout casser” au cours du développement
• permet de répartir le travail et de planifier plus finement

Quelques conseils

• faire simple, logique, classique (MVC, design patterns...)
• granularité : ne pas trop détailler sauf si important/incertain/complexe
• vérifier a priori que la conception permet d’implémenter les fonctionnalités prévues dans le cahier des charges

Développement d’un logiciel

## Méthode pour écrire du code

• comprendre le travail à faire (fonctionnalité/classe à implémenter)
• découper en étapes et les ordonner
• implémenter (coder, compiler, tester) étape par étape

## Conseils sur le développement en équipe

• faire le point régulièrement : travail fait, travail à faire
• répartir le travail de façon à éviter les conflits (fichiers différents)
• commits réguliers, branches si nécessaire
• faire attention à respecter le cahier des charges et la conception

## Programmation en binômes

• principe :
  • un secrétaire + un relecteur sur une même machine
  • les deux participent activement
  • changer les rôles fréquemment
• intérêts :
  • moins d’erreurs
  • réflexions complémentaires
  • motivation, convivialité (ou pas, mais bon...)
• à utiliser quand le travail n’est pas complètement trivial (donc tout le temps pour les projets L3)

Tests unitaires

• souvent : test « avec un printf » $\rightarrow$ pas bien
  • principe des tests unitaires :
  • écrire des petites fonctions de test en même temps que le code
  • compiler toutes les fonctions de test dans un programme de test
  • exécuter le programme de test
  • vérification et non-régression automatiques
• attention : détection d’erreurs $\neq$ preuve

$\rightarrow$ à utiliser pour les modules de base (traitement de données) voire plus

## Programmation par pseudo-code

• principe :
  • commencer par écrire le pseudo-code de l’algo en commentaire
  • traduire chaque ligne de pseudo-code en code réel
  • laisser le pseudo-code en commentaire
• intérêt :
  • code plus facile à écrire
  • code plus facile à relire

$\rightarrow$ très utile quand le code à écrire n’est pas trivial

## Gestion d’erreurs

• assertions
• logs
• codes de retour, variables d’état
• exceptions

$\rightarrow$ problème difficile

$\rightarrow$ se mettre d’accord sur la façon de faire au début du projet

## Conventions de code

• formatage du code, nommage des variables...
• conventions à définir et à respecter au niveau du projet
• permet d’avoir un code plus facile à lire
• utiliser des conventions classiques ou les expliciter dans la documentation

## Exemple de conventions de code C++

• notation dromadaire

• un nom de classe commence par une majuscule :

  class Event ...
  

  • préfixe _ pour les attributs : cpp std::string _summary ;

• préfixe ptr pour les pointeurs :

  icalcomponent * _ptrIcal ;
  

  • un nom de fonction commence par un verbe : cpp void updateDataFromIcal(); icalcomponent * getPtrIcal() const ;

• maximum 80 caractères par ligne

• ...

Quelques outils de développement à décider

• langages, bibliothèques...
• outils de compilation, test, déploiement
• outils de gestion de code source (git, svn...)
• outils de gestion de projets (github, redmine, trac, sourceforge...)

Gestion de projet avec github

Github

• https://github.com
• hébergement de dépôts git
• gestion des collaborateurs + droits d'accès
• gestion de projet basique (tickets, jalons, pulls request, wiki, stats...)

Créer un projet

• à partir d'un projet existant : fork
• nouveau projet :

Gestion des collaborateurs

Ajouter un jalon

Voir les jalons

Ajouter un ticket

Voir les tickets

Fermer un ticket

• via l'interface web
• via les messages de commit : close #1

Gestion de code source avec git

Git

• système de gestion de code source
• fonctionnalités : journalisation, synchronisation...
• implémentations : client console, gui
• notions principales :
  • commit
  • dépôt
    

Notion de commit

• état des fichiers versionnés
• seules les modifications par rapport au commit précédent sont stockées
• branches

• historique des commits

          H -- I
         /
  A -- B -- C -- F -- G
    \      /
     D -- E
  

Notion de dépôt (repository)

• ensemble des commits du projet
• système décentralisé :
  • chaque collaborateur a un dépôt complet et équivalent
  • les dépôts peuvent se synchroniser
  • souvent, on synchronise via un dépôt sur un serveur (github)

Workflow git

• initialisations :
  • configurer le client git
  • créer un dépôt git
• déroulement du projet :
  • ajouter, modifier, supprimer des fichiers
  • valider les modifications (commit)
  • récupérer les modifications du serveur (pull)
  • corriger les conflits éventuels
  • envoyer les modifications sur le serveur (push)

Configurer le client git

• installer git :

  sudo apt-get install git
  

• configurer l'utilisateur :

  git config --global user.name "Julien Dehos"
  git config --global user.email dehos@nimpe.org
  

• paramétrer le client :

  git config --global core.editor emacs
  git config --global http.proxy http://user:pass@proxyhost:proxyport
  

Quelques commandes git

---|---| git clone | récupère un dépôt | git status | affiche l'état courant des fichiers | git add <fichiers> | demande à Git de versionner des fichiers | git mv <nom1> <nom2> | renomme des fichiers versionnés | git rm <fichiers> | supprime des fichiers versionnés | git commit <fichiers> | valide les modifications des fichiers spécifiés | git commit -a | valide les modifications de tous les fichiers versionnés | git commit -am "message" | valide les modifications avec le message donné | git log | affiche la liste des commits | git diff | affiche les modifications courantes (par rapport au dernier commit)| git checkout -- . | supprime les modifications courantes (revient au commit) | git pull | récupère les modifications du dépôt distant et les intègre dans le dépôt local | git push | envoie les commits du dépôt local sur le dépôt distant |

Quelques conseils

• faire des commits réguliers et correspondant à des petites tâches successives (ou à des tickets)
• ne pas commiter un projet cassé (par exemple, du code qui ne compile pas)
• ne pas versionner les fichiers auto-générés
• utiliser git mv et git rm pour déplacer et supprimer des fichiers commités
• éviter les conflits potentiels en organisant le travail de telle sorte que les intervenants aient à travailler sur des fichiers différents

Récupérer un dépôt github

$ git clone https://juliendehos@github.com/juliendehos/projet_l3

Clonage dans 'projet_l3'...
remote: Counting objects: 3, done.
remote: Total 3 (delta 0), reused 0 (delta 0), pack-reused 0
Dépaquetage des objets: 100% (3/3), fait.
Vérification de la connectivité... fait.

Ajouter des fichiers

$ git add proto.cpp Makefile 

$ git status

Sur la branche master
Votre branche est à jour avec 'origin/master'.
Modifications qui seront validées :
  (utilisez "git reset HEAD <fichier>..." pour désindexer)

	nouveau fichier : Makefile
	nouveau fichier : proto.cpp

Valider un commit

$ git commit -am "mise en place du code, close #1"

[master eab4260] mise en place du code, close #1
 2 files changed, 9 insertions(+)
 create mode 100644 Makefile
 create mode 100644 proto.cpp

Envoyer des commits sur un serveur

$ git push

Password for 'https://juliendehos@github.com': 
Décompte des objets: 4, fait.
Delta compression using up to 4 threads.
Compression des objets: 100% (3/3), fait.
Écriture des objets: 100% (4/4), 447 bytes | 0 bytes/s, fait.
Total 4 (delta 0), reused 0 (delta 0)
To https://juliendehos@github.com/juliendehos/projet_l3
   bd1f597..eab4260  master -> master

Travail à réaliser

## Au début du projet

• sur github :
  • créer un compte pour chaque étudiant (ou binôme) du groupe
  • créer un dépôt pour le groupe (et ajouter les collaborateurs)
• faire une conception prévisionnelle du logiciel
• faire un planning prévisionnel (et les tickets/jalons correspondants sur github)

## Tout au long du projet

• utiliser git pour réaliser le projet (code, documentations, cahier des charges, rapport...)
• utiliser github pour suivre le déroulement du projet
• faire le point régulièrement pour mettre à jour la conception du logiciel et la répartition du travail