Un développeur junior ayant logiquement moins de pratique qu’un développeur freelance expérimenté, il sera plus sujet aux erreurs. Et, comme nous le verrons, ces erreurs ne sont pas uniquement techniques ; elles touchent à tous les domaines qui gravitent autour du développement.
Heureusement, un développeur débutant qui prend conscience de ses faiblesses sera plus à même de les combler, et ainsi progresser plus vite que ses pairs !
Vous êtes développeur junior et voulez éviter de commettre les erreurs classiques dues à votre manque d’expérience ? Nous avons sélectionné pour vous les 7 points faibles sur lesquels travailler !
Ne pas prendre assez de recul
Lorsque l’on développe, peu importe le projet ou la techno, il est important d’avoir une vue d’ensemble du produit avant de commencer à écrire du code.
C’est une erreur que font souvent les débutants : foncer tête baissée, sans penser à ce que le produit final doit être avant de se plonger dans la technique.
Ce qu’ils feront fonctionnera probablement, mais ne sera pas optimal. En ayant une vision d’ensemble, on est capable de rendre le code plus générique, réutilisable, plus facile à maintenir. Bien réfléchir à son développement avant de s’y mettre permet aussi d’avoir un découpage technique plus fin, pour au final une vélocité de développement accrue.
L’exemple typique serait la création de composants, avec un framework front-end, utilisés à plusieurs endroits de l’application. Le développeur expérimenté n’en créera qu’un seul, appelé où il faut, avec les bons paramètres. Alors que le junior aura tendance à écrire le même code partout là où il en a besoin, sans le rendre générique. Cela amène souvent à des répétitions inutiles, et donc à code plus difficile à faire évoluer.
Ce qui mènera, au final, à beaucoup de travail de refactorisation, pour avoir quelque chose de propre.
Il est donc important, avant de commencer à coder une fonctionnalité, de prendre du recul sur l’utilisation de celle-ci.
Ne pas prendre soin de la qualité du code
Dans la même veine que le conseil précédent : les développeurs débutants ont tendance à sous-estimer l’importance de la qualité du code.
Souvent parce qu’ils ne savent pas faire, parfois parce qu’ils n’en voient pas l’utilité. Mais un code propre est essentiel pour sa maintenabilité dans le temps.
Voici quelques conseils :
- Ne pas répéter du code à plusieurs endroits ;
- Bien découper le code en dossiers et fichiers, classes et méthodes, en fonction du but des morceaux de code ;
- Ne pas mélanger les vues et le code métier ;
- Éviter les méthodes et blocs (conditions, boucles, etc.) trop longs ;
- Ne pas nommer les variables et constantes sans réflexion (le nom de celles-ci doit être clair).
Ces conseils sont encore plus importants lors de travail en équipe ! Et pour essayer de corriger cela, il est important de lire et étudier du code écrit par des programmeurs plus expérimentés, mais aussi de faire relire le sien par des collègues séniors.
Ne pas assez utiliser Google
Et si je vous disais que les développeurs séniors utilisent plus Google que les juniors ?
Contrairement aux débutants, les programmeurs expérimentés savent qu’il est contre-productif de rester bloqué des heures sur le même problème. Une recherche sur Google est souvent une précieuse aide pour résoudre le problème en question.
En effet, si vous faites face à un bug, ou n’arrivez pas à trouver comment coder telle ou telle fonctionnalité générique, il y a de fortes chances qu’un développeur ait déjà eu à faire à cette problématique.
Il y a cependant quelques éléments à prendre en compte pour effectuer ces recherches correctement :
- Il faut rechercher intelligemment : choisir les bons termes à taper ;
- Choisir les bons liens sur lesquels cliquer : Stackoverflow évidemment, mais regarder la date de publication est également intelligent ;
- Il faut réussir à adapter le code trouvé au sien (un simple copier-coller fonctionne rarement !).
Ne pas se poser assez de questions
Les développeurs juniors ont tendance à ne pas se poser assez de questions. Pour reprendre l’exemple précédent : il leur arrive souvent de faire des simples copier-coller de code trouvé sur Stackoverflow ou sur le net, sans le modifier. Du code ainsi récupéré n’a que peu de chances de fonctionner dans son nouvel environnement.
Il est donc important, et ce avant toute action, de se poser les bonnes questions.
Pourquoi ce code est susceptible de corriger mon problème ? Comment fonctionne t-il ? Comment dois-je le modifier pour l’appliquer à mon projet ? Etc.
C’est également le cas lorsque l’on doit coder de nouvelles fonctionnalités. Il est important de se demander quelles interactions va avoir le nouveau code avec l’existant, comment l’implémenter de la meilleure des façons, etc.
Bref : le travail de développeur, c’est sans cesse se poser des (bonnes) questions !
Ne pas penser à l’expérience utilisateur
S’il n’est pas assez accompagné sur l’implémentation de l’UX/UI, il sera difficile pour le programmeur junior de faire quelque chose de user-friendly.
le manque d’expérience fait qu’il est difficile de penser à tout ce que pourrait faire un utilisateur, d’autant plus qu’il y a beaucoup de profils différents. Mais ces cas doivent être gérés, pour que l’interface s’adapte en fonction du comportement spécifique de l’internaute, et ainsi améliorer son expérience.
Par exemple, si l’utilisateur oublie de remplir un champ dans un formulaire : l’interface doit le lui dire. Si l’envoi d’un formulaire demande un certain temps de traitement, il faut que l’utilisateur le sache (avec une image de chargement par exemple). Or, ce sont des oublis fréquents lorsque l’on débute.
Cela nuit rarement au fonctionnel du projet ; il fonctionnera. Mais cela nuit à l’expérience de l’utilisateur, et un utilisateur qui n’est pas satisfait aura tendance à ne pas utiliser le produit de nouveau.
Pour corriger cette erreur, il faut non seulement faire tester votre produit à de vrais futurs utilisateurs, mais aussi pensez, vous, en amont, aux divers comportement qu’ils pourraient avoir !
Ne pas utiliser d’outil d’aide à la programmation
Pour aider le développeur junior à s’améliorer dans la plupart des points précédents, il existe des outils.
Ces outils ont été créés dans le but de guider les développeurs (pas uniquement débutants), dans la création de code plus propre, plus beau, et plus maintenable dans le temps.
C’est notamment les cas des linter, souvent intégrés ou installables sur les IDE (Integrated Development Environment), tels que Visual Studio Code, Eclipse ou Sublime Text.
Nous avons d’ailleurs dédié un article à l’utilisation d’ESLint, linter JavaScript permettant d’avoir des avertissements si notre code ne suit pas certaines recommandations (personnalisables). Et si vous voulez plus d’informations techniques concernant cet outil, dirigez-vous vers la documentation officielle.
Ne pas accepter la critique
Enfin, la dernière erreur que nous allons citer ici, que font souvent les développeurs débutants, c’est de ne pas savoir accepter la critique.
C’est compréhensible, car apprendre à coder est suffisamment dur comme ça, pour qu’un développeur vienne critiquer notre travail derrière…
Mais c’est pour votre bien !
La marge de progression d’un débutant est élevée, surtout au tout début de sa carrière, aussi, il est important de demander des retours sur son programme, faire de la revue de code, et de les accepter. Ils sont souvent donnés avec bienveillance, et même s’ils peuvent remettre en question une grosse partie de votre travail, il faut les prendre en compte !
Conclusion
Nous l’avons vu tout au long de cet article : les développeurs débutants sont sujets à beaucoup d’erreurs, qui, heureusement, disparaissent avec le temps et l’expérience ! Nous aurions d’ailleurs pu en citer d’autres, mais ces 7 là sont les principales, celles qu’il faut essayer de corriger dès les débuts, pour pouvoir évoluer en partant sur de bonne bases.
