---
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 :
```cpp
class Event ...
```
- préfixe _ pour les attributs :
```cpp
std::string _summary ;
```
- préfixe ptr pour les pointeurs :
```cpp
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](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

![](github_nouveau_projet.png)

## Gestion des collaborateurs

![](github_collaborateurs.png)  

## Ajouter un jalon

![](github_milestone.png)

## Voir les jalons

![](github_milestone_2.png)

## Ajouter un ticket

![](github_issue.png)

## Voir les tickets

![](github_issue_2.png)      

## Fermer un ticket

- via l'interface web
- via les messages de commit : `mise en place du code, close #1`

![](github_issue_3.png)



# 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)

![](concepts_depots_git.svg)

## 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 (1)

---|---|
`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) |

## Quelques commandes git (2)

---|---|
`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 |
`git branch` | affiche les branches locales | 
`git ls-remote` | affiche les branches distantes |
`git branch <branche>` | crée une nouvelle branche |
`git checkout <branche>` | change de branche |
`git push -u origin <branche>` | envoie une nouvelle branche distante |
`git merge <branche>` | fusionne une branche dans la branche courante |

## 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
```

## Branches locales

- créer une branche locale :  

```
$ git branch proto2
```

- voir les branches locales :

```
$ git branch
* master
  proto2
```

- changer de branche :

```
$ git checkout proto2
Basculement sur la branche 'proto2'
```

## Branches distantes

- voir les branches distantes :

```
$ git ls-remote
From https://juliendehos@github.com/juliendehos/projet_l3
4fca7ad38b299acdb7453547d5c9fc1d2494e4cc	HEAD
4fca7ad38b299acdb7453547d5c9fc1d2494e4cc	refs/heads/master
```

- envoyer une nouvelle branche sur le serveur `origin` :

```
$ git push -u origin proto2
Password for 'https://juliendehos@github.com': 
Décompte des objets: 2, fait.
Delta compression using up to 4 threads.
Compression des objets: 100% (2/2), fait.
Écriture des objets: 100% (2/2), 266 bytes | 0 bytes/s, fait.
Total 2 (delta 0), reused 0 (delta 0)
To https://github.com/juliendehos/projet_l3
 * [new branch]      proto2 -> proto2
La branche proto2 est paramétrée pour suivre la branche distante proto2 depuis origin.
```

## Fusion de branches

- exemple :

```
  -- B (proto2)               -- B -- (proto2)
 /                  ->       /       \
A -- C (master)             A -- C -- D (master)
```

- passer sur la branche qui doit recevoir la fusion :

```
$ git checkout master
Basculement sur la branche 'master'
```

- fusionner :

```
$ git merge proto2 
Merge made by the 'recursive' strategy.
 proto2.cpp | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 proto2.cpp
```

## 

- éventuellement, vérifier le log :

```
$ git log --oneline --decorate --graph
*   82eb957 (HEAD, master) Merge branch 'proto2'
|\  
| * e29caa2 (origin/proto2, proto2) début proto2
* | 7c13fc0 modif proto1
|/  
* 4fca7ad (origin/master) mise en place du code, close #1
```

# Travail à réaliser

## Au début du projet

- sur [github](https://github.com) :
    - 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