Un langage de programmation peut-il, par sa conception, imposer un «code propre»? [fermé]

Je suis donc en train de coder mes premiers projets en C ++ et il semble qu'il faut plus d'efforts pour rendre le code "propre", plutôt que de simplement travailler. C'est-à-dire qu'il semble que C ++ "permette" d'écrire du code laid mais fonctionnel.

Ce qui m'a fait réfléchir,

Un langage de programmation peut-il appliquer un code propre par conception? Existe-t-il déjà de telles langues?

De plus, comment cela est-il intégré comme principes de conception dans le développement / la théorie du langage de programmation? Quels types de mesures sont utilisés?

Le principal effet de la conception du langage sur le "code propre" se situe au niveau syntaxique. Les langages avec beaucoup de raccourcis et d'opérateurs obscurs (Perl / APL) se prêtent au code "sale", tandis que les langages avec un plus petit ensemble d'éléments (par exemple, Python) se prêtent à un code plus propre.

La sémantique, cependant, est un animal très différent. Il n'y a aucun moyen de faire en sorte que la sémantique d'une langue soit utilisée de manière propre, en particulier parce que vous ne pouvez pas, en tant que compilateur, savoir ce que l'utilisateur de la langue essaie d'accomplir. Un outil puissant est tout simplement cela - un outil puissant, pour le meilleur ou pour le pire.

Au final, la sémantique est plus importante que la syntaxe. C'est aussi la partie la plus difficile à comprendre en tant que développeur de maintenance (par exemple "qu'est-ce que ce code signifie réellement? Je vois ce qu'il fait ...").

Par conséquent, je dirais qu'il n'y a pas de conception pour appliquer du code propre, mais vous pouvez écrire une syntaxe simple avec une sémantique propre qui le rend plus facile. Pour le meilleur ou pour le pire, un code propre est avant tout une question de connaissances, de motivation, de discipline et de compétence des développeurs.

Les langages peuvent forcer ou encourager les programmeurs à corriger certaines classes de bogues, ce qui fait partie de la définition du code propre. Par exemple, différentes langues font un travail relativement décent pour aborder:

• Exceptions de pointeur nul.
• Bogues d'état partagés.
• Problèmes de concurrence.
• Exceptions non vérifiées.

Cela ne vous permet cependant que de progresser, car un code propre concerne principalement la communication interhumaine . Les langages de programmation n'ont vraiment qu'un seul levier pour aider à cela, et c'est leur pouvoir expressif . C'est un terme vraiment difficile à définir, mais il est plus facile pour les bons programmeurs d'écrire du code plus propre dans des langages plus expressifs. Ils ont plus d'outils disponibles pour exprimer facilement un algorithme en termes qui communiquent bien avec les autres humains. Ne vous méprenez pas, vous pouvez écrire du code propre dans ( presque ) n'importe quel langage de programmation. Ce sont juste quelques langues qui facilitent la tâche et ont un meilleur résultat relatif.

Cependant, vous ne pouvez pas simplement composer l'expressivité et comme par magie, les gens commenceront à écrire un meilleur code. Avec la plupart des programmeurs, vous leur donnez plus de boutons à tourner dans leur langue, et ils ne sauront pas comment les utiliser correctement, donc leur code finit par être pire. Il faut de la discipline et un bon mentorat pour améliorer la qualité de votre code. Il n'y a pas de balles d'argent.

Dans une certaine mesure. De nombreux langages sont délibérément conçus pour encourager certaines formes de code propre selon les idéaux des concepteurs de langage. Il est certainement possible d'écrire du code laid et incompréhensible dans n'importe quelle langue, mais certaines langues font plus d'efforts pour le décourager.

Par exemple, Python vous oblige à indenter des blocs en fonction de la structure sémantique du langage, tandis que de nombreux autres langages vous permettent d'indenter totalement au hasard ou pas du tout. Ceci est un exemple de langage encourageant activement un certain idéal de propreté.

Si vous pouvez le quantifier, vous pouvez créer un langage qui peut l'optimiser.

Bien que je ne connaisse aucun langage particulier qui applique réellement une politique de «code propre», les flics de style qui s'exécutent sur la génération sont assez courants.

La principale raison pour laquelle il s'agit d'une étape distincte de l'intégration dans la langue est largement fonction des priorités. Il est dans l'intérêt d'un langage de programmation de laisser le plus de flexibilité aux programmeurs pour obtenir le plus haut niveau d'adoption. Il y a tellement de langages de programmation et de DSL différents qui restreignant artificiellement la base d'utilisateurs en étant pointilleux et d'opinion sur les entrées autorisées entraveraient probablement une adoption plus large.

Par exemple, il n'est pas dans le meilleur intérêt de C # de forcer les gens à écrire

if (condition)
{

au lieu de

if (condition) {

Mais les vérificateurs de style peuvent être considérés comme difficiles, car c'est pour cela qu'ils sont conçus.

Donc, pour répondre à la question

Peut un langage de programmation appliquer le code propre à la conception?

_{mettre l'accent}

Absolument, tant que vous fournissez une définition précise de ce que signifie "code propre".

Par exemple, je pourrais définir «code propre» pour signifier:

• longueur de ligne ne dépassant pas 80 caractères
• fonctions composées de 100 lignes maximum
• l'indentation doit être de deux espaces
• les accolades ouvertes doivent suivre à la fin de la ligne précédée d'exactement un espace
• pas plus de deux opérateurs par ligne

et vous pourriez être en désaccord avec certaines ou toutes ces conventions, mais au bout du compte, elles sont quantifiables et peuvent être appliquées par programme.

Non, pas dans le sens que vous décrivez. La détection de la "laideur" ne peut pas se faire automatiquement!

Cependant, les concepteurs de langage peuvent faire des choses pour encourager un bon code (je ne veux pas dire «propre» car parfois le bon code sûr est aussi long et «moche»). Par exemple, les concepteurs du langage Rust ont examiné les choses que les programmeurs C ++ disciplinés ont tendance à faire (comme donner aux valeurs allouées en tas un seul "propriétaire"), et ont rendu plus facile de faire certaines de ces choses. Cela comprend la fourniture d'un vérificateur de type que vous pouvez utiliser pour vérifier que vous n'avez pas commis certaines erreurs courantes.

Je dirais qu'une bonne conception de langage est souvent réactive: les concepteurs regardent ce que font les bons programmeurs et essaient de rendre cela plus facile et "plus joli".