284 lines
11 KiB
Plaintext
284 lines
11 KiB
Plaintext
Introduction à la modularité
|
||
=============================
|
||
|
||
Un langage de programmation doit permettre la programmation structurée.
|
||
|
||
.. important:: La structuration et l'organisation modulaire sert à maintenir de grands programmes,
|
||
Elles sont une nécessité
|
||
|
||
Structuration d'un programme
|
||
-----------------------------
|
||
|
||
La réalisation d'applications importantes oblige le programmeur ou l'équipe de
|
||
développement à se poser des questions d'organisation et de structuration.
|
||
Aujourd'hui, on dispose de deux grands modèles d'organisation dont les avantages et les
|
||
particularités sont distincts.
|
||
|
||
La modularité
|
||
~~~~~~~~~~~~~
|
||
|
||
Les données et les traitements sont regroupés au sein d'une même entité à deux
|
||
facettes : d'un côté le code proprement dit, de l'autre son interface. La
|
||
communication entre modules s'effectue via leur interface. La description d'un
|
||
type peut être masquée en n'apparaissant pas dans l'interface du module. Ces
|
||
types de données abstraits facilitent les modifications d'implantation à
|
||
l'intérieur d'un module sans affecter les autres modules qui s'en servent. De
|
||
plus, les modules peuvent être paramétrés par d'autres modules augmentant
|
||
ainsi leur réutilisabilité.
|
||
|
||
Le paradigme objet
|
||
~~~~~~~~~~~~~~~~~~
|
||
|
||
Les descriptions des traitements et des données sont regroupées dans des
|
||
entités appelées **classes**; un objet est une instance (valeur) d'une classe.
|
||
La communication entre objets est réalisée par envoi de message, l'objet
|
||
receveur détermine à l'exécution (liaison retardée) le traitement
|
||
correspondant au message. En cela, la programmation objet est dirigée par
|
||
les données. La structuration d'un programme provient des relations entre
|
||
classes, en particulier l'héritage permet de définir une classe par extension
|
||
d'une autre.
|
||
|
||
En programmation objet, un **programme** est une collection d’objets qui communiquent
|
||
entre eux par **message**, le **résultat** est un message envoyé à un objet particulier
|
||
|
||
Comparaison entre les deux paradigmes
|
||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||
|
||
Il y a dualité entre ces deux modèles.
|
||
|
||
- On ne peut pas augmenter les composants d'un type dans un module (pas
|
||
d'extensibilité des données), mais on peut ajouter de nouveaux traitements
|
||
(extensibilité des traitements) sur ces données.
|
||
|
||
- En objet, on peut ajouter des sous-classes à une classe (extensibilité des
|
||
données) pour traiter des nouveaux cas, mais on ne peut pas ajouter de nouveaux
|
||
traitements visibles de la classe ancêtre (pas d'extensibilité des traitements).
|
||
|
||
**La combinaison des deux paradigmes offre de nouvelles extensibilités pour les
|
||
traitements et les données.**
|
||
|
||
Sûreté d'exécution
|
||
--------------------
|
||
|
||
La programmation raisonnée
|
||
~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||
|
||
Un **programme** est le codage d'un algorithme dans un langage de programmation.
|
||
La programmation consiste à modéliser un problème du monde réel sous une forme
|
||
symbolique (pour faire résoudre ce problème par un ordinateur).
|
||
|
||
Certains problèmes sont **indécidables** ou **ouverts**.
|
||
On utilise un langage de programmation pour décrire la **solution** du programme.
|
||
La sémantique du programme est le sens de chacune des constructions du langage.
|
||
**Comment passer de l'énoncé d'un problème à un programme de bonne qualité ?**
|
||
|
||
spécifier
|
||
|
||
décrire de manière complète et rigoureuse le problème à résoudre
|
||
|
||
modéliser
|
||
|
||
proposer une représentation du réel qui soit accessible au calcul
|
||
algorithmique
|
||
|
||
transcrire
|
||
|
||
La transcription du modèle algorithmique se fait dans un langage
|
||
de programmation cible adapté au problème
|
||
|
||
valider
|
||
|
||
La validation du programme est une étape qui permet de s'assurer plus ou
|
||
moins fortement que le programme produit les résultats attendus.
|
||
La validation va de la série de tests unitaires (validation faible)
|
||
à la preuve de programme (validation mathématique forte).
|
||
|
||
La preuve de programme
|
||
~~~~~~~~~~~~~~~~~~~~~~
|
||
|
||
Le niveau maximum de sûreté d'exécution d'un programme est la preuve. Qu'est-ce que la preuve
|
||
formelle d'un programme ? Selon la définition de Wikipédia, ce sont "des techniques permettant de
|
||
raisonner rigoureusement, à l'aide de logique mathématique, sur des programmes informatiques ou
|
||
du matériel électroniques, afin de démontrer leur validité par rapport à une certaine
|
||
spécification." Bref c'est un raisonnement logique sur un programmme qui permet d'être sûr que le
|
||
programme est valide et ne va pas planter.
|
||
|
||
La preuve de programme est très peu utilisée dans l'industrie, car très coûteuse et très
|
||
difficile à mettre en place. Elle quand même utilisée, mais dans des secteurs où le risque doit
|
||
absolument être évacué et où il n'y a aucun droit à l'erreur. Par exemple, le secteur médical
|
||
(informatique en bloc opératoire), militaire (peu d'informations nous parviennent dans ce
|
||
domaine), l'aviation civile (le logiciel Astrée pour Airbus), la fusée Ariane (depuis le bug qui
|
||
avait fait crasher Ariane 5 ces questions sont prises très au sérieux), et le milieu bancaire
|
||
(surtout le domaine des décisions boursières : un programme chargé de lancer des décisions
|
||
d'achat ou de vente à la bourse qui comporte un bug peut en quelque centièmes de secondes faire
|
||
perdre des millions, voire des milliards d'euros à une banque. Le programme ne doit tout simplement pas
|
||
bugger).
|
||
|
||
Le model checking
|
||
~~~~~~~~~~~~~~~~~~
|
||
|
||
Le model checking, l'analyse statique et l'interprétation abstraite procèdent d'une méthodologie
|
||
moins lourde de validation des programmes. Ces méthodes analysent exhaustivement l'évolution du
|
||
système lors de ses exécutions possibles et permetent de dire si globalement, dans un contexte
|
||
donné, le programme va fonctionner correctement. Encore très lourdes, ces techniques ne sont
|
||
utilisées que dans un contexte industriel de haute sécurité.
|
||
|
||
Les tests d'acceptation
|
||
~~~~~~~~~~~~~~~~~~~~~~~
|
||
|
||
Il y a plusieurs types de tests
|
||
|
||
- unitaires
|
||
- fonctionnels
|
||
- acceptation
|
||
|
||
Très utilisés dans l'industrie, les tests unitaires et fonctionnels ne testent que certaines
|
||
parties du programme et permettent de dire que le programme va marcher grosso-modo à peu près.
|
||
Beaucoup moins coûteux à installer, ce sont des éléments cléfs des méthodes agiles.
|
||
|
||
Les Outils de linting (validation)
|
||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||
|
||
- vérifications syntaxiques
|
||
- vérification sémantiques
|
||
- vérification sur les imports inutiles ou mal formés (imports croisés
|
||
|
||
Exemple en python : pylint
|
||
|
||
|
||
La dette technique
|
||
~~~~~~~~~~~~~~~~~~
|
||
|
||
Au bout d'un moment le code devient du code spaghetti et les techniques sont obsolètes.
|
||
Les tests permettent de solder la dette technique plus facilement.
|
||
|
||
**avoir le courage de payer une dette technique, et affronter une dette technique
|
||
sinon il peut y avoir un coût à payer qui sera pohibitoire.**
|
||
|
||
On solde la dette technique parce que à un moment ça va devenir beaucoup trop
|
||
cher à payer.
|
||
|
||
Les méthodologies agiles
|
||
~~~~~~~~~~~~~~~~~~~~~~~~
|
||
|
||
La manière dont le code est produit importe énormément. Par exemple, une
|
||
méthodologie ou le **refactoring** (réécriture de code) est permis et même conseillé
|
||
a plus de chance de produire du code organisé.
|
||
|
||
Les méthodologies agiles produisent en général du code mieux organisé. Ce sont les
|
||
méthodes de travail les plus en vogue aujourd'hui, elles mettent l'accent sur :
|
||
|
||
- Du logiciel fonctionnel plutôt que de la documentation exhaustive
|
||
- La réponse au changement plutôt que le suivi d'un plan
|
||
- Le logiciel fonctionnel est la principale mesure d'avancement
|
||
- Une attention continue à l'excellence technique et à une bonne
|
||
conception améliore l'agilité
|
||
- La simplicité est essentielle (il est facile de faire, il est
|
||
difficile de faire simple)
|
||
|
||
Le principe de base de la méthodologie Scrum par exemple est de focaliser l'équipe de façon
|
||
itérative sur un ensemble de fonctionnalités à réaliser, dans des itérations de durée fixe de une
|
||
à quatre semaines, appelées **sprints**. Chaque sprint possède un but à atteindre, défini par le
|
||
responsable de produit, à partir duquel sont choisies les fonctionnalités à implémenter dans ce
|
||
sprint. Un sprint aboutit toujours sur la livraison d'un produit partiel fonctionnel. Pendant ce
|
||
temps, le facilitateur a la charge de réduire au maximum les perturbations extérieures et de
|
||
résoudre les problèmes non techniques de l'équipe.
|
||
|
||
Conception descendante
|
||
-----------------------
|
||
|
||
Une vision **centripète** : du général au particulier.
|
||
|
||
Il s'agit d'une méthode de résolution d'un problème. On le découpe en tâches
|
||
de plus en plus fines, de plus en plus détaillées, qui aboutiront au programme final.
|
||
|
||
On met des *trous* dans les algorithmes de plus haut niveau,
|
||
c'est-à-dire des phrases en langage naturel.
|
||
|
||
.. ifconfig: exercice
|
||
|
||
**Exercice** : **Calculer la date du lendemain**
|
||
|
||
.. ifconfig: correction
|
||
|
||
- l'algorithme de plus bas niveau
|
||
|
||
::
|
||
|
||
lendemain jour =
|
||
si jour [est le dernier jour du mois] alors
|
||
resultat = [calculer le 1er janvier de l'année suivante]
|
||
sinon
|
||
resultat = lendemain_dansl'année jour
|
||
|
||
- les algorithmes de plus bas niveau
|
||
|
||
::
|
||
|
||
lendemain_dans_l'année jour =
|
||
si jour [est le dernier jour du mois] alors
|
||
resultat = [calculer le premier jour du mois suivant]
|
||
sinon
|
||
resultat = jour suivant jour
|
||
|
||
::
|
||
|
||
jour_suivant jour =
|
||
jour + 1
|
||
|
||
et ainsi de suite jusqu'à ce que toutes les phrases soient calculables.
|
||
|
||
Algorithme vague
|
||
--------------------
|
||
|
||
L'algorithme vague, c'est quand on pense l'algorithme en se plaçant du côté de
|
||
l'implémentation en premier. On a le nez dans le guidon, la vue d'ensemble est
|
||
difficile.
|
||
|
||
Voici, tiré du monde réel, un exemple d'algorithme vague
|
||
("ce que doit faire une fonction"), placé dans un bout de code
|
||
(souvent la **docstring** d'une fonction).
|
||
|
||
.. code-block:: python
|
||
|
||
def upsert_route(*args, **kwargs):
|
||
"""
|
||
Create or modify an existant DHCP route
|
||
param tuple (id or null, machine name, IP, MAC Adress)
|
||
return True or False with error message
|
||
"""
|
||
# si id présent alors modification sinon ajout
|
||
# récupère la liste des réservations en cours
|
||
# y cherche la variable sur la base de l'ID
|
||
# modifie les valeurs
|
||
# applique la nouvelle conf DHCP
|
||
|
||
return True
|
||
|
||
Voici un autre bout de code avec l'algorithme en commentaire,
|
||
et l'implémentation effective de l'algorithme
|
||
|
||
.. code-block:: python
|
||
|
||
def del_route(*args, **kwargs):
|
||
"""
|
||
Delete an existant DHCP route
|
||
param tuple (id, machine name, IP, MAC Adress)
|
||
return True or False with error message
|
||
"""
|
||
# récupère la liste des réservations en cours
|
||
# y cherche la variable sur l'id donné en paramètre
|
||
# supprime l'entrée avec vérification que les données fournies
|
||
# sont bien dans l'enregistrement à supprimer
|
||
# applique la nouvelle conf DHCP
|
||
route_to_del = (1, "host2","10.1.2.4","6E:FF:56:A2:AF:17") # FIXME
|
||
routes = get_routes()
|
||
if route_to_del in routes:
|
||
c = creole_loader(load_extra=True, rw=True, owner=MODNAME, mandatory_permissive=False)
|
||
c_id = c.dhcp.dhcp.id_dhcp.id_dhcp.index(route_to_del[0])
|
||
if c.dhcp.dhcp.id_dhcp.macaddress[c_id]==route_to_del[2] and c.dhcp.dhcp.id_dhcp.ip[c_id]==route_to_del[1]:
|
||
c.dhcp.dhcp.id_dhcp.id_dhcp.pop(c_id)
|
||
config_save_values(c, MODNAME)
|
||
return True
|
||
return False
|