4 Module 3 : Approche Objet et UML
5.4 Héritages simples et multiples
8 Module 7 : Gestion de projets
Dans un esprit d’efficacité, les formations SOLTI ne sont pas des produits standards et normalisés. Les objectifs d’une formation sont variés, les motivations et les compétences des stagiaires également.
La formation doit aider le stagiaire, qui est dans une situation particulière (capacités, expérience, compétence, disponibilité, motivation) à évoluer vers une nouvelle situation qui doit être définie aussi précisément que possible avant la formation.
Aussi, le programme sera adapté, dans le contenu et dans la forme, aux conditions réelles de formation et à l’attente des stagiaires. Le contenu de la formation est donné ci- dessous à titre indicatif et ne constitue pas au chapitre près à un engagement de SOLTI. Le totalité du programme représente environ 15 jours de formation. Nous avons réalisé depuis 2009 plus de 300 jours stagiaire.
Le client fournit
· Un PC par élève avec Visual Studio ou Eclipse installé
· Une salle aux dimensions adaptée au nombre de participants
· Un vidéo projecteur
· Un tableau blanc avec ses stylos
· Une connexion Internet pour le formateur
La durée effective des cours est de 6 heures quotidiennes minimum.
Pour le confort et la flexibilité, il est bon de ne pas faire plus de 2 journées à la suite suite.
Le contenu précis des formations dépend des objectifs fixés, du temps disponible et du temps passé sur les exercices. On essaie toutefois de tenir les horaires suivants, en alternant théorie et exercices :
Matin: 9h30 - 11h pause 11h15 - 12h45
Après-midi : 13h30 -15h15 pause 15h30 - 17h
Architecture d’un ordinateur
Architecture d’un processeur
Code machine
Langage assembleur
Macros
Procédures
Langage C
Compilateur
Editeur de lien
Runtime
Debugger
Entrées sorties
Fichiers
Liaison série
Ethernet
Ingénierie: Du besoin à la validation
Les modèles
Les méthodes
Cycle de vie d’une application
Méthodes traditionnelles: en cascade
Méthodes traditionnelles: en V
Le cycle de vie théorique
Les cycles de vie réels
La méthode itérative
Les outils UML
L’intérêt d’UML
Structure d’un programme
Les fonctions
Les variables
Les types simples
Caractères
Entiers
Flottants
Void
Tableaux
Structures
Enumérations
Expressions
Les pointeurs
Opérateurs simples
Opérateurs complexes
Les boucles if
Les switches
Les boucles for
Les boucles while
Les autres boucles
Break, return continue
Principe
Utilisation
Librairies
Usages et abus
Les solutions
Exercice : codage d’une bibliothèque string
Les fautes de frappe
Récursivité
Conversions de type
Promotion des entiers
Manipulation de pointeurs
Réentrance
Opérateur &
Complexité du code
Allocation dynamique
Tableaux et pointeurs
Les unions
Les champs de bits
Tests unitaires
Exercice : comparaison des codes générés
Gestion des sources
Versions
Sauvegardes
Codage
Structuration
Nommage
Commentaires
Divers
Systèmes asynchrones
Systèmes synchrones
Bonnes pratiques
Architecture 3 tiers
Modèle Vue Contrôleur
Threads
Tâches
Traçabilité
Portage
HAL
Norme Posix
Définition de la cible
Définition du processeur
Librairie portable
Mini Kernel
Inventaire
Les règles simples
Les règles utiles
Les règles pénibles
Les règles peu critiques
Introduction
Métriques de performance
Spécifications
Criticité
Vitesse
Génération de code
Design patterns
Bonnes pratiques
Exercice : optimisation de performance
Problématique: Taille et complexité des logiciels
Solutions: Descartes
Solutions: Le découpage
Concepts
Terminologie
Manipulations d’objets
Les messages
L’encapsulation
L’abstraction
L’héritage : Spécialisation
L’héritage : Généralisation
Classes abstraites
Conclusion
Les use cases
Fonctionnalités du système
A quoi ca sert
Les acteurs
Description
Relation extend
Relation include
Les scénarios
Séquences d’interactions
Diagramme de séquence
Diagramme de collaboration
Schémas
Objets
Classes
Association
Rôle
Agrégation
Cardinalité
Qualificateur
Généralisation et spécialisation
Diagrammes d’états
Définitions
Parcours d’une motrice
Trajets
Géométrie
Gestion de stock
Distributeur de billets
Une IDE style Visual
Créer un projet
Choisir un modèle
Ajouter un diagramme de classes
Editer un diagramme de classes
Ajouter une classe
Spécialiser la classe
Ajouter des attributs
Modifier un attribut
Afficher les propriétés
Diagramme d’état
Générer le code
D’autres outils
Commentaire fin de ligne
Déclarations et initialisations
Notion de référence
Arguments par défauts
Surcharge de fonctions
Opérateurs New et Delete
Incompatibilité entre C et C++
Exemples
Les entrées sorties standards
Affichage à l’écran
Lecture au clavier
Les flots
Exemples
Propriétés des fonctions membres
Construction, destruction et initialisations d’objets
Fonctions amies
Surcharge d'opérateurs
Conversions de types
Exemples
Notion d’héritage
Utilisation, surcharge des membres
Appel des constructeurs et destructeurs
Mise en œuvre
Mécanisme
Propriétés
Fonctions virtuelles pures
Exemples
Mécanisme de gestion des exceptions
Choix du gestionnaire
Les exceptions standards
Exemples d’exceptions
Création et utilisation
Les paramètres de type
Les paramètres expressions
Spécialisation
Exemples
Historique
Avant
.Net
.Net 3.0
.Net 3.5
.Net 4.0
En bref
Proche de java
Proche de C++
Les nouveautés
Les plus
Les moins
Références Web
Références papier
Application console
Désassembleur
Librairie : Création
Librairie : Utilisation
Application forms : Dessiner
Application forms : Coder
Application forms : Debugger
Conclusion
Définitions
Régions
Pragma
Commentaires
Doc XML
Balises
Les espaces de noms
Les constantes
Les types valeurs
Les types nullables
Les types référence
Les types de base
Les énumérations
Les conversions
Les tableaux unidimensionnels
Tableaux à 2 dimensions
Structures
Sécurité du code
Les opérateurs
Tous les opérateurs
Branchements if
Branchements switch
Boucles simples
Boucles moins simples
Les exceptions : émettre
Les exceptions : capturer
Les classes
Exemple de classe
Les méthodes
Appel de méthode
Passage de paramètres
Surcharge
Liste de paramètres
Propriétés
Indexeurs
Héritage
Classe abstraite : méthode abstraite
Classe abstraite : propriété abstraite
Surcharge des opérateurs
Interfaces : définir
Interfaces : utiliser
Architecture forms
Buttons
EditBox
ListBox
ComboBox
TabPanels
Control forms
Class libraries
Intégration de DLLs
Intégration d’objets COM
Bonnes pratiques Windows
Paramètres
Timers
Delegates
Threads
Traçabilité
Gestion de fichiers
Fichiers de log
Client server
Principe
Mise en œuvre
Exemple
Classe DataTable
Classe DataGridView
Bibliothèque Office et fichier Excel
ODBC et fichier Excel
ODBC et accès SQL
Projet
Création
Travail
Art
Communication
Simplement
Précisément
Exemples
Liberté et compétence
Monter en compétence
Gérer le changement
Produit et projet
Etudiant et professionnel
Objectifs…
Statistiques
William Deming
Produit/Projet
Produit/Affaire
4 phases distinctes
Analyse du besoin
Analyse fonctionnelle
Cahier des charges
Mise en œuvre
Synthèse
Piloter un projet
En terrain inconnu
Situer son objectif
Quels paramètres ?
Les indicateurs
Qualifier les dérives
Le triangle d’or
Le triangle des Bermudes
Il faut faire des choix
Quand ?
Pourquoi ?
Les composantes internes
Les composantes externes
La force motrice
L’organe modérateur
1. Chef de projet
2. Maitre d’ouvrage
3. Maitre d’œuvre
4. Client fournisseur
1. Outils : Pert
2. Outils : Gannt
3. Outils : Réunions
4. Outils : Documentation
5. Conclusion
1. Principes
2. Faisabilité
3. Planification
4. Développement
5. Réalisation
6. Exploitation
7. Clôture
8. Revues
9. Résumé
1. Industrie
2. Disciplines transverses
3. Objectifs
4. Critères de qualité
5. Coûts directes et indirects
6. L’approche usage
Historique
Gestion de projet
Qualité
Le Lean
L’agilité
Problématique: Pourquoi ? Comment ?
Effet tunnel : Méthode incrémentale
Erreurs de specs: Méthode itérative
Gestion commerciale: Méthode collaborative
Les critiques !
Historique
Structuration ou adaptation
Le manifeste agile : les 12 principes
Agilité, Lean et amélioration continue
La documentation
La réalité en chiffres
Personne n’est parfait
Triangle QCD des Bermudes
Le cycle en V Virtuel
Le cycle en R Réel
Pathologies du développeur
Qu’est ce qu’un bel algorithme ?
Complexité du langage
Les tests
Quels tests ?
Documentation
Critères de qualité
Recettes
Modularité
Conclusions
Mêlée
Rugby
Principes
Origines
Utilisateurs
Utilisations
Caractéristiques
Manifeste agile
Cycle
Sprints
Activités
Stabilité
Rôles
Cérémonial
Artifacts
Références
Ce qu’il faut retenir
Historique
Principes
Méthode
Intégration continue
Pair programming
Test driven
Pair testing
Planning Poker
Non régression
Psychologie du programmeur
Google Programming
Gestion des conflits
La journée d’un XP
Problématique
Solution lourde
Solution lean
Documentation
FAE
Conclusion
Gestion des sources
Versions
Sauvegardes
Codage
Structuration
Nommage
Commentaires
Divers
Les sprints
Les réunions
La documentation
Les livrables
Incrémental
Repository
Méthodologie
Le build
La livraison
Test unitaire
Framework
Test fonctionnel
Non régression
Gestion d’un micro projet XP
Formation des binômes
Codage alterné
Bilan.
Discussions.
Tâches
Co routines
Queues
Sémaphores
Compteurs Sémaphores
Mutexs
Conclusion
Principe
Les différentes normes
La topologie
Les performances
Communication UDP
Mise en œuvre avec Visual C
Principe
Client serveur
Réalisation d’un serveur avec Visual C
Réalisation d’un client avec Visual C
Gestion des déconnexions
Principes
USB 1.0
USB 2.0
Implémentations
Principes
Architecture
Logiciel
Exemples de carte 16 bits et 32 bits
Mise en œuvre
Principes
Architecture
Logiciel
Exemple de carte DsPIC
Mise en œuvre
Introduction au FPGA