Abstraction (informatique)

En informatique, le concept d'abstraction identifie et regroupe des caractéristiques et traitements communs applicables à des entités ou concepts variés ; une représentation abstraite commune de tels objets permet d'en simplifier et d'en unifier la manipulation.

Programmation

Généralités

Différentes couches de logiciel, partant d'en bas, le matériel est programmé en langage binaire, via un firmware, qui permet une abstraction pour le noyau, puis lui même pour le système d'exploitation, qui a son tour permet une abstraction pour les applications. Les différentes couches ont une abstraction de plus en plus importante, et chaque couche ne doit réussir à communiquer qu'avec celle d'en dessous ou celle d'au dessus, permettant une mutualisation des couches intermédiaires : par exemple le système d'exploitation est commun aux deux applications.

Exemple de couche unifiée (la couche SDL) pour programmer les applications via une interface unique vers SDL, quels que soient le système d'exploitation et le matériel réellement utilisés.

Un langage informatique est déjà une abstraction en lui-même, puisqu'il fait correspondre à un langage ésotérique (le langage machine s'écrit en binaire, c'est-à-dire composé uniquement de zéros et de uns) un autre langage mieux adapté à la compréhension humaine.

Une des abstractions est la généralisation du code pour le détacher au maximum du contexte. L’un des outils les plus connus de l’abstraction informatique est la variable, notamment la variable d'environnement.

Par exemple, sous Windows XP, le chemin du système est généralement C:\WINDOWS\system32. Mais il ne s’agit que d’un cas particulier, ce pourrait très bien être D:\OS_XP. En revanche, la variable d’environnement pour les fichiers système est %WINDIR% (ou %SYSTEMROOT%). Cette variable d’environnement est une valeur abstraite dont C:\WINDOWS\system32 est une application possible.

Beaucoup d’erreurs de programmes viennent du fait que les dits programmes utilisent des valeurs concrètes au lieu de valeurs abstraites (comme les variables d’environnement). Il arrive alors que des programmes ne fonctionnent pas correctement si d'autres programmes ou dossiers dont ils dépendent n'ont pas été installés dans les répertoires suggérés par défaut.

On nomme aussi couche d'abstraction matérielle une couche logicielle accédant au matériel informatique. En effet, l'hétérogénéité des différents composants, utilisant souvent des normes spécifiques, nécessiterait sans cette couche de développer spécifiquement pour chaque matériel une nouvelle implémentation du code (c’est pour cela que l’assembleur n’est pas portable). La bibliothèque logicielle DirectX fournit par exemple une suite d'outils théoriquement compatibles avec tout type de matériels.

Plus généralement, on nomme couche d'abstraction toute couche logicielle cachant au développeur l'implémentation de la couche inférieure, lui évitant de fournir une implémentation différente selon les spécificités de la couche inférieure. L’inconvénient de la couche d’abstraction est la moindre optimisation, induite par justement la présence de couches intermédiaires. Ceci reste une limitation théorique, non pratique : dans l’absolu, un code hautement abstrait pourrait être aussi véloce que du bon assembleur (puisque dans tous les cas, la machine exécute finalement du langage machine, pas du C ou du HTML). Dans la pratique, cependant, il n’existe pas de tel « compilateur 100 % ».

Abstraction du contrôle

L'une des motivations principales des langages de programmation consiste en l'abstraction du flot de contrôle. Les ordinateurs comprennent les opérations à un très bas niveau, par exemple le déplacement de certains bits d'un endroit à un autre en mémoire, ou encore l'addition de deux séquences de bits. Les langages de programmation permettent d'accomplir ces opérations à un plus haut niveau. Prenons pour exemple cette instruction écrite dans un langage semblable à Pascal:

a := (1 + 2) * 5

Ce calcul paraît simple et évident à un humain (« un plus deux donne 3, 3 fois 5 donne 15 »). Cependant, les étapes de bas niveau nécessaires pour qu'un ordinateur puisse évaluer cette expression et affecter la valeur résultante de 15 à la variable a sont en réalité subtiles et complexes. Les valeurs doivent être converties à une représentation binaire (une tâche souvent plus compliquée qu'elle n'apparaît) et les calculs décomposés (par le compilateur ou l'interpréteur) en instructions d'assembleur. Ces instructions sont peu intuitives aux humains et consistent d'opérations élémentaires, telles que la rotation d'un registre à gauche, ou encore l'addition du complément binaire du contenu d'un registre à un autre, qui ne correspondent généralement pas à la façon dont les humains se représentent de façon abstraite les opérations arithmétiques d'addition ou de multiplication. Enfin, l'affectation de la valeur résultante de 15 à la variable portant l'étiquette a, ce qui permet de faire référence à cette même variable plus tard, demande plusieurs opérations supplémentaires, telles que de faire la correspondance entre une étiquette et l'emplacement en mémoire physique ou virtuelle, l'entreposage de la représentation binaire de 15 à cet emplacement mémoire, etc.

Sans cette abstraction du contrôle, il serait nécessaire de spécifier toutes les étapes de bas niveau chaque fois que l'on souhaiterait simplement additionner ou multiplier des nombres et affecter le résultat à une variable. Une telle duplication des efforts mènerait à deux conséquences néfastes:

1. la répétition de tâches et d'étapes très communes chaque fois qu'une telle opération est nécessaire
2. le couplage trop étroit entre un programme et le matériel et ensemble d'instructions sur lesquels il peut fonctionner

Programmation orientée objet

Dans le contexte orienté objet, l'abstraction est un mécanisme, ou une pratique, servant à réduire le code d'un niveau de détail. Autrement dit, l'abstraction permet de regrouper un certain nombre de classes selon des caractéristiques communes.

Par exemple, dans un logiciel de dessin vectoriel :

 abstract class Forme{
   public:
      virtual Aire(){};
      virtual Perimetre(){};
   protected:
      int origine; //en pixel
      int hauteur; //en pixel
      int largeur; //en pixel
   ...
 }
 class Rectangle:public Forme{...}
 class Cercle:public Forme{...}

Ainsi, puisque toutes les figures ont un point d'origine, une hauteur, une largeur, une aire et un périmètre, nous pouvons les regrouper en une super-classe. Grâce au polymorphisme nous pourrons définir le comportement précis de chacun des types de figures simplement en faisant référence à la classe Forme, sans se soucier de ce que cette figure est réellement.

Web

La distinction concret/abstrait existe aussi pour la rédaction de code HTML. Le cas le plus célèbre est celui des entités « physiques » et des entités « logiques », notamment i/em et b/strong. Le premier élément de chaque paire renvoie à une valeur concrète (mise en italique/mise en gras) alors que le second élément renvoie à une valeur abstraite (emphase/forte emphase) qui, dans le domaine visuel (écran, projection, impression) se traduit par une mise en italique/en gras. Mais pas par exemple dans un média oral ou Braille. Cette nécessité d'abstraire le code est la raison pour laquelle les éléments i et b sont déconseillés (ils ont d’ailleurs disparu en XHTML 2.0).