Pourquoi est-il mauvais d'écrire quelque chose dans la langue X comme si vous écriviez un programme dans la langue Y en termes d'utilisation d'un paradigme de codage partagé [fermé]

Il y a quelque temps, j'ai posé une question sur SO à propos de quelque chose écrit en C ++, mais au lieu d'obtenir une réponse au problème, les commentaires sont devenus complètement fous sur mon style de codage, même lorsque j'ai indiqué qu'il s'agissait d'un morceau de code WIP et que je voulais le nettoyer plus tard quand j'avais le cas de base en cours d'exécution. (J'ai eu tellement de votes négatifs que j'ai décidé de retirer la question, car mon représentant sur SO est déjà presque abyssal)

Cela m'a fait me demander pourquoi les gens adoptent une attitude aussi dure "tu es un noob, va te faire foutre". J'étais accusé d'écrire du C ++ comme s'il s'agissait de Java. Quelque chose que je ne peux pas comprendre et qui me déconcerte encore.

Je programme dans plusieurs langages POO depuis un certain nombre d'années maintenant, quoique par intervalles. Je choisis le langage à utiliser en termes de bibliothèques disponibles et d'environnements d'exécution optimaux pour le travail à accomplir. J'adopte des modèles de conception dans le code OOP et je suis assez confiant que mon utilisation des modèles est saine et que OO sage, je peux me débrouiller. Je comprends la boîte à outils OOP, mais choisissez d'utiliser les outils uniquement lorsque je pense que cela est vraiment nécessaire, pas simplement d'utiliser une astuce pour montrer mes esprits de codage. (Ce que je sais ne sont pas de premier ordre, mais je pense qu'ils ne sont pas au niveau n00b non plus).

Je conçois mon code avant d'écrire une seule ligne. Pour définir des tests, j'énumère les objectifs d'une certaine classe et les critères de test auxquels elle doit adhérer. Parce qu'il m'est plus facile de créer des diagrammes de séquence puis d'écrire du code, j'ai choisi d'écrire mes tests après que l'interface soit devenue évidente.

Je dois admettre que dans le morceau de code que j'ai publié dans la question, j'utilisais toujours des pointeurs, au lieu d'utiliser des pointeurs intelligents. J'utilise RAII chaque fois que je le peux. Je sais que RAII signifie une protection contre les pointeurs nuls, mais je travaille progressivement. C'était un travail en cours et je voulais le nettoyer plus tard. Cette façon de travailler a été fermement condamnée.

À mon avis, je devrais d'abord avoir un exemple de travail afin que je puisse voir si le scénario de base est une façon de penser viable. Il m'arrive aussi de penser que le nettoyage du code est quelque chose qui est typique de la phase de refactoring de l'agile, après que le cas de base a été prouvé. Je dois admettre que même si j'obtiens lentement la norme Cxx, je préfère utiliser ce que je comprends, au lieu de prendre le risque d'utiliser des concepts que je n'ai pas encore maîtrisés dans le code de production. J'essaie de nouvelles choses de temps en temps, mais généralement dans des projets de jeu que j'ai à côté, juste à cet effet.

[modifier] Je voudrais préciser que la suggestion de moucheron [1] ne s'est pas présentée dans la recherche que j'ai faite avant de commencer à poser ma question. Cependant, bien que sa suggestion couvre un aspect de la question, la question à laquelle il est lié ne répond pas au cœur de ma question, mais seulement à une partie. Ma question concerne davantage la réponse que j'ai reçue à mon style de codage et les aspects professionnels de la gestion des différents styles de codage et des niveaux (apparents) de compétence. Avec ma question précédente sur SO et sa réponse à titre d'exemple. [/modifier]

La question est alors: pourquoi se moquer de quelqu'un qui n'utilise pas votre style de codage?

Les questions / subdivisions à ma portée sont:

• Pourquoi serait-ce une mauvaise pratique de programmation d'utiliser plus de code sujet aux erreurs dans des situations de prototype, si le refactoring le rend plus robuste par la suite?
• Comment un programme écrit en C ++ pourrait-il être comme il a été écrit en Java? Qu'est-ce qui en fait un mauvais programme (étant donné que j'ai indiqué l'intention du style actuel et le travail prévu pour s'améliorer?)
• Comment serais-je un mauvais professionnel si je choisissais d'utiliser une construction utilisée dans un certain paradigme de programmation (par exemple OOP / DP)?

[1] Développer rapidement et boguer, puis corriger les erreurs ou être lent, attention à chaque ligne de code?

Sans voir le code en question, il existe plusieurs façons d'écrire du code Java en C ++, certaines pires que d'autres.

1. À l'extrême, vous disposez de votre source comme Java: tout dans un seul fichier, tout dans la définition de classe, etc.:

   class HelloWorldApp {
   public:
       void main() {
           cout << "Hello World!" << endl;
       }
   };

   C'est ainsi que la source Java serait présentée. C'est techniquement légal en C ++, mais tout mettre dans le fichier d'en-tête et tout en ligne (en le définissant dans la déclaration de classe) est un style terrible et tuera vos performances de compilation. Ne le fais pas.
2. Excessivement OO - Pour simplifier à l'extrême, à Java, c'est le Royaume des Noms , où tout est un objet. Un bon code C ++ (c'est-à-dire idiomatique) est plus susceptible d'utiliser des fonctions gratuites, des modèles, etc., au lieu d'essayer de tout entasser dans un objet.
3. Non RAII - Vous l'avez déjà mentionné - en utilisant des pointeurs et un nettoyage manuel au lieu de pointeurs intelligents. C ++ vous donne des outils comme RAII et des pointeurs intelligents, donc un bon code C ++ (c'est-à-dire idiomatique) utilise ces outils.
4. Pas de C ++ avancé - Les bases de Java et C ++ sont assez similaires, mais une fois que vous entrez dans des fonctionnalités plus avancées (modèles, bibliothèque d'algorithmes de C ++, etc.), elles commencent à diverger.

À l'exception de # 1, aucun de ceux-ci ne fait d'un programme C ++ un mauvais programme, mais ce n'est pas non plus le type de code sur lequel je préfère travailler en tant que programmeur C ++. (Je n'apprécierais pas non plus de travailler avec Perl non idiomatique ou de style C, Python non idiomatique, etc.) Un langage a ses propres outils et idiomes et philosophie, et un bon code utilise ces outils et idiomes au lieu d'essayer d'utiliser le plus petit dénominateur commun ou essayer de reproduire l'approche d'une autre langue. L'écriture de code non idiomatique dans une langue / un domaine de problème particulier / ce qui ne fait pas de quelqu'un un mauvais programmeur, cela signifie simplement qu'il a plus à apprendre sur cette langue / ce domaine de problème / quoi que ce soit. Et il n'y a rien de mal à cela; il y a une très longue liste de choses que j'ai plus à apprendre, et le C ++ en particulier a une tonne de choses à apprendre.

Concernant la question particulière de l'écriture de code sujet aux erreurs avec l'intention de le nettoyer plus tard, ce n'est pas noir et blanc:

• Si un code prototype ne parvient pas à gérer toutes les exceptions possibles et tous les cas d'angle possibles, alors c'est à prévoir. Faites-le fonctionner, puis faites-le fonctionner de manière robuste. Aucun problème.
• Si un code prototype est écrit dans ce qui est simplement un mauvais style ou une mauvaise conception (mauvais pour le langage donné et ses idiomes, une conception fondamentalement mauvaise pour le problème, etc.), alors à moins que vous ne l'écriviez comme un jetable preuve de concept, vous ne gagnez rien.

Pour utiliser des pointeurs bruts contre des pointeurs intelligents à titre d'exemple, si vous allez travailler en C ++, l'utilisation de RAII et de pointeurs intelligents est suffisamment fondamentale pour qu'il soit plus rapide d'écrire du code de cette façon que de revenir en arrière et de le nettoyer plus tard. Encore une fois, ne pas le faire ne signifie pas que quelqu'un est un mauvais programmeur, non professionnel, etc., mais cela signifie qu'il y a plus à apprendre.

Chaque langage de programmation possède un ensemble d'expressions idiomatiques et de bonnes pratiques, qui conduisent généralement à un code élégant, correct et performant. Voici quelques pires pratiques qui conviennent parfaitement dans une autre langue:

• Je crierai si vous écrivez for ($i = 0; $i < 42; $i++) { … }en Perl, mais pas en PHP
  (en Perl, les variables doivent être déclarées, et ces boucles doivent itérer sur une plage)
• Je pleurerai si vous écrivez new Foo()en C ++ sans raison valable, mais pas en Java
  (C ++ n'a pas de ramasse-miettes, donc RAII doit être utilisé. Noobs fuira la mémoire sinon)
• Je grincerai des dents si vous déclarez toutes vos variables en haut de votre fonction, sauf en C89, Pascal ou JavaScript.
• Je vais faire facepalm si vous mettez toutes vos fonctions dans une classe en Python, mais pas en Java
  (Python est un langage multi-paradigme forçant à la place "OOP" et supporte les fonctions au niveau supérieur)
• Je vais pleurer si vous êtes return nullen Scala, mais pas dans un langage de type C
  (car Scala a un Optiontype)
• Je me plaindrai si vous écrivez un algorithme récursif en Java, mais pas en OCaml
  (car la pile de Java déborde rapidement, alors qu'OCaml a une optimisation des appels de queue)
• …

Il est facile d'utiliser une nouvelle langue comme si c'était quelque chose que vous connaissez, et avec de la chance, cela fonctionnera même. "Vous pouvez écrire Fortran dans n'importe quelle langue". Mais vous ne voulez vraiment pas ignorer les fonctionnalités spécifiques du langage X, car il est fort probable que X offre un certain avantage sur U.

« Je choisis le langage à utiliser en termes de bibliothèques disponibles et d'environnements d'exécution optimaux pour le travail en cours » - mais le fait que ce langage X soit réellement meilleur que le langage U pour le travail en cours dépend également de sa familiarité avec ce langage, ou combien de temps il faudra pour se familiariser suffisamment afin de bien l'utiliser. Vous ne donneriez pas une tronçonneuse lourde simplement parce qu'elle coupe le bois plus rapidement, alors que vous voulez réellement votre ancien couteau à stylo parce qu'il tient parfaitement dans votre main. À moins que vous ne vouliez réellement abattre un arbre.

Mais votre question concerne davantage un problème culturel : apprendre toutes les meilleures pratiques prend beaucoup de temps et les débutants posent le plus de questions, tandis que les gourous y répondent. Mais ce qui est évident pour un gourou n'est pas évident pour un débutant, et les gourous l'oublient parfois. En tant que débutant, la solution n'est pas de cesser de poser des questions. Cependant, on peut montrer une ouverture pour apprendre et appliquer les meilleures pratiques, par exemple en essayant de nettoyer votre code autant que possible avant de le montrer aux autres. La plupart des langues ont quelques bonnes pratiques de base qui sont faciles à apprendre, même lorsque toute la courbe d'apprentissage est en fait très longue.

Un problème commun est que les personnes novices en programmation ignorent toute indentation ou autre formatage, puis sont confuses car leur programme ne fonctionne pas. Je serais également confus, et la première étape pour comprendre un programme est de s'assurer qu'il est parfaitement mis en page. Ensuite, de simples erreurs comme une citation de fermeture ou une virgule manquante deviennent soudain évidentes. J'espère que vous pratiquez déjà un bon formatage, et ici c'est une métaphore pour d'autres bonnes pratiques: les meilleures pratiques empêchent les erreurs, les meilleures pratiques facilitent la recherche d'erreurs, l'application des meilleures pratiques vient avant de trouver le problème .

Il est trop bon marché de dire «je le réparerai plus tard», alors que le corriger maintenant aurait résolu votre problème (aussi, cette fameuse «phase de nettoyage» pourrait ne jamais arriver, donc la seule option responsable est de le faire correctement le première fois). À tout le moins, essayer de rendre votre code aussi bon que possible avant de demander de l'aide aux autres leur permet de raisonner plus facilement sur votre code, tout comme la chose polie à faire.

Je ne suis pas un développeur hardcore C ++, mais ...

Pourquoi serait-ce une mauvaise pratique de programmation d'utiliser plus de code sujet aux erreurs dans des situations de prototype, si le refactoring le rend plus robuste par la suite?

Une chose à garder à l'esprit est qu'une erreur en C ++ signifie généralement "comportement indéfini". Dans une langue sûre, le pire qui puisse arriver est une exception mettant fin immédiatement à votre programme. En C ++, vous avez de la chance si vous obtenez une erreur de segmentation. Il est tout à fait possible que votre programme continue de faire quelque chose de subtilement erroné. Il pourrait également se comporter correctement pendant une période de temps et manifester des bogues beaucoup plus tard, ou il pourrait se comporter correctement tout le temps, mais finirait par manger toute votre mémoire.

Dans tous les cas, il suffit d'une seule erreur pour que l'exécution du programme déraille complètement et en territoire inconnu. Il est probable que pour le développeur C ++ à plein temps, le «cas de base» signifie «aucune possibilité de comportement indéfini ou de fuites de mémoire».

Comment un programme écrit en C ++ pourrait-il être comme il a été écrit en Java? Qu'est-ce qui en fait un mauvais programme?

Je ne pense pas qu'il y ait une réponse à cela qui ne soit pas largement spéculative et d'opinion. Si vous voulez mon avis, Java a tendance à avoir quelques antipatterns associés, comme le fait que tout doit être un objet. Où dans d' autres langues que vous souhaitez passer un pointeur, foncteur, ou la fonction, en Java , vous trouverez généralement des tonnes de vide de sens et de peu-utiles ThingDoers, FooFactorieset IFrobnicatorsqui sont des fonctions seulement déguisées.

De même, là où dans d'autres langues vous pourriez passer un simple tuple ou une structure sans nom, en Java pour regrouper même seulement 2 objets dans un simple conteneur de données, vous devez prédéfinir une classe NamedThing de 30+ lignes avec des setters, des getters et des Javadocs. Le manque relatif de fonctionnalités de Java oblige les programmeurs à effectuer des doubles backflips orientés objet pour faire avancer les choses parfois. Le code résultant est rarement idiomatique en dehors de Java.

Ensuite, il y a le fait qu'en C ++ vous avez besoin d'un graphe d'objet très simplifié pour gérer la mémoire manuellement; généralement, un objet appartient à exactement un autre objet. En Java, vous n'avez pas besoin de suivre des contraintes aussi strictes, car le garbage collector s'assure que les choses seront nettoyées lorsqu'il n'y aura plus de références à elles. Il y a donc certainement un risque de gestion incorrecte de la mémoire si vous translittérez simplement le code de Java vers C ++.

Enfin, ce pourrait être de l'élitisme. Je ne prétendrai pas qu'ils constituent la majorité, mais j'ai certainement vu un sentiment de "Je n'ai pas besoin d'un langage qui me tiendra la main et m'empêchera de faire des choses stupides" chez certains développeurs C ++. Dans leur esprit, le C ++ est un "vrai" langage et si vous ne pouvez pas gérer ses particularités, vous n'êtes pas un "vrai programmeur".

Réponse légèrement hors sujet ...

Ne vous inquiétez pas - c'est un "comportement" courant dans toute communauté d'experts. Et soyez honnête, si vous êtes bon dans n'importe quelle langue, et que vous rencontrerez un code qui est "étrange", vous le critiquerez probablement aussi. (parce que, voulez TEACH).

Je suis dans le monde perl - quand verra quelque chose comme:

$imax=$#array;
$str=""
for($i=0; $i<$imax; $i++) {
    $str = "$str" . $array[$i];
}

au lieu de:

my $str = join '', @array;

va certainement le commenter - (lire: enseigner à l'auteur) sur la joinfonction.

Quoi qu'il en soit, trop de critiques sont contre-productives du tout, et l'un des meilleurs exemples est le suivant: (extrait de: http://perl-begin.org/humour/#How_can_I_switch_off_the_T.V..3F )

(Ce bit a été posté anonymement sur un pastebot le 23 mars 2011. Il est placé ici pour la postérité après quelques modifications.) - légèrement modifié aussi

Question: comment puis-je allumer mon téléviseur?

Qu'est-ce que le PO veut entendre?

Par exemple: Localisez le bouton marche / arrêt de la télécommande de votre téléviseur et appuyez dessus. Le bouton est généralement rouge et situé sur la ligne supérieure de la télécommande.

La réponse de l'expert #perl: D'abord, que voulez-vous dire par "allumer"? Définissez-le d'abord. Ne collez pas non plus votre téléviseur, votre télécommande TV et le salon.

... après un nopaste:

Votre chambre est moche. Et la télé a l'air terrible. Utilisez Mr. Clean sur l'écran et nettoyez d'abord votre salon. Utilisez trois vadrouilles de nettoyage au lieu de deux. Utilisez HDMI et n'utilisez jamais de connecteurs péritel (?), Sauf si vous en avez vraiment envie. Votre télécommande du téléviseur possède des boutons illisibles, nettoyez d'abord. Vous êtes débutant, alors lisez:

http://experts.blog/how_to_design_a_future_3D_TV.html http://experts.blog/the_basics_of_tv_repairing.html http://experts.blog/viruses_in_living_room_short_essay.html http://experts.blog/global_chip_replacement_guide.html

Invité IRC: Mais, je ne veux pas être un expert en télévision.

Réponse: Pourquoi voulez-vous allumer le téléviseur alors?!

Pourquoi serait-ce une mauvaise pratique de programmation d'utiliser plus de code sujet aux erreurs dans des situations de prototype, si le refactoring le rend plus robuste par la suite?

Lorsque vous écrivez rapidement et sale avec l'esprit de réparer plus tard, il y a le danger d'oublier quelque chose que vous devez réparer.

Comment un programme écrit en C ++ pourrait-il être comme il a été écrit en Java? Qu'est-ce qui en fait un mauvais programme (étant donné que j'ai indiqué l'intention du style actuel et le travail prévu pour s'améliorer?)

En java, vous n'avez pas à penser à qui possède un certain objet, il vous suffit de transmettre la référence et de l'oublier comme si ce n'était rien. Cependant, en C ++, il doit y avoir une définition claire de qui est propriétaire de l'objet et qui est responsable du nettoyage.

Comment serais-je un mauvais professionnel si je choisissais d'utiliser une construction utilisée dans un certain paradigme de programmation (par exemple OOP / DP)

Vous ne le feriez pas; Le C ++ est un langage multi-paradigmes, il se trouve qu'il supporte plutôt bien la POO mais il peut aussi faire beaucoup d'autres choses. Cependant, la plus grande partie se résume à utiliser l'outil approprié pour le travail au lieu de retirer le marteau à chaque fois que vous devez enfoncer une pointe pointue dans du bois.

La raison pour laquelle vous avez obtenu une mauvaise réponse est que la plupart des personnes SO ont tendance à juger les compétences en fonction de l'idiotie que vous pouvez coder dans la langue que vous demandez. Les personnes familiarisées avec le C ++ ont tendance à s'agiter quand elles voient un mauvais code qui ressemble à quelque chose qui les a mordues dans le passé.