par Christophe Camel
On pose :
X : Un élément, constitué d'un ensemble d'instructions.
|X| : Taille de X. C'est la quantité d'instructions mise en jeu pour définir X.
[X] : Cardinalité de X. C'est sa bogosité. Elle donne une information sur la quantité de bugs contenus dans l'élément X.
Alors :
U : Univers des buggés.
Un élément X appartient à cet univers si et seulement
si la quantité de bugs qui le contient est au minimum égale
à 1.
Proposition: Tout logiciel appartient à U.
Démonstration : L'inégalité de Von Neumann prouve l'inexistance d'un espace débuggé pour tout programme non trivial. Or, par définition, un logiciel est non trivial ( soit [X] > 0 ). Sachant que tout programme non trivial appartient à U ( [X]>0 => X dans U ), tout logiciel appartient aussi à U.
Proposition : Tout programme trivial est exclu de U. L'ensemble des programmes triviaux est appelé Ù. (U barre).
Démonstration : Evidente.
Le transfert d'un élément X d'un univers vers un autre consiste en la modification de cet élément pour que la règle d'appartenance soit vérifiée dans le nouvel univers.
On définit la fonction B comme suit :
B : X --------> Y
Ù --------> U
La fonction Y = B(X) est appelé fonction de Buggage. Elle "transforme" un programme trivial en logiciel (programme buggé) par le passage de l'univers débuggé Ù à l'univers des buggés U. La fonction B est n'est pas une fonction bijective.
La fonction réciproque D = B-1 peut
se définir comme cela :
X --------> Y
U --------> Ù
D réalise le passage d'un logiciel buggé à l'univers débuggé, c'est la fonction de débuggage TOTAL. Cette fonction n'existe pas, du fait de l' inégalité de Von Neuman. (La fonction B n'est pas bijective).
a) Définition
L'espace U peut se voir partitionné en sous ensembles Un. X appartient à Un si et seulement si : [X] = n.
L'union de tous les Un donne U.
b) U est ordonné.
Ainsi : U0 < U1 < U2 < U3 < .... < Up
(p tend vers l'infini)
c) Débuggage partiel
Le principe de débuggage partiel est l'opération qui fait passer X de Un à Up avec p < n.
Théorème : La bogosité d'un élément X est bornée.
Démonstration : Passer de U à Ù nécessite de faire diminuer la bogosité à 0. Or ce transfert étant impossible, la limite inférieure de la bogosité est 1.
Il existe également une borne supérieure : h.
h est la bogosité maximale. C'est une fonction croissante de la
taille de X.
|X| = cte => lim [X] = h
h(|X|)
croissant.
a) Patch.
Un patch est aussi un élément de U. On appelle pouvoir
correcteur CP du patch P, le rapport : CP = bc / [P] avec :
bc est le nombre de bugs qu'il corrige,
[P] la bogosité (intrinsèque) du patch.
Un CP > 1 indique un patch efficace. Il corrige plus de bugs qu'il n'en apporte.
{ CP > 1 } -> [Y] < [X] + [P] avec Y = X + P et bc <[X]
Un CP < 1 indique un patch inefficace.
{ CP < 1 } -> [Y] > [X] + [P]
Inégalités des ajouts patchés :
|
[P1] + [P2] > [P1+P2] |
Le pouvoir correcteur ajouté a une performance moindre qu'un patch global. Ceci montre bien que l'application d'une infinité de patch à un programme fait tendre la bogosité de celui vers 0 sans jamais l'atteindre.
Ainsi, l'application répété de patchs fait passer X de Un vers Up avec (p-n) tendant vers 0
b) Patch autocorrecteur
Est dit patch autocorrecteur, tout patch à CP infini.
Ceci implique une bogosité intrinsèque nulle. Le patch est en fait un patch pour le programme mais aussi pour lui-même. Il s'agit du modèle parfait du patch, qui n'a pas sa place en milieu industriel.