Un peu de nostalgie
Dans le monde du logiciel, les interfaces utilisateur tiennent
une place importante. Aux débuts de l’informatique, lorsque les capacités des
machines étaient modestes, les UI (User Interface) étaient de simples terminaux
connectés à un serveur central. Puis sont apparus les ordinateurs personnels
dont le système d’exploitation proposait une CLI (Command Line Interface).
Ces CLI n’étaient pas très faciles à utiliser par les
néophytes en informatique, et pouvaient en rebuter plus d’un. Puis les éditeurs
de logiciels ont compris que la simplicité d’utilisation était un élément déterminant
dans le succès d’un produit.
Sont alors apparues les premières interfaces
« intuitives »:- Certaines en mode texte TUI (Text User Interface). Je me souviens du Framework « Turbo Vision » de Borland, ou bien du logiciel PC Tools sous Ms-DOS, qui permettait de réaliser des opérations courantes sur les disques locaux.
![]() |
| Turbo Vision |
- Certaines en mode graphique GUI (Graphical User Interface). Par exemple sur le premier Macintosh ou bien le système Amiga OS.
![]() |
| Amiga OS |
j Aujourd’hui, à l’heure où la concurrence informatique est
rude, au delà de la performance brute d’un logiciel, la qualité d’une interface
utilisateur est déterminante dans le choix d’une application.
Je pourrais citer par exemple le cas des logiciels de
compression. D’innombrables freewares existent sur le net, il est naturel que
l’utilisateur oriente son choix vers l’application la plus fluide, et la plus
ergonomique.
Je tiens à noter que la ligne de commande reste très utile,
notamment pour la création de batchs et l’automatisation de tâches, cependant je
considère que son utilisation concerne un public plus restreint.
Mon framework personnalisé
J’ai utilisé dans le paragraphe précédent le terme
ergonomie. Qui aimerait travailler sur un bureau bancal ou avec un outil trop
lourd à manipuler ?
Certaines choses apparaissent évidentes lorsqu’on parle
d’ergonomie, cependant l’ergonomie logicielle est souvent négligée (notamment
dans les logiciels destinés aux professionnels)
Il m’est souvent arrivé de me battre contre des fenêtres non
redimensionnables qui dépassent de l’écran, ou a contrario, d’un ascenseur sans
fin dans une fenêtre minuscule. Il est plutôt rare de rencontrer des logiciels
qui proposent une impression correctement paginée (en dehors des
visionneurs/éditeurs de documents bien entendu).
Il est aisé de critiquer, mais il faut admettre qu’il n’est
pas simple de créer une bonne interface utilisateur. Cela demande un investissement
de temps et souvent d’argent.
Développant moi-même régulièrement des logiciels, je me
heurte naturellement à ces problématiques.
J’ai donc décidé de créer un framework personnalisé, je me
suis fixé le cahier des charges suivant :
- Il doit être développé sur la plateforme .net. WPF se prête très bien à la création d’interfaces riches.
- Il doit être portable (sous forme d'une ou plusieurs DLL)
- Il doit nécessiter le moins de code possible pour l’utilisateur
- Son intégration doit être la plus élégante et transparente possible
- Les éléments de l’interface doivent s’adapter dynamiquement à la taille de la fenêtre et de l’écran (bon, ça c’est quand même la base)
- Il doit supporter l’annulation et le rétablissement de toutes les actions
- Il doit prendre en charge la sélection multiple et l’édition en groupe
- La mise à jour des données doit s’afficher en temps réel dans l’application (je n'aime pas les boutons de rafraîchissement)
- Il doit être possible de charger ou de sauvegarder les informations dans une base de données (ex MS SQL).
- Il doit être possible de charger ou de sauvegarder les informations dans un fichier (ex XML)
- Dans le cas d’une mise à jour vers un serveur distant (SQL ou autre), seules les données modifiées ou ajoutées doivent être prises en compte. Par exemple, si un utilisateur modifie un seul nom dans un annuaire téléphonique, il serait très pénalisant de pousser l’ensemble de l’annuaire dans la base de données.
- Il doit être gratuit (tant qu’à faire autant en faire profiter les autres)
Mise en pratique
Mes recherches initiales sur le sujet m’on amenées à étudier la méthode MVVM (Model, View, View Model). Cependant j’ai trouvé que cette dernière présente plusieurs inconvénients :- Beaucoup de code nécessaire. L’utilisateur doit créer un ViewModel pour chaque Model.
- L’intégration des commandes utilisateurs au sein du ViewModel limite l’interaction avec la vue. Par exemple, dans le cas ou nous aurions besoin d’afficher un message de confirmation lors de la suppression d’un élément. En principe, le ViewModel ne doit jamais avoir connaissance de la vue qui le présente.
- La synchronisation des données entre le modèle et le ViewModel. Ceci devient un vrai cauchemar lorsqu’on décide d’implémenter l’annulation/rétablissement
- La sélection multiple, ce sujet sera traité dans les articles dédiés.
Mon implémentation est loin d’être parfaite. Lecteur
trouvera au fil des articles quelques limitations. Par exemple, mon implémentation n’est pas adaptée pour la manipulation d’énormes quantités de données. Ces
dernières sont toutes chargées en mémoire, non pas dynamiquement ni à la demande. Cependant je trouve que mon travail se prête à
la majorité des besoins quotidiens.
Dans les articles suivants je vais essayer d’expliquer
progressivement comment utiliser mon framework. Ces tutoriels supposent que le
lecteur dispose déjà des connaissances générales en développement C# et de WPF.
J’utilise Visual Studio 2010 Express pour réaliser mes
exemples, le code de chaque projet est disponible en téléchargement dans l'article post associé.


Aucun commentaire:
Enregistrer un commentaire