
Concevoir une application : du besoin au test, quatre notions essentielles
Relier les quatre notions besoin, interface, code et test en une démarche cohérente, et vérifier qu'une application répond à un besoin exprimé par ses utilisateurs.
Ce que dit la fiche
Les points essentiels
- Le besoin exprime ce que les utilisateurs veulent pouvoir faire avec l'application et pour quel résultat ; il se formule en fonctionnalités vérifiables, avant tout choix technique.
- L'interface est la partie visible par laquelle l'utilisateur dialogue avec l'application : écrans, formulaires, boutons, messages. Elle doit être adaptée aux utilisateurs visés et à leurs tâches.
- Le code est l'ensemble des instructions écrites dans un langage de programmation ; il traduit le besoin en traitements, stocke ou récupère des données et réagit aux actions de l'utilisateur dans l'interface.
- Le test consiste à exécuter l'application avec des données choisies pour comparer le résultat obtenu au résultat attendu et repérer les anomalies avant la mise en service.
- Les quatre notions s'enchaînent mais ne sont pas strictement linéaires : un test qui révèle un écart peut obliger à corriger le code, l'interface, voire à préciser le besoin.
- Un bon besoin est précis, compréhensible, vérifiable : « calculer le montant de la commande » se teste, « une application agréable » ne se teste pas facilement.
- Un jeu d'essai comprend des données d'entrée, le résultat attendu fixé avant l'exécution et le résultat obtenu ; il inclut des cas normaux et des cas limites ou erronés (champ vide, valeur négative).
- Tester ne prouve pas l'absence d'erreur : cela réduit le risque en montrant que, pour les cas essayés, l'application se comporte comme prévu.
Les mots à connaître
- Besoin
- Ce que l'organisation ou l'utilisateur attend de l'application, exprimé en fonctionnalités et en contraintes, indépendamment de la manière de le programmer.
- Interface
- Moyen d'interaction entre l'utilisateur et l'application (écrans, zones de saisie, boutons, messages d'erreur) qui permet de saisir des données et d'obtenir des résultats.
- Code
- Suite d'instructions écrites dans un langage de programmation, exécutée par l'ordinateur pour réaliser les traitements attendus.
- Test
- Exécution de l'application sur un jeu d'essai pour comparer résultat attendu et résultat obtenu et détecter les anomalies.
La méthode, étape par étape
- Identifier les utilisateurs et reformuler le besoin sous forme de fonctionnalités précises et vérifiables.
- Concevoir l'interface : repérer les données à saisir, les résultats à afficher et les actions à proposer, en pensant à la tâche de l'utilisateur.
- Écrire le code qui relie l'interface aux traitements et aux données : lecture de la saisie, calcul ou règle de gestion, affichage du résultat.
- Préparer un jeu d'essai avec cas normaux, cas limites et cas erronés, en fixant le résultat attendu avant d'exécuter.
- Exécuter, comparer attendu et obtenu, puis corriger la cause de chaque écart (besoin, interface ou code) et retester.
Des exemples résolus
Une boulangerie veut une application pour calculer le montant d'une commande de viennoiseries. Un croissant coûte 1,20 € et un pain au chocolat 1,50 €. Identifier le besoin, un élément d'interface, la logique du code et un test pour 3 croissants et 2 pains au chocolat.
Besoin : calculer automatiquement le montant total d'une commande à partir des quantités saisies. Interface : deux zones de saisie (quantité de croissants, quantité de pains au chocolat) et un bouton Calculer qui affiche le total. Code : multiplier chaque quantité par son prix unitaire puis additionner les deux montants. Test : résultat attendu fixé avant exécution = 3 × 1,20 + 2 × 1,50 = 3,60 + 3,00 = 6,60 €. Si l'application affiche 6,60 €, le test est réussi pour ce cas ; sinon on cherche l'erreur dans le code.
Une association propose une application d'inscription à un tournoi réservé aux 12 ans et plus. L'application accepte la saisie d'un âge de 8 ans. Quelle notion est en cause, quel test l'aurait révélé, et comment corriger ?
Le besoin précise une règle de gestion : seuls les participants de 12 ans et plus peuvent s'inscrire. Le code ne l'applique pas. Un test avec cas limites l'aurait révélé : âge 11 (attendu : refus), âge 12 (attendu : acceptation), âge 8 (attendu : refus). Le cas 8 ans montre un écart entre attendu et obtenu. Correction : ajouter dans le code la condition âge supérieur ou égal à 12, côté interface afficher un message d'erreur clair, puis rejouer les trois tests pour vérifier que la correction fonctionne et qu'aucun cas valide n'est devenu refusé.
Les pièges à éviter
- Confondre l'interface et l'application entière : un écran réussi ne garantit pas que les calculs soient exacts. L'interface n'est que la partie visible ; le code et les données doivent être testés aussi.
- Ne tester que le cas normal et conclure que l'application est correcte. Il faut ajouter des cas limites et erronés (champ vide, valeur négative, valeur au seuil) et fixer le résultat attendu avant l'exécution, sinon on risque de justifier le résultat obtenu.
Teste-toi
Citez les quatre notions étudiées et indiquez en une phrase le rôle de chacune dans la conception d'une application.
Voir la réponse
Besoin : ce que l'utilisateur attend ; interface : moyen d'interaction visible ; code : instructions qui réalisent les traitements ; test : vérification attendu/obtenu.
Les quatre notions forment une démarche : on exprime le besoin, on conçoit l'interface, on écrit le code puis on teste. Chaque définition correspond à une étape précise, et le test ferme la boucle en vérifiant que le résultat répond au besoin initial.
Une application de réservation de salles doit refuser une réservation si la salle est déjà prise. Rédigez deux tests (un cas normal, un cas limite ou erroné) en précisant données et résultat attendu.
Voir la réponse
Cas normal : salle libre à la date demandée, réservation acceptée. Cas erroné : salle déjà réservée au même créneau, réservation refusée avec message d'erreur.
Un test valable précise les données d'entrée et le résultat attendu avant exécution. Le cas erroné est indispensable car la règle de gestion consiste justement à refuser un conflit de créneau ; tester seulement le cas libre ne vérifierait pas cette règle.
Un test révèle que le total affiché est faux alors que l'écran de saisie est clair. Dans quelle partie chercher l'erreur en priorité, et que faire ensuite ?
Voir la réponse
Chercher d'abord dans le code, notamment dans le calcul, puis corriger et retester ; vérifier aussi que le besoin était bien formulé.
L'interface étant claire, l'écart entre attendu et obtenu provient plus probablement d'un traitement erroné dans le code. Après correction, on rejoue le test pour confirmer la réparation et s'assurer qu'aucun autre cas n'est devenu faux ; si l'erreur venait d'une règle mal comprise, on reprend le besoin.
Cette fiche fait partie de notre collection Systèmes d'information de gestionRetrouve nos autres fiches de Terminale technologique pour réviser efficacement !
Voir toutes les fiches