Méthodes de génie logiciel avec Ada/Glossaire
Glossaire
Ce glossaire reprend les termes principaux dans le but de faciliter la lecture du livre, aussi avons-nous préféré donner des définitions simples et concrètes, aux dépens parfois de la rigueur d'une définition plus formelle.
- Agrégat
- valeur d'un type structuré (tableau ou article), fournie sous la forme d'une liste de valeurs entre parenthèses.
- Attente active
- boucle d'un programme n'effectuant rien d'autre que tester l'arrivée d'un événement.
- Attribut
- en termes de programmation orientée objet: structures de données faisant partie de la définition d'une classe. En termes Ada: construction syntaxique spéciale permettant de récupérer de l'information liée à un type, une variable, un sous-programme, etc.
- Classe
- en Ada: ensemble des types dérivés directement ou indirectement d'un type étiqueté. La classe d'origine T se désigne en Ada par T'Class. Plus généralement dans le monde orienté objet: abstraction d'un ensemble d'objets possédant des propriétés communes.
- Condition de course
- erreur d'un système parallèle due au fait que deux tâches effectuent simultanément une action à un moment indésirable.
- Élaboration
- processus par lequel une déclaration devient utilisable. En Ada, ceci peut nécessiter l'exécution de code; l'élaboration est aux déclarations ce que l'exécution est aux instructions.
- Encapsulation
- regroupement dans une même entité de structures de programmes et de structures de données logiquement reliées.
- Facette
- ensemble de propriétés constituant une vue particulière des propriétés d'un objet; un objet peut posséder plusieurs facettes. Par exemple, un cercle peut comporter une facette d'objet graphique et une autre d'objet géométrique.
- Garde
- condition booléenne contrôlant une entrée de tâche ou d'objet protégé. L'entrée ne peut être appelée que si la garde est True.
- Générique
- forme d'unité de programme paramétrable, permettant d'écrire des modules réutilisables sur divers types de données.
- Graphe de dépendances
- v. topologie de programme.
- Héritage
- mécanisme par lequel un type dérivé possède les attributs et les méthodes du type dont il est dérivé.
- Instance
- structure de donnée appartenant à une classe et représentant un objet abstrait. Une instance est à une classe ce qu'une variable est à un type.
- Instanciation
- création d'une unité de programme normale à partir du modèle constitué par un générique.
- Liaison dynamique
- propriété d'un appel de sous-programme (méthode) qui ne peut être résolu à la compilation, mais où le sous-programme appelé dépend de l'instance à laquelle il s'applique à l'exécution.
- Méthode
- en programmation orientée objet, structures de programme (opérations) faisant partie de la définition d'une classe.
- Nom complet
- nom simple d'une entité, précédé par le nom de l'entité dans laquelle elle a été déclarée (les deux noms sont séparés par un point).
- Nom simple
- identificateur qui a servi à déclarer une entité.
Plan d'abstraction : ensemble constitué de l'implémentation d'un objet à concevoir et des spécifications des objets utilisés nécessaires à sa réalisation.
- Point fixe
- représentation informatique des nombres réels fournissant une erreur absolue constante.
- Point flottant
- représentation informatique des nombres réels fournissant une erreur relative constante.
- Polymorphisme
- propriété d'une variable susceptible de contenir à l'exécution des valeurs de types différents, mais appartenant à une même classe. La variable peut donc contenir plusieurs «formes» de valeurs.
- Réentrance
- propriété d'un sous-programme qui peut être appelé simultanément par plusieurs tâches.
- Sémantique de référence
- propriété d'un type de donnée abstrait pour lequel l'affectation X := Ya la signification: «X et Y désignent la même instance».
- Sémantique de valeur
- propriété d'un type de donnée abstrait pour lequel l'affectation X := Ya la signification: «le contenu de Y est transféré dans X».
- Sous-programme abstrait
- sous-programme déclaré avec le mot abstract, qui ne possède pas de corps. On ne peut appeler un sous-programme abstrait, il doit être redéfini par les types qui en héritent.
- Sous-programme primitif
- sous-programme déclaré dans la même spécification de paquetage que le type d'un de ses paramètres. Seuls les sous-programmes primitifs sont hérités lors de la dérivation du type.
- Suite de validation
- ensemble de programmes de tests destinés à vérifier le bon fonctionnement d'un composant logiciel.
- Surcharge
- possibilité d'attribuer le même nom à plusieurs sous-programmes s'ils diffèrent par le nombre ou le type de leurs arguments ou par le type de la valeur renvoyée pour les fonctions.
- Topologie de programme
- organisation des relations de dépendance logique entre modules d'un programme. La représentation de la topologie de programme est le graphe de dépendances.
- Type abstrait
- type étiqueté déclaré avec le mot abstract. On ne peut déclarer d'objet ni créer de valeurs d'un type abstrait. Un type abstrait peut déclarer des sous-programmes abstraits.
- Type contrôlé
- type dérivé du type étiqueté Finalization.Controlled (ou Finalization.Limited_Controlled). Il est possible de définir l'initialisation et la finalisation de tels types, ainsi que l'affectation pour ceux qui ne sont pas limités.
- Type de donnée abstrait
- type défini par un ensemble de valeurs et muni d'un ensemble d'opérations. Ces valeurs sont abstraites parce que la vue qu'en a l'utilisateur est indépendante de la représentation interne adoptée.