2.3 Les modèles d'interface formels

Une grande variété de modèles, langages et méthodes formelles ont été développés pour spécifier, concevoir, vérifier, implémenter et tester divers systèmes. Certains d'entre eux ont été employés dans le but de concevoir des interfaces plus fiables, c'est-à-dire moins sujettes aux erreurs de conception humaines. Ces méthodes sont principalement employées dans les applications critiques, par exemple celles qui mettent en jeu la vie ou la sécurité humaine (centrales nucléaires, contrôle aérien). Elle sont également employées dans certaines applications industrielles non critiques car elles donnent des garanties de fiabilité tôt dans le cycle de conception et permettent de raccourcir la phase de test. Les modèles formels sont également utilisés comme support pour raisonner sur les propriétés et le comportement des interfaces.

Les méthodes formelles ne constituent pas le sujet de notre thèse. Cependant, ce sont également des modèles d'interfaces, et nous les décrivons comme tels. Nous présentons ici deux approches qui nous semblent essentielles dans le domaine de l'interaction homme-machine: les modèles à base de systèmes de transition et les modèles d'interacteurs formels.

2.3.1 Les systèmes de transition

Les systèmes de transition désignent un ensemble des notations permettant de décrire des comportements dits « orientés contrôle ». Il en existe un très grand nombre, presque tous des extensions des automates à états finis ou des réseaux de Petri respectivement introduits en 1955 et 1962.

Ces deux notations graphiques et leurs variantes sont encore couramment employées aujourd'hui en interaction homme-machine, soit à des fins de spécification formelle, soit pour raisonner sur des systèmes interactifs ou expliquer leur fonctionnement. S'ils ne permettent de décrire que des petites parties d'une interface (et ne constituent pas des modèles d'interfaces à proprement parler), ils entrent dans la composition de certaines méthodes formelles plus exhaustives. Nous présentons ici ces deux notations et quelques-uns de leurs emplois.

2.3.1.1 Les automates à états finis

Les automates à états finis ou machines à états finis, dont les principales variantes sont les machines de Moore [Moore, 1956] et de Mealy [Mealy, 1955], ont été employés pour spécifier le comportement dynamique de certains systèmes, et sont notamment utilisés pour décrire certaines parties des interfaces utilisateur.

Les automates à états finis sont représentés graphiquement par des diagrammes de transition d'états, graphes orientés dont les n $\oe$ uds sont des états et les arcs des transitions (figure 2.10). Un état est un ensemble de valeurs qui caractérise le système à un moment donné dans le temps. Une transition d'état est une relation entre deux états indiquant un changement d'état possible, et qui peut (dans les automates étendus, par exemple) être annotée pour indiquer les conditions et les sources de déclenchement (événements) et les opérations qui en résultent (sorties).

**Figure:** Le cliquer-glisser décrit par un diagramme de transition d'états [Tyson R. et al., 1990].
$\begin{figure} \begin{center} \includegraphics[scale=0.3]{drag_std} \end{center} \end{figure}$

La figure 2.10 est un diagramme de transition d'états simple et classique qui décrit la gestion du cliquer-glisser (drag_start, drag_feedback, drag_end) à partir d'événements souris de type press, release et move [Tyson R. et al., 1990]. Les transitions sont annotées par les événements qui les déclenchent (en gras) et les sorties produites (en italique). Cet automate filtre tous les événements move ayant lieu avant le press ou après le release.

Les automates à états finis menant rapidement à une explosion du nombre d'états et de transitions, de nombreuses extensions ont été proposées. Les machines à états hiérarchiques et les statecharts [Harel, 1987] décrivent des automates composables, ce qui facilite la description de systèmes complexes et autorise la réutilisabilité. Les automates à états finis peuvent également être employés comme compléments à des outils de programmation conventionnels [Blanch, 2002] ou en association avec d'autres formalismes pour décrire des parties plus importantes de l'interface. Robert Jacob[Jacob et al., 1999] emploie des automates pour spécifier les aspects discrets de l'interaction en entrée et des flots de données pour les aspects continus. Il décrit également un éditeur visuel VRED qui sera évoqué dans la section 2.7.3.

2.3.1.2 Les réseaux de Petri

Les réseaux de Petri [Petri, 1962] sont une généralisation des automates à états. Ils ont été largement utilisés pour modéliser la concurrence et la synchronisation dans les systèmes distribués, et sont employés pour décrire certains comportements dans les interfaces. Nous présentons cette notation sans rentrer dans les détails.

Un réseau de Petri est un graphe biparti alterné qui possède deux types de n $\oe$ uds : les places (cercles) et les transitions (rectangles). Des arcs (flèches) relient les places aux états (voir figure 2.11). L'état du système, nommé marquage, est défini par la répartition de jetons (petits cercles foncés) dans les places. Une transition est franchissable sous certaines conditions, notamment lorsque suffisamment de jetons sont présents dans ses places d'entrée. Le franchissement d'une transition se traduit par une modification du marquage consistant la plupart du temps en un « déplacement » de jetons.

**Figure:** Un comportement bas-niveau du clavier (répétition de touches) décrit avec une variante élaborée de réseau de Petri [Accot et al., 1997].
$\begin{figure} \begin{center} \includegraphics[width=\textwidth]{formal_transducers1} \end{center} \end{figure}$

Le modèle des transducteurs formels [Accot et al., 1997] emploie des réseaux de Petri de haut-niveau [Jensen, 1995] pour décrire les transformations successives des événements d'entrée. La figure 2.11 décrit un niveau de transformation pour le clavier. Dans cette notation, les jetons sont typés et comportent une valeur, les arcs sont annotés par des variables (<k> sur la figure) et des événements extérieurs viennent déclencher des transitions (ellipses grises et flèches coudées). Quatre touches sont représentées par quatre jetons en haut de la figure, en attente dans la place Idle. En-dessous se trouve la transition Post, qui est activée par des événements clavier de type Down avec une touche k en paramètre. Lorsqu'un événement

arrive, cette transition est franchie si le jeton

est présent dans

, auquel cas le même événement

est généré et le jeton passe dans la place

. Il retourne à la place

lors du prochain événement

. Une partie de ce réseau de Petri répète simplement les événements

(avec cependant un filtrage grammatical), et une autre partie (la partie grisée) décrit un mécanisme de répétition automatique de touches avec génération d'événéments

. Cette dernière emploie des réseaux de Petri stochastiques généralisés [Marsan et al., 1995] pour décrire des transitions temporisées.

Les réseaux de Petri ont été intégrés dans plusieurs méthodes et outils formels utilisés pour décrire la majeure partie des interfaces utilisateur. Le formalisme ICO (Interactive Cooperative Objects) [Palanque and Bastide, 1993,Palanque and Bastide, 1997] emploie une approche orientée-objet pour modéliser les aspects statiques du système interactif et des réseaux de Petri de haut-niveau pour en décrire les aspects dynamiques. Il est livré avec l'outil PetShop [Bastide et al., 2002,Schyn et al., 2003], qui comporte un éditeur interactif permettant de construire des spécifications ICO et de les exécuter.

2.3.2 Les interacteurs formels

Dans cette section, nous regroupons sous le terme interacteurs formels deux modèles formels très liés, et qui décomposent les systèmes interactifs en unités autonomes appelées interacteurs (objets d'interaction), qui communiquent entre eux, avec le système ou avec l'utilisateur par le biais de stimuli (ou événements).

Les deux principaux modèles formels à base d'interacteurs ont été développés dans le cadre du projet Esprit AMODEUS, l'un à l'Université d'York (Angleterre), l'autre à l'institut CNUCE (Pise, Italie). Le modèle d'York [Duke and Harrison, 1993] est une variante modulaire du modèle mathématique PIE [Dix and Runciman, 1985]. Son but est de fournir un cadre pour une spécification structurée des systèmes interactifs à base de notations orientées modèle comme Z ou VDM. L'approche de CNUCE [Paternò and Faconti, 1992], inspirée des travaux sur les modèles graphiques de référence comme GKS [ISO, 1985], est plus constructive. Ce modèle est utilisé conjointement avec LOTOS [ISO, 1987], un langage basé sur l'algèbre des processus.

Nous donnons ici un aperçu conceptuel de ces deux modèles, sans rentrer dans les détails liés aux notations mathématiques.

2.3.2.1 Les interacteurs d'York

Dans le modèle d'York [Duke and Harrison, 1993], un interacteur est défini comme un composant dans la description d'un système interactif qui encapsule un état, les événements qui manipulent cet état, et les moyens par lesquels cet état est rendu perceptible par l'utilisateur.

**Figure 2.12:** Schéma général d'un interacteur d'York.
$\includegraphics[scale=0.4]{yorkmodel}$

Le schéma général d'un interacteur d'York est représenté sur la figure 2.12. Un interacteur d'York consiste en un objet comportant un état et communiquant avec son environnement par des événements de type stimulus ou réponse. Un interacteur possède également une présentation, qui reflète l'état de l'objet de façon perceptible par l'utilisateur. La relation de rendu $\rho$ spécifie les présentations possibles pour un état (et éventuellement un historique) donné de l'objet.

Dans une version raffinée de ce modèle, l'élément présentation est explicité par un nouvel objet apparié à l'objet principal, et dont l'état interne représente les caractéristiques d'affichage perceptibles par l'utilisateur.

**Figure 2.13:** Un mécanisme simple de sélection et de déplacement d'icônes décrit avec les interacteurs d'York.
$\includegraphics[scale=0.6]{yorkexample}$

La figure 2.13 montre comment un comportement simple de système interactif peut être décrit par des combinaisons d'interacteurs. Dans cet exemple, des icônes (disques, fichiers, répertoires) peuvent être manipulées par une souris à un bouton représenté par un curseur. Une icône peut être sélectionnée ou désélectionnée en cliquant à son emplacement, ce qui a pour effet de changer son apparence. Enfin, les icônes sélectionnées peuvent être déplacées en cliquant sur la commande ``déplacer'' dans un menu, puis en bougeant la souris.

2.3.2.2 Les interacteurs de CNUCE

Le modèle de CNUCE [Paternò and Faconti, 1992], plus détaillé que le précédent, décrit en plus la structure et le comportement de base d'un interacteur, distingue plusieurs types et sources d'événements, et introduit la notion de niveau d'abstraction.

Les auteurs de ce modèle définissent un interacteur comme une entité d'un système interactif capable de réagir à des stimuli externes, en traduisant des données d'un haut niveau d'abstraction vers un niveau plus bas d'abstraction et vice-versa. Un système interactif est ainsi décrit comme un graphe d'interacteurs communiquant entre eux. Au plus bas niveau, ils communiquent avec l'utilisateur et au plus haut niveau, ils communiquent avec l'application.

**Figure 2.14:** Le schéma simplifié d'un interacteur de CNUCE (à gauche), et sa structure interne (à droite). Le schéma de droite reproduit les noms de flux employés dans le formalisme original.
$\includegraphics[scale=0.4]{cnucemodel}$

Vu de l'intérieur, un interacteur est structuré en quatre composants qui communiquent entre eux (figure 2.14, schéma de droite) : la collection maintient les informations relatives au modèle abstrait de l'interacteur. Lorsque cet élément est déclenché, il transmet ces informations à la présentation qui met à jour les éléments visibles par l'utilisateur. D'autre part, la mesure reçoit et accumule les informations provenant de l'utilisateur. Lorsqu'elle est déclenchée, elle les transmet à l'abstraction qui les convertit en données abstraites manipulables par l'application. La mesure peut également se servir d'informations provenant de la collection.

Notons que l'élément collection peut être assimilé à l'état de l'interacteur d'York, et que la présentation joue à peu près le même rôle dans les deux modèles. La mesure et l'abstraction n'ont pas d'équivalent dans le modèle d'York, et font implicitement partie de l'état.

**Figure 2.15:** Vue interne de l'interacteur *Commandes* dans le modèle de CNUCE.
$\includegraphics[scale=0.4]{cnuceexample}$

L'exemple de la section précédente peut être décrit avec trois interacteurs, de manière très analogue au modèle d'York. La figure 2.15 reproduit uniquement l'interacteur Commandes. Les entrées du côté utilisateur (en bas à droite) sont connectées à l'interacteur Souris, et la sortie du côté application (en haut à droite) est connectée à l'interacteur Icônes. Les autres connexions sont laissées implicites. Lorsqu'il est déclenché par un clic de souris, l'interacteur compare la position courante stockée dans la mesure à la structure stockée dans la collection, et selon l'option activée dans le menu, génère l'événement approprié interprétable par les autres interacteurs.

2.3.3 Conclusion

Dans cette section, nous avons donné un bref aperçu de deux approches formelles employées pour décrire les interfaces utilisateur, à savoir les systèmes de transition et les interacteurs formels.

Les systèmes de transition sont particulièrement bien adaptés à la description des comportements de type contrôle dans les applications interactives. Ils ont été employés pour décrire le niveau dialogue de l'interaction, le comportement des widgets, ou encore la production d'événements synthétiques. Le modèle des transducteurs formels propose un modèle d'entrée transformationnel, et constitue une tentative intéressante de modéliser par rétro-conception le comportement très bas-niveau des dispositifs physiques. Les systèmes de transition ne permettent cependant pas de décrire des parties importantes des interfaces, en particulier les flux de données et l'interaction continue, et c'est pourquoi ils sont fréquemment employés en conjonction avec d'autres formalismes.

Les interacteurs formels sont beaucoup plus structurants pour les interfaces graphiques. Ils décomposent l'interaction en des entités communicantes, à la manière des modèles de référence à agent. Ces interacteurs reçoivent des valeurs en entrée et produisent des sorties. Les interacteurs d'York communiquent entre eux par des stimuli et des réponses, et avec l'utilisateur en maintenant une présentation. Mais la partie entrée de cette communication n'est pas explicite dans le modèle. Le modèle de CNUCE, en plus de décrire une structure et un comportement interne pour les interacteurs, emploie comme les transducteurs formels un modèle d'entrées de type transformationnel basé sur des couches d'abstractions successives.