De manière générale, est-il préférable de créer toutes les parties fonctionnelles ou de faire fonctionner l'interface utilisateur en premier - ou un mélange des deux?

De manière générale, est-il préférable de créer toutes les parties fonctionnelles ou de faire fonctionner l'interface utilisateur en premier - ou un mélange des deux?

En supposant que vous travailliez sur un projet volumineux, est-ce une pratique généralement acceptée de faire fonctionner tous les objets fonctionnels de collecte de données fonctionnels avant toute interface utilisateur, de travailler tous les éléments une par une à la fois ou au milieu?

Nous savons tous qu'il faut décomposer le travail en éléments gérables, mais la question qui se pose est de savoir si l'assurance-chômage est incluse dans des éléments gérables, je suppose.

Dans le cas de l'exemple, considérons une application graphique avec une fenêtre racine, mais plus d'une douzaine d'onglets dans différents docks pour séparer différents composants de données. Chaque onglet individuel comporte un ensemble relativement complexe de pièces mobiles du point de vue des unités fonctionnelles.

L'exemple d'application dans cette question particulière est ici avec le blog d' accompagnement et le produit commercial d'origine .

De nombreux utilisateurs professionnels et clients pensent généralement que, lorsque l’ apparence est complète, elle est presque complète. Comme vous le savez probablement, c'est loin de la vérité. On peut l’avoir beau, mais sans back-end et certains utilisateurs pensent qu’il faut 80% du travail pour le rendre beau, pas 20% ( ou l’autre 80% ).

D'innombrables développeurs peuvent raconter des histoires horribles à ce sujet: faire une maquette des pages dans Microsoft Word à l'aide de captures d'écran d'un autre outil, et le client affirmant: "Alors, vous avez presque terminé?"

Vous devez ajuster le temps pour que toutes les parties soient terminées quand c'est fait. Essayer de faire tout le back-office en premier et ensuite tout le front-end amènera l'utilisateur final à penser que vous ne faites rien et à vous demander pourquoi vous êtes payé alors que rien ne prouve rien. D'un autre côté, front-end en premier, vous trouverez l'utilisateur final en train de faire des changements insidieux et de consommer tout notre temps.

Le pire des cas avec un «un d'abord et l'autre» est lorsque vous arrivez à l'autre partie, vous constatez que cela ne correspond pas du tout au design.

Ainsi, construisez les deux. Montrez les progrès dans le front-end, faites-le travailler avec ce que vous construisez. Dans de nombreux cas, c’est une bonne idée de fournir des versions incrémentielles et de vous assurer que vous réalisez ce que le client veut (cela entre dans Agile). Rester trop longtemps sans «progrès visibles» peut nuire à la relation client (il s'agit dans les deux cas de «tout semble être fait tôt» et de «rien ne se fait jusqu'à la fin» - il est difficile pour le client de voir le cadre en cours d'écriture ou l’unité des tests ou la désinfection des données en cours).

Joel a écrit à ce sujet dans The Iceberg Secret, Revealed :

Corollaire important deux. Si vous montrez à un non-programmeur un écran doté d'une interface utilisateur 100% belle, ils penseront que le programme est presque terminé.

Les personnes qui ne sont pas des programmeurs ne font que regarder l'écran et voir des pixels. Et si les pixels ressemblent à un programme qui fait quelque chose, ils se disent: "Oh, ça alors, est-ce que ça pourrait être plus difficile de le faire fonctionner?"

Le gros risque ici est que si vous commencez par simuler une interface utilisateur, probablement pour pouvoir engager des conversations avec le client, tout le monde va penser que vous avez presque fini. Et ensuite, quand vous passerez l'année prochaine à travailler «à couvert», pour ainsi dire, personne ne verra vraiment ce que vous faites et pensera que ce n'est rien.

Ceci est encore répété dans l'article de blog Ne donnez pas à la démo le look Done qui contient ce graphique utile:

Notez ici que les deux options reflètent généralement les options suivantes: "faites-le fini" (et attendez-vous à ce que vous le fassiez bientôt) et "faites le backend" (et le client craint que vous ne respectiez pas l'échéance).

Comment «fait» quelque chose ressemble devrait correspondre à comment «fait» quelque chose est.

Tous les développeurs de logiciels ont vécu cette expérience plusieurs fois dans leur carrière. Mais les outils de publication assistée par ordinateur entraînent les mêmes problèmes pour les rédacteurs techniques: si vous montrez un brouillon parfaitement typé et formaté, il le considère comme plus abouti que vous le souhaiteriez. Nous avons besoin d'une correspondance entre ce que nous sommes et ce que les autres perçoivent comme nous sommes.

Cet article soulève également un point important sur le type de commentaires que vous obtenez avec différents niveaux de cuisson de l'interface utilisateur. Si vous avez quelque chose qui semble complet, vous aurez plus de chances de recevoir des commentaires sur «pourriez-vous changer la police» que sur «cette disposition ne fonctionne pas - il y a trop d'onglets».

Pour ceux qui se battent avec cela dans le monde Java Swing, il existe une apparence appelée " serviette" qui permet à l'interface utilisateur de ne pas paraître complète (même si c'est le cas).

La clé ici est de faire en sorte que cela ne look fait. Avoir l'interface utilisateur complète est un signe pour de nombreux utilisateurs que l'application est complète (même si ce ne sont que quelques pages statiques sans aucune logique derrière ou quelque chose de construit dans un constructeur d'interface).

Lectures complémentaires (et liens de l'article):

• Le secret de l'iceberg révélé
• Ne donnez pas à la démo un aspect fini
• Serviette Look & Feel pour Swing
• Pourquoi les graphes de style xkcd sont importants

Cela dépend: vous avez besoin d'une boucle de rétroaction serrée autour de votre fonctionnalité la plus importante.

Si le cœur de ce que vous faites, la partie risquée et effrayante, est un moteur interne, faites-la fonctionner dans la console ou via des tests unitaires. Par exemple, un analyseur de protocole n'a pas besoin d'une interface utilisateur pour savoir s'il fonctionne correctement.

Si votre style cool implique une interactivité (une interactivité nécessitant constamment de dépanner, de jeter et de redécouvrir), une approche d'abord axée sur l'interface utilisateur est cruciale. Par exemple, je souhaite créer une application pour permettre aux utilisateurs d'interagir avec une visualisation de données. La chose la plus importante que je dois comprendre est de savoir si la visualisation est significative, alors je vais probablement jeter une demi-douzaine d'approches avant d'en choisir une. Je vais faire tout cela avant d'écrire un seul test unitaire.

Il y a une zone grise floue entre vous permettant de décider de la meilleure combinaison pour mieux interagir et valider votre code (tests automatisés? Interface utilisateur pour l'expérimentation?). J'ai personnellement fait les deux extrêmes et tout le reste, et choisir le bon endroit pour faire partie de ce spectre est l'une des choses les plus difficiles à décider et dépend à 100% du type de chose que je construis.

Dans un environnement agile, vous entendrez peut-être parler de "squelettes ambulants" ou de "fines tranches verticales". L'idée étant que, dans la mesure où le logiciel est ce qui est important pour l'utilisateur, vous le créez pièce par pièce.

Dans l'exemple d'application que vous avez mentionné, vous commenceriez par la fenêtre et peut-être un onglet, puis vous le feriez fonctionner de front. Ensuite, au fil du temps, vous ajouteriez des fonctionnalités et donc des onglets au cas par cas, permettant à chaque fonctionnalité de fonctionner au fur et à mesure de sa création. Cela fait partie de ce que les démonstrations fréquentes de clients vous donnent: une occasion de montrer quelque chose de nouveau et d’obtenir un retour immédiat.

En bref, oui, le travail d'interface utilisateur fait absolument partie intégrante d'une unité de travail fonctionnel, si vous avez une interface utilisateur.

Commencez par quelque chose de petit qui fonctionne, puis modifiez-le pour offrir un logiciel complet.

Je recommanderais de combiner les fonctionnalités et l'interface utilisateur (et d'obtenir des retours d'expérience ou des tests dès que possible).

BTW, n’est-ce pas ainsi que sont développés les logiciels les plus volumineux? Regardez par exemple dans le navigateur Firefox : d’une version à l’autre, les fonctionnalités et l’interface utilisateur ont évolué.

Dans les applications volumineuses (basées sur le Web PHP) sur lesquelles je travaille, j'essaie tout d'abord de mettre en place les classes et les méthodes, qui retournent des valeurs factices . Cela permet d'établir un pseudo-contrat que les autres développeurs peuvent utiliser pour implémenter l'interface utilisateur.

Un autre avantage de cette méthode est que nous pouvons affiner le contrat / l'interface lorsque les exigences de l' interface utilisateur changent (et qu'elles changent toujours), avant même que tout le code soit écrit et livré.

Ce que j'ai tendance à faire, c'est de commencer par une interface utilisateur de merde : quelque chose qui vide les données variables à l'écran. Pas de polices, pas d'alignement, rien de graphique pendant longtemps. Juste "Welcome user x" et des boutons appelés "load pic" etc.

Au fur et à mesure que le développement avance, vous constaterez peut-être que plus de choses doivent continuer, ou moins. Mais à un moment donné, vous déciderez que le backend est presque terminé. Maintenant, vous avez une interface utilisateur qui contient toutes les pièces jointes nécessaires et vous pouvez passer beaucoup de temps à faire tout le travail graphique.

Attention cependant, ce n'est pas infaillible. Vous avez besoin d'un peu de prévoyance pour voir certaines questions se poser. Par exemple, vous devrez peut-être rechercher des composants de l'interface utilisateur pour afficher les données de manière judicieuse.

Si vous utilisez un bon système de suivi des étapes et des problèmes, vous pouvez éviter certains de ces problèmes car, en un coup d'œil, la direction peut voir à quel point vous êtes productif. Ils pourront voir que le backend est terminé à 80% et que l'interface utilisateur est le prochain jalon. ils seront en mesure de voir que vous avez un ensemble d'interfaces utilisateur et de tâches principales à terminer pour un jalon de fonctionnalité spécifique. Mais tout commence par les exigences du projet, et la réponse de Doug T soulève quelques points positifs sur cet aspect de la conception d'un système.

Pensez du point de vue de vos utilisateurs / clients. Un système logiciel est un ensemble de fonctionnalités qui donnent une valeur à ces utilisateurs / clients. Bien sûr, chacune de ces fonctionnalités ont une interface utilisateur, un backend et quelques autres choses.

Construisez votre système toujours par caractéristique et essayez de diviser en très petites fonctionnalités. De cette façon, vous êtes toujours près d'avoir quelque chose de plus à offrir à vos clients. N'oubliez pas que le développement logiciel ne consiste pas à construire la version 1.0, mais plutôt à passer de la version 1.0.1 à la version 1.0.2, etc.

Ça dépend. Dans quelle mesure vos exigences sont-elles bien définies? À quelle partie du système l'interface utilisateur est-elle confrontée?

D'après mon expérience, la plupart des clients ne savent pas ce qu'ils veulent jusqu'à ce qu'ils voient quelque chose devant eux. Donc, normalement, je fournis des images filaires d’aspects clés de l’interface utilisateur ou je livre la majorité de l’UI (non fonctionnelle). Cela permet au client de changer d'avis sur les caractéristiques / fonctions sans trop d'impact car la conception de la base de données et la structure du code n'en sont encore qu'à la phase de conception - il est facile de modifier la conception. Il est plus facile / plus rapide de changer de conception plus tôt dans le projet, puis plus tard.

États agiles, vous devez également travailler en premier sur les éléments les plus difficiles et les plus importants. Échec rapide . Donc, une fois que le client a vu l'interface utilisateur, je me concentre sur la construction de petits composants entièrement fonctionnels, ce qui en dit le plus important et le plus difficile à mettre en œuvre en premier. Vous saurez ainsi le plus tôt possible si vous rencontrez des difficultés.

Ensuite, vous avez vos sprints et une communication constante avec le client, développant l'interface utilisateur et les aspects fonctionnels à la fois.