Gestionnaire de sources Flashcards
Introduction
Gestionnaire de sources est un système de contrôle de versions.
Gestionnaire de sources autorise plusieurs personnes à travailler sur des
documents communs (chacun en ayant une copie locale).
Gestionnaire de sources est une partie prenante de l’approche agile.
Introduction
Gestionnaire de sources permet :
ü suivi et historique des modifications au cours du temps
ü synchronisations entre les différentes versions des documents et gestion de la
concurrence
ü retours arrière vers versions plus anciennes et imputabilité des changements
Introduction
Avant les gestionnaires de sources :
ü gestion manuelle des copies, des sauvegardes et des versions et possibilité
d’ écraser les modifications des autres
ü suivi et historique des modifications manuel dans un fichier et difficulté de
retracer les changements
Problème à résoudre
Solution 1 : le lock
Solution 2 : copymodify-merge (phase1)
Gestionnaire de sources
au quotidien
q Mettre à jour votre copie de travail
ü update
q Réaliser des modifications
ü add
ü delete
ü copy
ü move
q Examiner vos changements
ü status
ü diff
q Publier vos changements
ü commit
Gestionnaire de sources
au quotidien
Création d’un dépôt
Import d’un projet dans un dépôt
Contrôle d’accès au dépôt
Organisation dépôt & projet
Création d’un tag
Création d’une branche de développement
Changer de branche :
q Merge vers branche principale
q Revenir à version précédente
Gestionnaire de sources
Fonctionnalités MoSCoW
Must
- Dépôt centralisé
- Historique des modifications
- Mises à jour des sources
- Consulter les anciennes versions
- Retour en arrière
- Branches
- Appliquer une modification
- dans plusieurs branches
Should
- Fonction comparaison (diff)
- Intégration dans les IDE, système de suivi de bugs, système de gestion de projets
- Ligne de commande
- Interface graphique
Could
- Dépôt local
- Interface web
- Déplacer un fichier en conservant l‘historique des changements
Gestionnaire de sources
Inclusion VS Exclusion
INCLURE
q Code source
q Prototypes
q Documents tapés
ü tests, documentation, etc.
ü Favorisez le format texte
ü Format binaire difficile a gérer a long terme
EXCLURE
q Code généré
ü fichiers de configuration IDE
ü générateur automatisé de code
q Les librairies
ü JAR du projet
q Documents d’analyse et diagrammes de conception
ü Wiki
Types de gestionnaires
de sources :
ü Centralisé - SVN
ü Décentralisé - Git
Conclusion
q La construction automatisée et le gestionnaire de sources est une partie prenante de l’approche agile.
q Collaboration, automatisation, etc.
q Plusieurs outils disponibles.
ü Gratuit, décentralisé, etc.
q Qualités recherchées
ü Simplicité, Performance, Flexibilité, Intégration, etc.
q Outil indispensable
ü Indépendamment de la taille de l’équipe (même un seul
développeur) ou du projet
JSON
{
“status”: “OK”,
“student_id”: 12345,
“program”: “Mobile App”,
“first_name”: “Zied”,
“last_name”: “Zaier”,
“date_birth”: “10-10-99”,
“active”: true,
“GPA”: 3.7,
“courses”: [
“Applied Mathematics”,
“Introduction to Mobile”,
“Databases Structures “,
“Algorithms, Pseudocode”,
“Debugging programs”
]
}
– Utilise la syntaxe des objets JavaScript
! Format de structure de données
– Compréhensible par une machine et un humain
! Fichier texte
– Extension : .json
! Facile à mettre en œuvre et utiliser
– Simple et léger
! Portabilité
– Interopérabilité multi-plateforme
JSON
Deux structures :
Objet
ü {}
ü {chaîne : valeur}
ü {chaîne : valeur, chaîne : valeur, …}
q Tableau
ü []
ü [valeur]
ü [valeur, valeur, …]
q Aucun mot-clé réservé
q Sensible à la casse
JSON
Objet
{
“status”: “OK”,
“student_id”: 12345,
“program”: “Mobile App”,
“first_name”: “Zied”,
“last_name”: “Zaier”,
“date_birth”:”10-10-99”,
“active”: true,
“GPA”: 3.7
}
q délimité par des accolades { }
q Contient la paire propriété et valeur séparée par un “:”
q Les couples sont séparés par une virgule
q propriété définie par une chaîne de caractères
JSON
Tableau
[
“Applied Mathematics”,
“Introduction to Mobile”,
“Databases Structures”,
“Algorithms, Pseudocode”,
“Debugging programs”
]
q délimité par des crochets [ ]
q Liste de valeurs ordonnées, sans propriété
q valeurs séparées par une virgule
q tableau comme pour Java ou C++
JSON
Valeur
qLes type de valeurs possibles sont :
ü Chaîne de caractères
ü Nombre
ü Booléen
ü null
ü Objet
ü Tableau
Code source
Créer un JSON
{
“status”: “OK”,
“student_id”: 12345,
“program”: “Mobile App”,
“first_name”: “Zied”,
“last_name”: “Zaier”,
“date_birth”: “10-10-99”,
“active”: true,
“GPA”: 3.7,
“courses”: [
“Applied Mathematics”,
“Introduction to Mobile”,
“Databases Structures”,
“Algorithms, Pseudocode”,
“Debugging programs”
]
}
{…
.JSONObject etudiant = new JSONObject();
etudiant.accumulate(“status”, “OK”);
etudiant.accumulate(“student_id”, 12345);
etudiant.accumulate(“program”, “Mobile App”);
etudiant.accumulate(“first_name”, “Zied”);
etudiant.accumulate(“last_name”, “Zaier”);
etudiant.accumulate(“date_birth”, “10-10-99”);
etudiant.accumulate(“active”, true);
etudiant.accumulate(“GPA”, 3.7);
JSONArray cours = new JSONArray();
cours.add(“Applied Mathematics”);
cours.add(“Introduction to Mobile”);
cours.add(“Databases Structures”);
cours.add(“Algorithms, Pseudocode”);
cours.add(“Debugging programs”);
etudiant.accumulate(“courses”,cours);
System.out.println(etudiant.toString());
…..}
Code source
Parser un JSON
{
“status”: “OK”,
“student_id”: 12345,
“program”: “Mobile App”,
“first_name”: “Zied”,
“last_name”: “Zaier”,
“date_birth”: “10-10-99”,
“active”: true,
“GPA”: 3.7,
“courses”: [
“Applied Mathematics”,
“Introduction to Mobile”,
“Databases Structures “,
“Algorithms, Pseudocode”,
“Debugging programs”
]
}
{…..
String titreCours;
JSONObject students= JSONObject.fromObject(json);
String status=students.getString(“status”);
…..
int student_id= students.getInt(“student_id”);
…..
double GPA= students.getDouble(“GPA”);
…..
boolean active=students.getBoolean(“active”);
…..
JSONArray cours = students.getJSONArray(“courses”);
for(int i=0; i<cours.size();i++) {
titreCours = cours.getString(i);
….
}
…..
…..}
import java.io.IOException;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
public class JavaApplication2 {
public static void main(String[] args) throws IOException {
JSONObject employee= new JSONObject();
employee.accumulate(“employeeid”, “123456”);
employee.accumulate(“fname”, “Zied”);
employee.accumulate(“lname”, “Zaier”);
employee.accumulate(“sin”, 123456789);
employee.accumulate(“retired”,false);
employee.accumulate(“salary”, 9999.99);
JSONObject address= new JSONObject();
address.accumulate(“streetnumber”, 1001);
address.accumulate(“streetname”, “Sherbrooke”);
address.accumulate(“postalcode”, “H3S1S1”);
employee.accumulate(“address”, address);
JSONArray projects = new JSONArray();
JSONObject project = new JSONObject();
project.accumulate(“name”,”mobile app project”);
project.accumulate(“nbrh”,55);
projects.add(project);
project.clear();
project.accumulate(“name”,”Backend project”);
project.accumulate(“nbrh”,77);
projects.add(project);
project.clear();
project.accumulate(“name”,”Database project”);
project.accumulate(“nbrh”,100);
projects.add(project);
employee.accumulate(“projects”, projects);
utilities.FileWriter.saveStringIntoFile(“json/employee.”
+ “json”, employee.toString());
}
}
Les branches principales
branche origin/master
develop
Nous considérons le origin/master être la branche principale où
le code
source de la tête de la branche (HEAD) reflète toujours un état prêt pour la mise en production.
Branches de support
vos branches doivent rester locales (ne seront pas poussées sur origin);
Par contre, lorsque vous travaillez dans une entreprise ou sur un projet open-source, vous devez pousser vos branches sur origin pour pouvoir ouvrir des Pull Requests
les branches de fonctionnalités, ;
les branches de version;
les branches de correctifs;
ces branches ont toujours une durée de vie limitée, puisqu’elles seront éventuellement supprimées
Branches de fonctionnalités (Feature) parfois appelées branches de sujet - topic
peut bifurquer à partir de develop ou version et être fusionnée à nouveau dans develop;
utilisées pour développer de nouvelles fonctionnalités pour la prochaine version ou une version future lointaine;
la version cible dans laquelle cette fonctionnalité sera intégrée peut bien être inconnue à ce stade;
elle existe tant que la fonctionnalité est en développement, mais
sera éventuellement fusionnée avec develop ou version ou supprimée
L’indicateur –no-ff
fait que la fusion crée toujours un nouvel objet de validation. Cela évite de
perdre des informations sur l’existence historique d’une branche de fonctionnalité et regroupe tous les commits qui ont ajouté la fonctionnalité.
Branches de version (release) release-*
peut bifurquer à partir de develop et doit être fusionnée à nouveau
dans develop et master;
prennent en charge la préparation d’une nouvelle version de production;
permettent de corriger des bogues mineurs et de préparer des méta-données pour une version (numéro de version, dates de construction, etc.);
Le moment clé pour bifurquer une nouvelle branche de version à partir du develop est lorsque le développement reflète (ou presque) l’état souhaité de la nouvelle version;
Au moins toutes les fonctionnalités ciblées pour la version à construire doivent être fusionnées dans develop à ce stade. Toutes les fonctionnalités ciblées sur les versions futures peuvent ne pas l’être, Elles doivent attendre la fin de la branche de version.;
C’est exactement au début d’une branche de version que la
version à venir se voit attribuer un numéro de version, pas plus tôt;
L’ajout de nouvelles fonctionnalités importantes ici est strictement interdit. Ils doivent être fusionnés dans develop, et par conséquent, attendre la prochaine grande version;
Lorsque l’état de la branche de version est prêt à devenir une véritable version, certaines actions doivent être effectuées. Tout d’abord, la branche de version est fusionnée dans master;
Branches de correctif (Hotfix) hotfix-*
peut bifurquer à partir de master et doit être fusionnée à nouveau
dans develop et master.
destinées à se préparer à une nouvelle version de production, bien que non planifiée;
Ils découlent de la nécessité d’agir immédiatement sur un état indésirable d’une version en production. Lorsqu’un bogue critique dans une version en production doit être résolu immédiatement, une branche de correctif peut être dérivée de la balise correspondante sur la branche principale qui marque la version en production;
