Devrait coder être court / concis? [fermé]

https://stackoverflow.com/questions/952194

math
proof

11-09-2019
|

Question

Lors de l'écriture d'une preuve mathématique, un objectif est de continuer à compresser la preuve. La preuve devient plus élégante, mais pas nécessairement plus facile à lire. La compression se traduit par une meilleure compréhension, comme vous éliminer les caractères inutiles et verbosité.

J'entends les développeurs disent que vous devriez souvent faire votre empreinte de code le plus petit possible. Cela peut très rapidement obtenir le code illisible. En mathématiques, il n'est pas une telle question puisque l'exercice est purement académique. Cependant, dans le code de production où le temps est de l'argent, avoir des gens essaient de comprendre ce que un code très concis fait ne semble pas avoir beaucoup de sens. Pour un peu de code plus bavard, vous obtenez la lisibilité et l'épargne.

À quel moment voulez-vous arrêter la compression du code logiciel?

La solution

J'essaie d'atteindre un niveau de verbosité où mes déclarations de programme se lisent comme une phrase tout programmeur pouvait comprendre. Cela ne signifie pas fortement refactorisation mon code tel qu'il est tous les petits morceaux d'une histoire, de sorte que chaque action serait décrite dans une méthode distincte (un peut être à une autre classe niveau encore plus loin).

sens que je ne réduiraient pas mon nombre de caractères juste parce qu'il peut être exprimé en moins. C'est ce que les concours de code golf sont pour.

Autres conseils

Ma règle est dire ce que vous entendez . Une façon commune que je vois des gens qui vont mal est « la réduction de la force. » En gros, ils remplacent le concept qu'ils pensent à quelque chose qui semble sauter les étapes. Malheureusement, ils quittent les concepts de leur code, ce qui rend plus difficile à lire.

Par exemple, le changement

for (int i = 0; i < n; i++)
    foo[i] = ...

int * p = foo, q = foo+n;
while ( *p++ = ... < q );

est un exemple d'une réduction de la force qui semble enregistrer les étapes, mais il laisse le fait que foo est un tableau, ce qui rend plus difficile à lire.

Un autre courant est l'utilisation bool au lieu d'un enum.

enum {
    MouseDown,
    MouseUp
};

Avoir ce soit

bool IsMouseDown;

laisse le fait que ce soit une machine d'état, ce qui rend le code plus difficile à maintenir.

Donc, ma règle serait, dans votre mise en œuvre, ne pas creuser à un niveau plus bas que les concepts que vous essayez d'exprimer.

Vous pouvez rendre le code plus petit en voyant la redondance et l'éliminer, ou en étant intelligent. Faites le premier et non celui-ci.

Voici un bon article de Steve McConnell - les meilleures pratiques http://www.stevemcconnell.com/ ieeesoftware / bp06.htm

Je pense à court / concis deux résultats à partir du code bien écrit. Il y a de nombreux aspects à faire un bon code et de résultats à partir du code bien écrit, réaliser les deux sont différents. Vous ne prévoyez pas pour une petite impression de pied, vous prévoyez une fonction qui est concise et fait une chose très bien - ce qui devrait conduire à une petite impression de pied (mais pas). Voici une courte liste de ce que je mettrais l'accent sur le moment où l'écriture de code:

simples fonctions ciblées - une fonction doit faire qu'une seule chose, une livraison simple, fonctions en vedette plusieurs sont buggy et pas facilement réutilisables
couplage lâche - ne pas tendre la main à l'intérieur d'une fonction de données globales et ne comptent pas beaucoup sur d'autres fonctions
dénomination précise - utiliser des noms significatifs variables précises, les noms cryptiques ne sont que
garder le code simple et non complexe - ne pas trop utiliser le langage wow techniques spécifiques de, bon pour impressionner les autres, difficile de comprendre facilement et maintenir - si vous ajoutez quelque chose de commentaire « spécial » si au moins les gens peuvent apprécier avant de vous maudire
commenter régulièrement - à de nombreux commentaires seront ignorés et pas à jour à peu ont pas de sens
Mise en forme - être fiers de la façon dont le code ressemble, le code correctement indenté aide
travail avec l'esprit d'une personne de maintenance du code - penser ce qu'il serait de maintenir le code que vous writting
ne peur ou paresseux pour factoriser - rien est parfait pour la première fois, nettoyer votre propre désordre

Une façon de trouver un équilibre est de chercher lisibilité et non-ness concise. Les programmeurs sont le code scannent en permanence visuellement pour voir ce qui est fait, et donc le code devrait autant que possible l'écoulement bien.

Si le programmeur scanne le code et frappe une section qui est difficile à comprendre, ou prend un certain effort pour analyser visuellement et comprendre, il est une mauvaise chose. En utilisant des constructions communes bien compris est important, rester à l'écart de la vague et peu utilisé, sauf si nécessaire.

Les humains ne sont pas compilateurs. Compilateurs peuvent manger les choses et continuer d'avancer sur. Code Obscure est pas mentalement consommé par les humains aussi rapidement que le code bien compris.

Parfois, il est très difficile de produire un code lisible dans un algorithme complexe, mais pour la plupart, la lisibilité humaine est ce que nous devons chercher, et non l'intelligence. Je ne pense pas que la longueur du code est vraiment une mesure de clarté non plus, parce que parfois une méthode plus détaillée est plus lisible qu'une méthode concise, et parfois une méthode concise est plus lisible qu'une longue.

En outre, les commentaires ne devraient compléter, et ne devraient pas décrire votre code, votre code devrait se décrire. Si vous avez des commentaires à une ligne, car il est pas évident ce qui est fait, ce qui est mauvais. Il prend plus de temps pour la plupart des programmeurs expérimentés pour lire une explication en anglais que d'en lire le code lui-même. Je pense que le code de livre marteaux complets celui de la maison.

En ce qui concerne les noms d'objets vont, la réflexion sur ce qui a connu une évolution avec l'introduction de nouveaux langages de programmation.

Si vous prenez les langues « accolade », en commençant par C, la brièveté a été considéré comme l'âme de l'esprit. Donc, vous auriez une variable pour tenir une valeur de prêt nommé « lv », par exemple. L'idée était que vous tapiez beaucoup de code, donc gardez les touches au minimum.

Ensuite est venu le Microsoft sanctionné « notation hongroise », où les premières lettres d'un nom de variable devaient indiquer son type sous-jacent. On pourrait utiliser « flv », ou quelque chose comme, pour indiquer que la valeur du prêt était représenté par une variable flottante.

Avec Java, puis C #, le paradigme est devenu l'un de clarté. Un bon nom pour une variable de valeur du prêt serait « loanValue ». Je crois qu'une partie de la raison est la fonction de commande terminée dans la plupart des éditeurs modernes. Depuis son pas nécessaire de saisir un nom entier plus, vous pourriez aussi bien utiliser autant de caractères que nécessaire pour être descriptif.

Ceci est une bonne tendance. Code doit être intelligible. Les commentaires sont souvent ajoutés après coup, le cas échéant. Ils sont également pas mis à jour sous forme de code est mis à jour, de sorte qu'ils se périmer. Descriptif, bien choisi , les noms de variables sont les premiers, le meilleur et le plus facile de faire savoir aux autres ce que vous codez au sujet.

J'ai eu un professeur de science informatique qui a déclaré: « En tant qu'ingénieurs, nous créons en permanence types de choses qui n'a jamais existé auparavant. Les noms que nous donnons les colleront, donc nous devons faire attention aux choses de nom de façon significative . "

Il doit y avoir un équilibre entre le code source courte douce et la performance. S'il est agréable source et court le plus vite, alors bon, mais pour le bien de belle source, il fonctionne comme un chien, puis mauvais.

Efforcez-vous d'factoriser jusqu'à ce que le code lui-même se lit bien. Vous découvrirez vos propres erreurs dans le processus, le code sera plus facile à grok pour le « gars à côté », et vous ne serez pas accablés par le maintien (et oublier plus tard de changer) dans les commentaires ce que vous êtes déjà exprimées code.

Quand cela échoue ... vous, laissez-moi un commentaire.

Et ne me dites pas « quoi » dans le commentaire (c'est ce que le code est pour), dites-moi « pourquoi ».

Par opposition à long / décousu? Bien sûr!

Mais il arrive au point où il est si court et si concis qu'il est difficile de comprendre, alors vous êtes allé trop loin.

Oui. Toujours.

DRY : Ne vous répétez. Cela vous donnera un code qui est à la fois concis et sécurisé. Écrit le même code plusieurs fois est une bonne façon de le rendre difficile à maintenir.

Maintenant, cela ne signifie pas que vous devez faire en fonction de tous les blocs de code à distance à la recherche aussi bien.

Une erreur très commune (horreur?), Par exemple, est le code factorisation faire presque la même chose, et pour gérer les différences entre les occurences en ajoutant un drapeau à l'API fonctionne. Cela peut sembler inocuous au début, mais génère un flux de code difficile à comprendre et bug sujets, et encore plus difficile à factoriser.

Si vous suivez les règles de refactoring communes (recherche sur les odeurs code) votre code deviendra de plus en plus concise comme effet secondaire le plus grand nombre d'odeurs de code sont sur la détection de redondance.

Par contre, si vous essayez de rendre le code aussi court que possible ne pas suivre les directives meaningfull, à un moment donné, vous devrez arrêter parce que vous ne pourrez pas voir plus comment réduire le code.

Imaginez si la première étape consiste à éliminer tous les espaces blancs inutiles ... après que le code étape dans la plupart des langages de programmation deviendra si difficile à lire, vous n'aurez pas beaucoup de chance de trouver une autre amélioration possible.

L'exemple ci-dessus est assez caricatural, mais pas si loin de ce que vous obtenez lorsque vous essayez d'optimiser la taille sans suivre aucune directive raisonnable.

Il n'y a pas la ligne exacte que l'on peut tirer de distinguer entre le code qui est bien pendue et le code qui est fleuri. Utilisez votre meilleur jugement. Demandez aux autres regardent votre code et voir comment ils peuvent facilement comprendre. Mais rappelez-vous, l'exactitude est l'objectif numéro 1.

La nécessité pour les petites empreintes de code est un retour des jours de langage assembleur et les premières langues de niveau peu élevé ... il y a de petites empreintes de code où ont un besoin réel et pressant. Ces jours-ci cependant, ce ne est pas tant d'une nécessité.

Cela dit, je déteste le code bavard. Là où je travaille, nous écrivons le code qui lit autant que possible comme une langue naturelle, sans grammaire supplémentaire ou des mots. Et nous n'abrégeons rien à moins que son abréviation très courante.

Company.get_by_name("ABC") 
makeHeaderTable()

est à peu près aussi laconique que nous allons.

En général, je fais des choses évidentes et faciles à travailler avec. Si la concision / essoufflement me sert à cette fin, d'autant mieux. Souvent, des réponses courtes sont les plus clairs, si la brièveté est un sous-produit évident.

Il y a un couple de points à mon esprit qui déterminent quand arrêter l'optimisation:

La valeur de passer du temps d'effectuer des optimisations. Si vous avez des gens passer des semaines et ne pas trouver quoi que ce soit, y at-il de meilleures utilisations de ces ressources?
Quel est l'ordre de priorité d'optimisation. Il y a quelques facteurs que l'on pourrait prendre soin quand il s'agit de code: Temps d'exécution, l'espace d'exécution (à la fois en cours d'exécution et que le code compilé), l'évolutivité, la stabilité, le nombre de fonctionnalités sont mises en œuvre, etc. Une partie de cela est le commerce hors du temps et de l'espace, mais il peut aussi être un code où ne va, par exemple, peut middleware exécuter ad hoc des commandes SQL ou doivent être acheminés par les procédures stockées pour améliorer les performances?

Je pense que le point principal est qu'il ya un modération que la plupart de bonnes solutions auront.

Les optimisations de code ont peu à voir avec le style de codage. Le fait que le fichier contient des espaces de x ou de nouvelles lignes moins qu'au début ne fait pas mieux ou plus vite, au moins au stade de l'exécution - le format que vous le code avec des caractères blancs qui sont unsually ignorés par le compilateur. Il fait même le code pire, car il devient illisible pour les autres programmeurs et vous-même.

Il est beaucoup plus important pour que le code soit court et propre dans sa structure logique, telles que les conditions de test, flux de contrôle, les hypothèses, la gestion des erreurs ou l'interface de programmation globale. Bien sûr, je voudrais inclure également ici des commentaires intelligents et utiles + la documentation.

Il n'y a pas nécessairement une corrélation entre le code concis et la performance. Ceci est un mythe. Dans les langues matures comme C / C ++ les compilateurs sont capables d'optimiser le code très efficace. Il est nécessaire de la cause dans ces langues de supposer que le code plus concis est le meilleur code performant. Les plus récents, moins langues optimisées sur la performance comme Ruby ne possèdent pas les caractéristiques d'optimisation du compilateur de compilateurs C / C, mais il y a encore peu de raisons de croire que le code concis est plus performant. La réalité est que nous ne savons jamais comment le code et effectuera la production jusqu'à ce qu'il soit en production et est profilée. Simples, anodins, les fonctions peuvent être énormes goulots d'étranglement si elle est appelée suffisamment d'emplacements dans le code. Dans les systèmes hautement concurrents les plus importants goulots d'étranglement sont généralement causés par des algorithmes de concurrence pauvres ou verrouillage excessif. Ces problèmes sont rarement résolus par l'écriture de code « concis ».

La ligne de fond est la suivante: Le code qui fonctionne mal peut toujours être refactorisé une fois le profilage détermine qu'il est le goulot d'étranglement. Code ne peut être efficace si elle est refactorisé facile à comprendre. Le code qui est écrit pour être « concis » ou « intelligent » est souvent plus difficile à factoriser et à maintenir.

Écrivez votre code pour la lisibilité humaine factoriser puis pour des performances en cas de besoin.

Mes deux cents ...

code devrait être courte, concrète et concentrée. Vous pouvez toujours expliquer vos idées avec beaucoup de mots dans les commentaires .

Vous pouvez rendre votre code aussi court ou compact vous aimez aussi longtemps que vous le commenter. De cette façon, votre code peut être optimisé, mais encore faire sence. J'ai tendance à rester quelque part au milieu avec des variables et des méthodes descriptives et des commentaires si elle est végétation éparse pas encore clair.

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow