Complexité de la conception logicielle

Le terme complexité désigne l'état des événements ou des choses, qui ont de multiples liens interconnectés et des structures très complexes. En programmation logicielle, au fur et à mesure que la conception du logiciel est réalisée, le nombre d'éléments et leurs interconnexions deviennent progressivement énormes, ce qui devient trop difficile à comprendre à la fois.

La complexité de la conception logicielle est difficile à évaluer sans utiliser de métriques et de mesures de complexité. Voyons trois mesures importantes de la complexité des logiciels.

Mesures de complexité de Halstead

En 1977, M. Maurice Howard Halstead a introduit des mesures pour mesurer la complexité des logiciels. Les métriques de Halstead dépendent de la mise en œuvre réelle du programme et de ses mesures, qui sont calculées directement à partir des opérateurs et des opérandes du code source, de manière statique. Il permet d'évaluer le temps de test, le vocabulaire, la taille, la difficulté, les erreurs et les efforts pour le code source C / C ++ / Java.

Selon Halstead, «un programme informatique est une implémentation d'un algorithme considéré comme une collection de jetons qui peuvent être classés en tant qu'opérateurs ou opérandes». Les métriques Halstead conçoivent un programme comme une séquence d'opérateurs et de leurs opérandes associés.

Il définit différents indicateurs pour vérifier la complexité du module.

Paramètre Sens
n1 Nombre d'opérateurs uniques
n2 Nombre d'opérandes uniques
N1 Nombre d'occurrences totales d'opérateurs
N2 Nombre d'occurrences totales d'opérandes

Lorsque nous sélectionnons le fichier source pour afficher ses détails de complexité dans Metric Viewer, le résultat suivant apparaît dans Metric Report:

Métrique Sens Représentation mathématique
n Vocabulaire n1 + n2
N Taille N1 + N2
V Le volume Longueur * Vocabulaire Log2
ré Difficulté (n1 / 2) * (N1 / n2)
E Efforts Difficulté * Volume
B les erreurs Volume / 3000
T Temps de test Temps = Efforts / S, où S = 18 secondes.

Mesures de complexité cyclomatique

Chaque programme comprend des instructions à exécuter pour effectuer une tâche et d'autres instructions de prise de décision qui décident quelles instructions doivent être exécutées. Ces concepts de prise de décision modifient le déroulement du programme.

Si nous comparons deux programmes de même taille, celui avec le plus d'énoncés décisionnels sera plus complexe car le contrôle du programme saute fréquemment.

McCabe, en 1976, a proposé la mesure de la complexité cyclomatique pour quantifier la complexité d'un logiciel donné. Il s'agit d'un modèle basé sur un graphique basé sur des constructions de prise de décision de programme telles que if-else, do-while, repeat-until, switch-case et goto.

Processus pour créer un graphique de contrôle de flux:

  • Découpez le programme en blocs plus petits, délimités par des constructions décisionnelles.
  • Créez des nœuds représentant chacun de ces nœuds.
  • Connectez les nœuds comme suit:

    • Si le contrôle peut passer du bloc i au bloc j

      Dessinez un arc

    • Du nœud de sortie au nœud d'entrée

      Dessinez un arc.

Pour calculer la complexité cyclomatique d'un module de programme, nous utilisons la formule -

V(G) = e – n + 2

Where
e is total number of edges
n is total number of nodes

La complexité cyclomatique du module ci-dessus est

e = 10
n = 8
Cyclomatic Complexity = 10 - 8 + 2
                      = 4

Selon P. Jorgensen, la complexité cyclomatique d'un module ne doit pas dépasser 10.

Point de fonction

Il est largement utilisé pour mesurer la taille des logiciels. Function Point se concentre sur les fonctionnalités fournies par le système. Les caractéristiques et fonctionnalités du système sont utilisées pour mesurer la complexité du logiciel.

Le point de fonction compte sur cinq paramètres, nommés entrée externe, sortie externe, fichiers internes logiques, fichiers d'interface externe et enquête externe. Pour tenir compte de la complexité du logiciel, chaque paramètre est en outre catégorisé comme simple, moyen ou complexe.

Voyons les paramètres du point de fonction:

Entrée externe

Chaque entrée unique du système, de l'extérieur, est considérée comme une entrée externe. L'unicité de l'entrée est mesurée, car deux entrées ne doivent pas avoir les mêmes formats. Ces entrées peuvent être des données ou des paramètres de contrôle.

  • Simple - si le nombre d'entrées est faible et affecte moins de fichiers internes

  • Complex - si le nombre d'entrées est élevé et affecte plus de fichiers internes

  • Average - entre simple et complexe.

Sortie externe

Tous les types de sortie fournis par le système sont comptés dans cette catégorie. La sortie est considérée comme unique si son format de sortie et / ou son traitement sont uniques.

  • Simple - si le nombre de sorties est faible

  • Complex - si le nombre de sorties est élevé

  • Average - entre simple et complexe.

Fichiers internes logiques

Chaque système logiciel maintient des fichiers internes afin de maintenir ses informations fonctionnelles et de fonctionner correctement. Ces fichiers contiennent des données logiques du système. Ces données logiques peuvent contenir à la fois des données fonctionnelles et des données de contrôle.

  • Simple - si le nombre de types d'enregistrement est faible

  • Complex - si le nombre de types d'enregistrement est élevé

  • Average - entre simple et complexe.

Fichiers d'interface externe

Le système logiciel peut avoir besoin de partager ses fichiers avec un logiciel externe ou il peut avoir besoin de transmettre le fichier pour traitement ou comme paramètre à une fonction. Tous ces fichiers sont comptés comme des fichiers d'interface externes.

  • Simple - si le nombre de types d'enregistrement dans le fichier partagé est faible

  • Complex - si le nombre de types d'enregistrement dans le fichier partagé est élevé

  • Average - entre simple et complexe.

Enquête externe

Une demande est une combinaison d'entrée et de sortie, où l'utilisateur envoie des données à interroger comme entrée et le système répond à l'utilisateur avec la sortie de la demande traitée. La complexité d'une requête va au-delà des entrées externes et des sorties externes. La requête est dite unique si son entrée et sa sortie sont uniques en termes de format et de données.

  • Simple - si la requête nécessite un faible traitement et produit une petite quantité de données de sortie

  • Complex - si la requête nécessite un processus élevé et produit une grande quantité de données de sortie

  • Average - entre simple et complexe.

Chacun de ces paramètres dans le système est pondéré en fonction de sa classe et de sa complexité. Le tableau ci-dessous mentionne la pondération donnée à chaque paramètre:

Paramètre Facile Moyenne Complexe
Contributions 3 4 6
Les sorties 4 5 sept
Enquête 3 4 6
Des dossiers sept dix 15
Interfaces 5 sept dix

Le tableau ci-dessus donne des points de fonction bruts. Ces points de fonction sont ajustés en fonction de la complexité de l'environnement. Le système est décrit en utilisant quatorze caractéristiques différentes:

  • Données de communication
  • Traitement distribué
  • Objectifs de performance
  • Charge de configuration d'opération
  • Taux de transaction
  • Saisie de données en ligne,
  • Efficacité de l'utilisateur final
  • Mise à jour en ligne
  • Logique de traitement complexe
  • Re-usability
  • Facilité d'installation
  • Facilité opérationnelle
  • Sites multiples
  • Désir de faciliter les changements

Ces facteurs caractéristiques sont ensuite notés de 0 à 5, comme indiqué ci-dessous:

  • Aucune influence
  • Incidental
  • Moderate
  • Average
  • Significant
  • Essential

Toutes les cotes sont ensuite résumées par N. La valeur de N varie de 0 à 70 (14 types de caractéristiques x 5 types de cotes). Il est utilisé pour calculer les facteurs d'ajustement de la complexité (CAF) à l'aide des formules suivantes:

CAF = 0.65 + 0.01N

Ensuite,

Delivered Function Points (FP)= CAF x Raw FP

Ce FP peut ensuite être utilisé dans diverses métriques, telles que:

    Cost = $ / FP

    Quality = Erreurs / FP

    Productivity = PF / personne-mois