Table des matières
4 Module 3
: Approche Objet et UML
5.4 Héritages simples et
multiples
8 Module
7 : Gestion de projets
10 Module
9 : Logiciel embarqué
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
Industrie
Disciplines transverses
Produire quoi ?
Critères de qualité
Coûts directs et indirects
Exigences qualité
Analyse du besoin
Analyse fonctionnelle
Cahier des charges
Mise en œuvre
Qualité d’un projet
Management
Planification
Contrôle
Chef de projet
Maître d’ouvrage
Maître d’œuvre
PERT
Gantt
Kamban
Réunions
Documentation
Sensibilisation
La réalité en chiffres
Personne n’est parfait
Projet logiciel
Triangle des Bermudes
Le cycle de vie
Cycle en V, idéal
Cycle en V, réel
Autres cycles
Modèle en spirale
Comparaison des cycles
Pathologies
Les algorithmes
Complexité du langage
Les tests
Quels tests ?
Gestion de code
La documentation
Critères de qualité
Recettes
Modularité
Conclusion 1
Conclusion 2
Cycle de vie et documentation
Encadrer les travaux
La fiche de test est éternelle
Par exemple…
Gantt
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