Réaliser
Développer (c'est-à-dire concevoir, coder, tester et intégrer) une solution informatique pour traiter un problème métier.
Apprentissages critiques
Implémenter des conceptions simples
Traduire une conception en code fonctionnel en respectant les spécifications et les langages cibles (Python, HTML/CSS, SQL…).
Élaborer des conceptions simples
Analyser un besoin client et proposer une architecture ou un algorithme adapté avant toute implémentation.
Faire des essais et évaluer leurs résultats
Tester systématiquement la solution produite et comparer les résultats obtenus aux spécifications initiales.
SAE 1.01 — Implémentation d'un besoin client
$ cat contexte.md
La SAE 1.01 avait pour objectif de répondre à un besoin client concret en développant un jeu de Reversi/Othello en java sans interface graphique. Le projet impliquait d'analyser le cahier des charges, de concevoir une architecture adaptée, puis d'implémenter et de tester une partie de l'application.
Ce travail mobilise directement les trois apprentissages critiques de la compétence Réaliser : de la conception initiale jusqu'à la vérification du bon fonctionnement du jeu en regard des spécifications.
Preuves
▸ Preuves « Ressources »
Introduction au développement
Exercices d'algorithmique et premiers programmes Java illustrant l'implémentation de conceptions simples.
→ Voir les TPsDéveloppement d'interfaces Web
TP HTML/CSS montrant la conception et l'implémentation de maquettes en réponse à un cahier des charges en une heure.
→ Voir l'évaluationIntroduction aux bases de données
Modélisation et requêtes SQL réalisées lors des séances de TP, validant la capacité à élaborer une conception simple.
→ Voir le dernier TP▸ Preuves « SAE »
Code source de l'application
Le projet du développement du jeu Othello/Reversi en Java
→ Voir la SAEAnalyse & Réflexivité
Qu'est-ce que j'ai appris en réalisant cette SAE ?
La SAE 1.01 m'a permis de comprendre concrètement l'écart qui existe entre concevoir une solution sur le papier et l'implémenter. J'ai découvert que la phase de conception (AC11.02) est déterminante : une architecture mal pensée déboucheà coup sûr sur du code difficile à écrire et modifier.
Sur le plan technique, j'ai renforcé ma maîtrise du langage Java, notamment les structures de données (tableaux à deux dimensions), les fonctions et la gestion d'un dépôt git en collaboration. J'ai aussi appris à lire et interpréter un cahier des charges, ce qui est fondamental pour répondre correctement au besoin client.
Enfin, j'ai pris conscience de l'importance des tests (AC11.03) : sans une démarche de vérification rigoureuse, il est impossible de savoir si le produit livré satisfait la demande.
Quelles difficultés ai-je rencontrées et comment les ai-je surmontées ?
La principale difficulté a été de décomposer le problème en sous-problèmes biens découpés et facilement résolvables. Face au cahier des charges initial, j'ai eu tendance à vouloir tout coder d'un coup, ce qui a rapidement conduit à des erreurs en cascade difficiles à déboguer et l'incompréhension de mon coéquipier.
J'ai surmonté cet obstacle en adoptant une approche incrémentale : tester chaque fonction indépendamment avant de les assembler. Cela correspond directement à l'AC11.03,faire des essais unitaires à chaque étape, plutôt qu'en toute fin de projet.
J'ai également eu du mal à estimer le temps nécessaire entre chaque tâche. Cette expérience m'a appris à mieux planifier en réservant du temps pour les problèmes et les tests, qui sont souvent sous-estimés.
Comment ce travail valide-t-il les apprentissages critiques de la compétence Réaliser ?
AC11.01 : Implémenter des conceptions simples : le code source livré démontre ma capacité à traduire une spécification en programme fonctionnel. Les choix d'implémentation (algorithmes, structures) sont documentés.
AC11.02 : Élaborer des conceptions simples : l'ordonancement des méthodes effectués en début de projet attestent d'une phase de conception menée avant tout codage. J'ai su identifier quels actions développer avant les autres et proposer une architecture adaptée.
AC11.03 – Faire des essais et évaluer leurs résultats : le code comprend quelques méthodes de tests sur les fonctions les plus délicate et montrent le bon fonctionnement de celles ci.
Que ferais-je différemment si je recommençais ?
Je consacrerais davantage de temps à la phase de conception avant d'écrire la première ligne de code. La tentation de "coder directement" est forte mais inefficace : un schéma clair en amont évite une grande partie des erreurs.
J'écrirais également mes tests en parallèle du code, voire avant, plutôt qu'en fin de projet. Cela m'aurait permis de détecter des bugs bien plus tôt et de gagner pas mal de temps précieux lors de la phase de débogage.