10 mèmes qui capturent parfaitement la frustration du codage

Le codage peut parfois être fascinant et épanouissant, mais qu’il s’agisse d’amateurs inexpérimentés ou de professionnels ayant des années d’expérience à leur actif, chaque programmeur sait à quel point cela peut parfois être frustrant. Bien qu’il existe plus de ressources que jamais pour aider les utilisateurs à coder, cela ne signifie pas que ce n’est pas toujours une tâche remplie de moments douloureux.

De la maladresse des différents langages de programmation à la menace omniprésente de bogues et d’erreurs, de nombreux codeurs ont trouvé que le meilleur moyen de faire face aux frustrations uniques de celui-ci est de créer et de partager des mèmes hilarants. Ce sont quelques-uns de leurs meilleurs exemples.

La douleur d’être un codeur inexpérimenté

Principalement après les réunions de ProgrammerHumor

Peu de mondes sont aussi remplis de jargon technique et de termes cryptés que la programmation, où tout le monde peut parfois sembler parler des langues différentes, et cela peut être ennuyeux pour les codeurs moins expérimentés. Peu importe le nombre de cours et de tutoriels suivis par un débutant, il est inévitable qu’il rencontre des choses qu’il ne comprend pas de temps en temps.

Bien que ce mème concerne principalement les jeunes professionnels, il s’applique tout autant aux amateurs qui tentent d’entrer dans la communauté de la programmation. Malheureusement, il n’y a aucun moyen d’éviter de se sentir exclu ou ignorant de temps en temps.

Il n’y a rien de pire que des tutoriels inutiles

L’une des meilleures parties de l’entrée dans le codage est de découvrir la quantité de ressources disponibles pour aider les débutants en codage, des forums utiles aux didacticiels YouTube. Malheureusement, le hic, c’est qu’il peut parfois être difficile de dire en un coup d’œil ce qui est utile et ce qui ne l’est tout simplement pas.

Même les didacticiels officiels tels que ceux pour apprendre Python peuvent être difficiles, manquant des étapes importantes qu’une personne novice en matière de codage pourrait ne pas encore comprendre. D’autre part, les didacticiels YouTube peuvent être incroyablement incohérents et le résultat est que parfois rien de ce que l’utilisateur en retire n’est vraiment utile.

Une seule ponctuation peut faire la différence

Bien que le codage puisse donner un incroyable sentiment de liberté, il peut aussi sembler étouffant et pédant à des moments où toute erreur peut causer un énorme problème. Différents langages de programmation ont tous leurs propres bizarreries, mais ce qu’ils ont surtout en commun, c’est que même la plus petite erreur peut casser un morceau de code.

En C++ par exemple, un point-virgule manquant peut être la cause d’une erreur, et, bien que cela signifie que tout utilisateur C++ devient rapidement très bon pour se souvenir de les mettre, il sera toujours difficile de repérer quand une erreur est si petite.

Quand le refactoring tourne mal

Même les meilleurs innovateurs technologiques savent que simplifier et améliorer un produit même s’il fonctionne déjà bien peut être crucial et c’est pourquoi le refactoring vaut toujours la peine d’être fait. En théorie, la refactorisation devrait signifier simplement améliorer le code sans réellement changer aucune des fonctionnalités, mais cela ne fonctionne pas toujours.

Il n’y a rien de plus frustrant que de casser complètement quelque chose qui fonctionnait déjà bien dans le but de le faire fonctionner plus efficacement, mais cela peut parfois être la réalité. Ainsi commence le douloureux processus de résolution des nouvelles erreurs. Ce n’est peut-être pas un problème majeur, mais cela ne veut pas dire que ce n’est pas parfois ennuyeux.

CSS peut être l’un des langages les plus capricieux

Ce n’est pas seulement la refactorisation qui peut faire apparaître de nouveaux problèmes dans quelque chose qui fonctionnait parfaitement auparavant. Comme le savent tous ceux qui ont essayé l’un des langages de codage les moins agréables comme CSS, même les plus petits changements peuvent causer une multitude de problèmes nouveaux et souvent apparemment sans rapport.

Bien que les résultats puissent impliquer des logiciels hilarants, comme le montre ce mème, cela ne manque pas de douleur pour les programmeurs qui essaient de maintenir leur code en état de marche.

Les vieilles habitudes ont la vie dure lors du changement de langage de programmation

Que ce soit parce qu’un travail l’exige ou que le codeur veut simplement relever un nouveau défi, la plupart des programmeurs finissent par changer de langage à un moment ou à un autre. Bien qu’il puisse s’agir d’une transition en douceur, il existe souvent des bizarreries spécifiques à certaines langues qui deviennent plus apparentes lors du changement.

Par exemple, les langages plus anciens comme C/C++ et Java ont tellement habitué les codeurs à mettre compulsivement un point-virgule à la fin de chaque ligne qu’il est impossible d’abandonner cette habitude même après avoir changé pour une autre où ce n’est pas nécessaire.

Trop de variables peuvent être difficiles à gérer

Le codage peut parfois rendre l’utilisateur intelligent, en particulier lorsqu’il y a des gens qui ont connu un succès et une richesse incroyables grâce à la programmation, mais cela peut tout aussi bien les faire se sentir stupides. Par exemple, donner des noms pratiques aux variables et les utiliser immédiatement après devrait être incroyablement simple, mais même cela peut causer des problèmes.

Lorsque vous essayez de penser à plusieurs choses à la fois, la mémoire à court terme peut être la première chose qui sort de la fenêtre, ce qui signifie qu’il est étonnamment facile d’oublier une variable qui vient juste d’être créée. C’est encore un autre rappel que la principale cause de frustrations de codage est les lacunes du codeur.

Une étrange forme de progrès

Certaines erreurs peuvent être beaucoup plus déconcertantes et durables que d’autres, et le processus consistant à essayer de déterminer la cause et de trouver une solution peut être l’un des plus fastidieux du codage. Parfois, la solution à une erreur peut soudainement être la cause d’une autre erreur qui nécessite tout autant d’attention.

La partie hilarante est que cela peut encore être une cause de célébration pour les programmeurs. Une nouvelle erreur peut signifier un progrès vers une solution permanente et peut donner des indices importants sur la raison pour laquelle l’erreur d’origine a pu se produire en premier lieu, ce qui en fait une étape potentiellement précieuse.

La douleur de relire votre code plus tard

Bien que ce mème soit un exemple exagéré, il contient un élément de vérité. Le codage est presque toujours une expérience d’apprentissage, même pour les vétérans de la profession ou du passe-temps, et l’avantage de cela est le sentiment de s’améliorer lentement avec le temps.

Bien sûr, le revers de la médaille est que revenir à l’ancien code peut être une expérience difficile et révélatrice, car les anciennes erreurs et les mauvaises pratiques deviennent soudainement très apparentes. Il se peut également que l’ancien code ne semble pas avoir de sens du tout, mais fonctionne toujours d’une manière ou d’une autre, une expérience encore plus déconcertante.

Personne à blâmer sauf vous-même

Bien qu’il ne s’agisse évidemment pas d’un problème technique, peu de choses sur le codage peuvent causer plus de dommages émotionnels que la pensée qu’il est parfois impossible de rejeter la responsabilité d’un problème sur quelqu’un d’autre. Les ordinateurs peuvent avoir leurs propres problèmes, mais ils ne peuvent faire exactement que ce qu’on leur dit de faire.

Le code écrit en collaboration ou par quelqu’un d’autre est une tout autre affaire, mais lorsqu’il s’agit entièrement du travail de l’utilisateur, il n’y a aucun moyen d’éviter la réalité écrasante que ce sont ses propres erreurs qui causent les problèmes.