Méthodes de génie logiciel avec Ada/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.

Méthodes de génie logiciel avec Ada

Version imprimable

[ Modifier le sommaire ]

Bibliographie

Sommaire

Glossaire

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.