La micro-optimisation est-elle importante lors du codage?

J'ai récemment posé une question sur Stack Overflow pour savoir pourquoi isset () était plus rapide que strlen () en PHP . Cela a soulevé des questions sur l’importance du code lisible et sur la question de savoir si les améliorations de la performance en micro-secondes dans le code méritaient d’être prises en compte.

Mon père est un programmeur à la retraite et je lui ai montré les réponses. Il était absolument certain que si un codeur ne prenait pas en compte les performances de son code, même au niveau micro, il n'était pas un bon programmeur.

Je n'en suis pas si sûr. L'augmentation de la puissance de traitement nous évite peut-être de prendre en compte ce type d'amélioration de la micro-performance. Peut-être que ce genre de réflexion appartient aux personnes qui écrivent le code de langue actuel? (de PHP dans le cas ci-dessus).

Les facteurs environnementaux pourraient être importants - Internet consomme 10% de l'énergie mondiale. Je me demande à quel point quelques microsecondes de code représentent une perte de temps lorsqu’elles sont répliquées des milliards de fois sur des millions de sites Web.

J'aimerais connaître des réponses basées de préférence sur des faits concernant la programmation.

La micro-optimisation est-elle importante lors du codage?

Mon résumé personnel de 25 réponses, merci à tous.

Parfois, nous devons vraiment nous préoccuper des micro-optimisations, mais seulement dans de très rares circonstances. La fiabilité et la lisibilité sont beaucoup plus importantes dans la majorité des cas. Cependant, considérer de temps en temps la micro-optimisation ne fait pas mal. Une compréhension de base peut nous aider à ne pas faire de mauvais choix évidents lors du codage tel que

if (expensiveFunction() || counter < X)

Devrait être

if (counter < X || expensiveFunction())

( Exemple de @ zidarsk8 ) Il pourrait s'agir d'une fonction peu coûteuse et, par conséquent, modifier le code constituerait une micro-optimisation. Mais, avec une compréhension de base, vous n’auriez pas à le faire, car vous l’écririez correctement au départ.

Je suis tous les deux d'accord et pas d'accord avec ton père. Les performances doivent être envisagées tôt, mais la micro-optimisation ne doit l'être que si vous savez réellement qu'un pourcentage élevé de temps sera consacré à de petites sections de code liées au processeur.

Le problème avec la micro-optimisation est que cela se fait généralement sans idée de la façon dont les programmes passent réellement plus de temps que nécessaire.

Cette connaissance provient de l'expérience du réglage des performances, comme dans cet exemple , dans lequel un programme apparemment simple, sans aucune efficacité évidente, est suivi d'une série d'étapes de diagnostic et d'accélération, jusqu'à ce qu'il soit 43 fois plus rapide qu'au début.

Cela montre que vous ne pouvez vraiment pas deviner ou deviner où seront les problèmes. Si vous effectuez un diagnostic, qui dans mon cas est une pause aléatoire , les lignes de code responsables d'une fraction importante du temps sont de préférence exposées. Si vous les examinez, vous pouvez trouver un code de substitution et ainsi réduire le temps total d'environ cette fraction.

D'autres choses que vous n'avez pas corrigées prennent toujours autant de temps qu'auparavant, mais étant donné que le temps total a été réduit, ces choses prennent maintenant une fraction plus importante. Par conséquent, si vous recommencez, cette fraction peut également être éliminée. Si vous continuez à le faire après plusieurs itérations, c'est ainsi que vous pouvez obtenir des accélérations massives sans avoir nécessairement effectué de micro-optimisation .

Après ce type d’expérience, lorsque vous abordez de nouveaux problèmes de programmation, vous reconnaissez les approches de conception qui ont initialement conduit à de telles inefficiences. D'après mon expérience, cela vient de la conception excessive de la structure de données, de la structure de données non normalisée, du recours massif aux notifications, etc.

La micro-optimisation n’est importante que si les chiffres le disent.

Les exigences sur lesquelles vous vous développez doivent comporter certaines spécifications de données de performances, si celles-ci posent problème au client ou à l'utilisateur. Lorsque vous développez un logiciel, vous devez tester les performances de votre système par rapport à ces exigences. Si vous ne répondez pas aux exigences de performances, vous devez profiler votre base de code et optimiser au besoin pour atteindre les exigences de performances. Une fois que vous avez atteint les performances minimales requises, vous n'avez plus besoin de réduire les performances du système, surtout si vous voulez compromettre davantage la lisibilité et la maintenabilité du code (dans mon expérience, un code hautement optimisé est moins lisible et plus complexe. maintenable, mais pas toujours). Si vous pouvez obtenir des gains de performances supplémentaires sans dégrader les autres attributs de qualité du système,

Il existe cependant des cas où la performance est de la plus haute importance. Je pense principalement aux systèmes temps réel et aux systèmes embarqués. Dans les systèmes temps réel, la modification de l'ordre des opérations peut avoir un impact considérable sur le respect des délais rigoureux nécessaires au bon fonctionnement, voire même sur les résultats des calculs. Dans les systèmes intégrés, la mémoire, le processeur et la puissance de la batterie sont généralement limités. Vous devez donc réduire la taille de vos fichiers binaires et le nombre de calculs pour optimiser la durée de vie du système.

Chaque fois que quelqu'un pose des questions sur l' optimisation , je me souviens de la citation de Michael A. Jackson

La première règle de l'optimisation de programme: ne le faites pas.

Deuxième règle de l'optimisation de programme (réservée aux experts!): Ne le faites pas encore .

^{Citation de Wikipedia corrigée pour l'anglais britannique. * 8 ')}

La deuxième règle implique implicitement de profiler votre code et de ne consacrer que du temps à optimiser les éléments qui feront la différence.

Lors de la programmation en assemblage, l'affirmation de votre père était correcte. Mais c'est beaucoup plus proche du métal que la plupart des gens ne programment ces jours-ci. Aujourd'hui, même si vous essayez de vous optimiser (sans profilage), votre code risque de fonctionner plus lentement que si vous aviez fait quelque chose de la manière la plus courante, car cette manière de procéder est plus susceptible d'être optimisée par les compilateurs JIT modernes .

Même en C, il faut être très bon en optimisation pour en savoir plus sur l'optimisation d'une section de code par rapport au compilateur.

Si vous ne connaissez pas ce dont Ulrich Drepper parle dans son excellent document intitulé Ce que tous les programmeurs devraient savoir à propos de la mémoire , vous êtes probablement sur un perdant qui tente même de s’optimiser. Cependant, contrairement au titre du journal (ce qui est en réalité un hommage à la même chose fantastique de David Goldberg. ), Ne pas avoir ce niveau de compréhension ne vous empêche pas nécessairement d'être un bon programmeur, mais simplement une sorte de programmeur.

isset()vs strlen()en PHP

Je ne connais pas PHP, donc ce qui isset()est censé être fait n'est pas évident . Je peux le déduire du contexte, mais cela signifie qu'il sera également obscur pour les programmeurs novices en PHP et pourrait même amener les programmeurs plus expérimentés à double-prendre. C'est le genre d' usage idiomatique d'une langue qui peut faire de l'entretien un cauchemar.

Non seulement cela, mais rien ne garantit que ce isset()sera toujours plus efficace, simplement parce que c'est plus efficace maintenant. Une optimisation maintenant ne sera peut-être pas une optimisation l'année prochaine ou dans 10 ans. Les processeurs, systèmes et compilateurs s’améliorent et évoluent avec le temps. Si les performances de PHP strlen()posent problème, il est possible que PHP soit modifié à l'avenir. Il peut alors être nécessaire de supprimer toutes les optimisations de isset () pour optimiser encore une fois le code.

Toute optimisation a le potentiel de devenir une future anti-optimisation , elle doit donc être considérée comme une odeur de code possible, à conserver au minimum.

Un exemple d'expérience personnelle

Comme exemple d’une telle anti-optimisation , j’ai déjà eu à nettoyer une énorme base de code remplie de code de formulaire, if x==0 z=0 else z=x*ycar quelqu'un avait supposé qu’une multiplication à virgule flottante coûterait toujours plus cher qu’une branche. Sur l'architecture cible d'origine, cette optimisation a accéléré l'exécution du code, mais les temps changent.

Lorsque nous avons essayé d'utiliser ce code sur un processeur plus moderne et très pipeline, les performances étaient horriblement mauvaises. Chacune de ces déclarations provoque un vidage du pipeline. En simplifiant toutes ces lignes de code, z=x*yle programme a dû exécuter un ordre de grandeur plus rapide sur la nouvelle architecture, rétablissant ainsi les pertes de performances dues à l' anti-optimisation .

Les problèmes que nous devons généralement optimiser pour aujourd'hui sont très différents de ceux que nous devions optimiser il y a 20, voire 10 ans.

Ensuite, nous nous inquiétions de faire le plus de travail possible par cycle d'horloge. Nous sommes maintenant davantage préoccupés par les vidages de pipeline, les erreurs de prédiction de branche et les erreurs de cache au niveau du processeur, mais les verrous et la communication interprocessus deviennent de plus en plus importants au fur et à mesure que nous passons au multi- processus et architectures multiprocesseurs. Le papier de Drepper peut vraiment aider à comprendre beaucoup de ces problèmes.

1. Écrivez un code propre, concis, simple et explicite.
2. Faites des tests de performance pour identifier les goulots d'étranglement.
3. Optimiser les sections critiques.

En règle générale: 95% de votre code est exécuté 5% du temps. Il est inutile d’optimiser avant de profiler / évaluer votre code et de voir quels sont les 5% exécutés 95% du temps.

Chaque imbécile peut faire de la micro-optimisation et tout compilateur / run-time décent le fera pour vous.
Optimiser un bon code est trivial. Écrire du code optimisé et essayer de le rendre bon après cela est fastidieux au mieux et insoutenable au pire.

Si vous vous souciez sérieusement des performances, n'utilisez pas PHP pour du code essentiel à la performance. Trouvez les goulots d'étranglement et réécrivez-les avec les extensions C. Même la micro-optimisation de votre code PHP au-delà de l'obscurcissement ne vous donnera pas autant de vitesse.

Personnellement, j'ai beaucoup aimé faire de la micro-optimisation lorsque j'ai commencé à programmer. Parce que c'est évident. Parce que cela vous récompense rapidement. Parce que vous n'avez pas à prendre de décisions importantes. C'est le moyen idéal de procrastination. Il vous permet de fuir les aspects vraiment importants du développement logiciel: la conception de systèmes évolutifs, flexibles, extensibles et robustes.

Je suis d’accord avec votre père: "Si un codeur ne prend pas en compte les performances dans son code, même au niveau micro, il n’est pas un bon programmeur." La clé est de "considérer la performance". Cela n’équivaut pas à "faire des micro-optimisations à chaque étape".

Je suis d'accord avec la plupart des autres commentaires - ce qui était utilisé auparavant pour accélérer les programmes C ne le fait peut-être pas aujourd'hui - mais il y a d'autres choses sérieuses à prendre en compte: Devrais-je utiliser le C ou C ++? Les classes avec des opérateurs simples surchargés peuvent nuire aux performances si vous les utilisez beaucoup. Est-ce important? Cela dépend de votre application, mais si vous ne le considérez même pas, vous n'êtes pas un très bon programmeur. Certaines personnes pourraient le considérer pendant environ 2 millisecondes et le rejeter, mais je pense que beaucoup trop ne le considèrent même pas littéralement.

En réalité, avec l'optimisation, le code peut devenir plus difficile à lire. Le code prendra plus de temps à écrire. Le code sera quelque part entre un peu plus rapide et un ordre de grandeur plus rapide (c'est rare). Vos clients ne connaîtront probablement pas la différence.

Une autre réalité est que les gens aiment réutiliser du code, et le résultat peut être très différent de celui que vous aviez écrit. Tout à coup, les gens peuvent s'en soucier.

Par exemple, disons que vous avez écrit quelque chose comme Angry Birds sur un PC ou pour une console de jeux. Vous avez ignoré l'optimisation de votre système physique et de votre système graphique, car les deux cœurs à 2,5 GHz sont à la base le minimum requis de nos jours et que votre jeu fonctionne correctement. Ensuite, les téléphones intelligents arrivent et vous voulez le porter. Oh, sacrément, un noyau ARM 600 MHz ?

Pensez à un site Web - quelque chose qui a été créé pendant un week-end comme Hot or Not . Vous utilisez la base de données qui vous convient, écrivez tout avec un développement rapide à l’esprit, lancez en envoyant une URL à vos amis. Trois mois plus tard, votre serveur est en train de mourir de surcharge et vous ne pouvez rien faire pour passer à la vitesse supérieure. Cela arrive tout le temps. Les sites Web les plus importants ont des factures d'électricité mesurées en centaines de kilowatts ou même en mégawatts. Pensez-y, il y a des mégawatts à économiser grâce à l'optimisation du code.

Comme votre père l'a dit, vous devez au moins y penser . La plupart des gens ne savent même pas à quel point les performances sont sur la table et la dissimulent avec une petite astuce sur "l'optimisation prématurée" et "ne le fais pas". Ce ne sont pas de bons programmeurs.

Ce n'est pas une opinion populaire sur ces sites. Au revoir les points de réputation ....

Prenons d'abord votre cas: PHP

• Je ne pense pas que PHP soit un type de langage (à la fois en raison de sa nature et de son domaine d'application principal) dont vous avez besoin pour vous soucier de ces "micro-optimisations". Le code PHP est principalement optimisé avec la mise en cache opcode.
• Les programmes écrits en PHP ne sont pas liés au processeur, ils sont principalement liés aux E / S , donc ces optimisations ne valent pas votre temps de toute façon.
• Tout ce que vous DEVEZ optimiser doit probablement être inséré dans une extension C puis chargé dynamiquement dans le runtime de PHP
• Comme vous pouvez le constater, nous n'obtenons aucune incitation à la micro-optimisation de notre code PHP. Par contre, si vous passez ce temps à rendre le code PHP plus lisible et facile à gérer, cela vous rapportera plus de dividendes.

En général,

Je ne passerais pas beaucoup de temps à optimiser mon code dans un langage dynamique comme Python ou Ruby , car ils ne sont PAS conçus pour des tâches de traitement de données nécessitant beaucoup de temps . Ils résolvent différents types de problèmes pour lesquels la modélisation d'une situation réelle (facile à lire et à gérer) - ce qui s'appelle l' expressivité - est plus importante que la rapidité. Si la vitesse était la préoccupation principale, ils ne seraient pas dynamiques en premier lieu.

Pour les programmes compilés (C ++, Java), l’optimisation est plus cruciale. Mais là aussi, vous devez d'abord examiner la nature / domaine / objectif du programme que vous écrivez. Vous devez également peser soigneusement le temps nécessaire à la micro-optimisation par rapport aux avantages de cette optimisation. Si vous avez encore besoin d'optimisation, vous pouvez également envisager une étape supplémentaire et coder ces éléments de code dans l'assembleur.

Donc, pour répondre à votre question initiale - "La micro-optimisation est-elle importante lors du codage?" - la réponse est - il DÉPEND -

• Quel genre de chose faites-vous: domaine d'application, complexité?
• Les améliorations de la vitesse en microsecondes sont-elles VRAIMENT importantes pour votre programme?
• Quelle optimisation sera la plus rentable? Ce n'est peut-être pas toujours une optimisation de code, mais quelque chose d'extérieur.
• Combien de "bien" (en termes de rapidité) vous récoltez-vous du temps que vous investissez en micro-optimisation?
• Peut-on atteindre de meilleures vitesses autrement - en modifiant le matériel, la RAM et le processeur, en exécutant le code en parallèle ou sur un système distribué?

Non seulement la micro-optimisation (l'optimisation de code, d'ailleurs) prend du temps, elle "déforme" la lisibilité naturelle de votre code, le rendant ainsi très lourd en maintenance. Considérez toujours cela comme un dernier recours. Essayez toujours d'optimiser l'ensemble de l'application en adoptant un meilleur matériel et une meilleure architecture que l'optimisation de fichiers de code individuels.

Il semble y avoir beaucoup de réponses qui disent que l'optimisation micro est

tout ce qui concerne les compromis - performances, temps, coûts, efforts, lisibilité / maintenabilité, etc.

Mais bon, je sais qu’il ya certaines optimisations pour lesquelles il n’existe aucun impact sur la lisibilité, et j’aime simplement les faire pour le plaisir. J'ai constaté sur certains de mes travaux scolaires (qui étaient tous basés sur la vitesse), qu'il était toujours agréable de considérer l'optimisation micro lors de la rédaction d'énoncés conditionnels tels que:

if (counter < X && shouldDoThis()) // shouldDoThis() is an expensive function

est toujours plus gentil que

if (shouldDoThis() && counter < X ) 

Il y a pas mal de façons d '"accélérer" votre code comme ça et la différence est généralement négligeable (pas toujours), mais je me sentirais mieux si je l'écrivais comme ça.

Je ne sais pas si quelqu'un considère cela comme une optimisation, mais je pense qu'un programmeur devrait savoir et tenir compte de ces choses lorsqu'il écrit son code.

Au début de ma carrière, des déclarations générales telles que «ne pas micro-optimiser» ont créé beaucoup de confusion. Tout est circonstanciel; ainsi, la raison pour laquelle les gens disent "meilleure pratique" plutôt que "faire ceci".

La "meilleure pratique" est le premier choix compte tenu de toutes les circonstances. Par exemple, LINQ et Entity Framework doivent être utilisés à la place du SQL en ligne. Chez moi, nous sommes sur SQL Server 2000 . SQL Server 2000 ne prend pas en charge Entity Framework. Les meilleures pratiques nécessitent:

• Vendre mon patron à l’idée d’acheter une nouvelle version de SQL Server, ce qui représente plusieurs milliers de dollars.
• Vendre des développeurs sur l'idée d'apprendre de nouvelles technologies.

Je sais d'expérience que cela ne va pas arriver. Donc, je pouvais arrêter de fumer, ne pas trop stresser ou ne pas suivre les meilleures pratiques.

Des considérations politiques, techniques et monétaires sous-tendant les décisions ont une incidence sur le résultat global. Rappelez-vous ce fait lorsque vous prenez une décision et choisissez judicieusement vos batailles.

" Pour tout, il y a une saison, un temps pour chaque activité sous le ciel. "

C'est toujours un compromis.

Premièrement, l’industrie informatique est une question d’argent à la fin. Ce que vous devez faire en tant que développeur, c'est générer de la valeur pour le client afin d’obtenir de l’argent (c’est une simplification à outrance, mais le point principal est ici).

Le temps de développement coûte de l'argent. La puissance de la machine coûte aussi de l'argent. Habituellement, ce deuxième coût est bien inférieur au premier. Il est donc capital d’avoir un code lisible et un code maintenable afin que les développeurs puissent passer le plus clair de leur temps à générer de la valeur.

La microoptimisation peut, dans certains cas, être importante. Mais ils impliquent généralement un code moins lisible ou un code moins extensible (ce n'est pas le cas de votre exemple lié, mais en général, il l'est). Cela coûtera à un moment donné au développeur. Cette fois étant plus coûteux que la puissance de la machine, c'est un gaspillage.

Deuxièmement, la micro-optimisation dans un grand projet peut rendre de plus en plus difficile la maintenance / l'évolution. Le problème, c’est que lorsqu’elles évoluent, une autre optimisation peut maintenant être impossible à faire. Avec une application en évolution, vous obtiendrez généralement une solution plus lente que celle que vous auriez eue sans ces optimisations.

Troisièmement, l'optimisation est souvent irréprochable car la complexité de l'algorithme surmontera généralement toute micro-optimisation que vous auriez pu réaliser si le jeu de données augmentait. Malheureusement, étant donné que la micro-optimisation rend votre code plus difficile à maintenir / à évoluer, cette optimisation peut être plus difficile à faire.

Parfois, la valeur réside dans cette optimisation (pensez aux programmes critiques en matière de latence, comme dans les jeux vidéo ou le pilote automatique d’un avion). Mais cela doit être démontré. Habituellement, votre programme passe la majeure partie du temps dans une portion limitée de code. Quelle que soit la micro-optimisation que vous fassiez, vos programmes ne seront jamais aussi rapidement accélérés sans identifier le goulot d'étranglement et travailler sur cette partie.

Poser votre question comme vous l'avez montré montre que vous n'avez pas comparé le problème à un programme réel. Dans ce cas, vous pourriez avoir fait le tour et remarqué si c'était plus rapide ou pas. Donc, vous demandiez cela avant d'avoir un problème. C'est là que se trouve le problème. Vous avez mal géré le problème de l'optimisation.

Comme la maintenance et l'évolution ont généralement plus de valeur que la micro-optimisation, assurez-vous de disposer de la bonne interface avant de vous lancer. Ensuite, si certaines parties de votre programme sont suffisamment abstraites l’une pour l’autre, vous pouvez en optimiser un sans en déranger tout. Cela nécessite que votre interface fonctionne suffisamment longtemps pour être approuvée.

La performance est une caractéristique

L'article de Jeff Atwood est excellent sur la création d'un site Web performant et sur l'importance de le faire ...

Cela dit, ne vous concentrez pas sur la micro-optimisation avant d’en avoir besoin. Vous pouvez effectuer une optimisation plus rentable. Concentrez-vous sur l'architecture, pas sur le code. La plupart des sites Web que j'ai vus qui fonctionnaient lentement présentaient des problèmes de haut niveau (couche de service Web inutile, conception de base de données médiocre, architectures excessivement compliquées) qui non seulement nuisaient aux performances, mais étaient profondément enracinés et difficiles à corriger.

Lorsque vous créez un site Web, votre code côté client et votre logique de base de données sont beaucoup plus susceptibles de causer des problèmes de performances que votre code côté serveur. Comme quoi que ce soit, si vous avez des problèmes de performances, vous saurez mieux, profilez encore mieux votre code et vous pourrez le retrouver rapidement.

Le temps de développement coûte plus cher que le temps d’ordinateur. C'est généralement ce que vous souhaitez optimiser. Mais:

• Il y a une différence entre la micro-optimisation et la complexité algorithmique. Consacrez suffisamment de temps pour vous assurer que vous utilisez le bon algorithme .
• Assurez-vous que vous posez la bonne question, ce select (select count(*) from foo) >= 1n'est pas la même chose que select exists(select 1 from foo).
• certains idiomes de langue sont populaires simplement parce qu'ils sont plus rapides. Il est correct de les utiliser, car la plupart des utilisateurs de cette langue les maîtriseront. (votre exemple est un bon exemple).

Que voulez-vous optimiser?

• Performance du logiciel?
• Fiabilité?
• Productivité du programmeur?
• Satisfaction du client?
• Efficacité énergétique?
• Maintenabilité?
• Temps de marché?
• Coût?

"Optimiser" ne signifie pas toujours que le code soit exécuté aussi rapidement que possible. Il est parfois important de trouver le moyen le plus rapide et absolu de faire quelque chose, mais ce n'est pas vraiment courant dans la plupart des codes. Si les utilisateurs ne peuvent pas remarquer la différence entre 50 et 100 microsecondes, il n'y a aucune différence entre les deux en code qui ne s'exécutera qu'occasionnellement. Voici un exemple:

Si vous devez continuellement mettre à jour un affichage de la longueur de la saisie de l'utilisateur et du temps qu'il faut à l'une des deux routines pour déterminer que la longueur est beaucoup plus petite que le temps entre deux frappes de touche consécutives, peu importe la routine. tu utilises. D'autre part, si vous devez déterminer la longueur d'un milliard de chaînes, vous devrez probablement porter une attention particulière aux différences de performances entre différentes routines. Dans le premier cas, vous préférerez peut-être écrire un code facile à comprendre et à vérifier; dans le second cas, vous pourriez être prêt à échanger votre lisibilité pour gagner du temps.

Dans tous les cas, si vous souhaitez optimiser votre code, vous devez le profiler avant et après les modifications que vous apportez. Les programmes actuels sont suffisamment compliqués pour qu'il soit souvent difficile de déterminer les goulots d'étranglement; Le profilage vous aide à optimiser le bon code , puis à montrer que les optimisations que vous avez effectuées ont réellement fonctionné.

Vous n'avez pas dit quand votre père a pris sa retraite ni quel genre de programmation il a faite, mais sa réaction n'est pas surprenante. Historiquement, la mémoire, le stockage secondaire et le temps de calcul étaient coûteux et parfois très coûteux. Ces jours-ci, toutes ces choses sont devenues très bon marché par rapport au temps des programmeurs. Dans le même temps, les processeurs et les compilateurs sont devenus capables d’optimiser le code de manière que les programmeurs ne puissent jamais égaler. Les jours où les programmeurs utilisent de petites astuces pour réduire quelques instructions de machine ici et là sont pour la plupart révolues.

Il n’est pas important d’optimiser lors de l’écriture du code. L'optimisation doit être effectuée à l'aide d'un profileur, optimisant le code là où cela compte.

CEPENDANT , un programmeur doit éviter de faire des choses évidemment stupides en écrivant le code.

Par exemple, ne faites pas d'opérations coûteuses répétées dans une boucle. Stockez la valeur dans une variable en dehors de la boucle et utilisez-la. Ne faites pas des choses comme les comparaisons de chaînes ou les expressions rationnelles dans une fonction souvent appelée, lorsque vous pouvez monter d'un niveau, faire la comparaison et en faire un entier, une référence de fonction ou une classe dérivée.

Ces choses sont faciles à retenir pour un programmeur expérimenté et améliorent presque toujours la qualité du code.

Lorsque vous décidez quoi optimiser, souvenez-vous toujours de la loi d'Amdahl . Voir le lien pour des maths précises; la phrase à retenir est la suivante:

Si une partie de votre programme représente 10% de son temps d'exécution et que vous optimisez le temps d'exécution de cette partie deux fois plus vite, le programme dans son ensemble ne fera qu'accélérer de 5%.

C'est pourquoi les gens disent toujours qu'il ne vaut pas la peine d'optimiser les parties de votre programme qui n'occupent pas plus de quelques pour cent de la durée totale d'exécution. Mais ce n'est qu'un cas particulier d'un principe plus général. La loi d'Amdahl vous dit que si vous devez faire en sorte que le programme fonctionne deux fois plus vite, vous devez accélérer chaque élément de 50% en moyenne. Il vous indique que si vous devez traiter vingt gigaoctets de données, il n'y a que deux façons de le rendre plus rapide que le temps nécessaire pour lire vingt gigaoctets sur le disque: obtenez un disque plus rapide ou réduisez la taille des données.

Alors, que dit la loi d'Amdahl à propos de la micro-optimisation? Il dit qu'ils valent peut-être la peine s'ils appliquent à tous les niveaux. Si vous pouvez économiser 1% sur le temps d'exécution de chaque fonction de votre programme, félicitations! Vous avez accéléré le programme de 1%. Cela valait-il la peine? Eh bien, en tant que compilateur, je serais ravi de trouver une optimisation qui permette de le faire, mais si vous le faites à la main, je dirais de chercher quelque chose de plus grand.

Cela dépend de votre stade de développement. Lorsque vous commencez à écrire, les micro-optimisations ne doivent pas être prises en compte, car vous obtiendrez plus de gains de performances en utilisant de bons algorithmes que de micro-optimisations. En outre, réfléchissez à ce que vous développez, car les applications sensibles au facteur temps bénéficieront davantage des considérations d'optimisation micro que les applications d'entreprise génériques.

Si vous testez et développez des logiciels, les micro-optimisations vous blesseront probablement, elles tendent à rendre le code plus difficile à lire et même à introduire leur propre ensemble unique de bogues qui doivent être corrigés avec tout ce qui doit l'être.

Si vous recevez en fait des plaintes d'utilisateurs au sujet du code lent, elles pourraient valoir la peine d'être examinées, mais uniquement si tout le reste a été résolu, à savoir:

• Le code est-il bien écrit?
• L'application est-elle capable d'accéder à ses données sans aucun problème?
• Peut-on utiliser un meilleur algorithme?

Si toutes ces questions ont été résolues et que vous rencontrez toujours des problèmes de performances, alors il serait peut-être temps de commencer à utiliser des micro-optimisations dans le code, mais il est fort probable que d'autres modifications (par exemple, un meilleur code, un meilleur algorithme, etc.) plus d'un gain de performance qu'une volonté de micro-optimisation.

La rapidité d'exécution est l'un des nombreux facteurs qui contribuent à la qualité d'un programme. Souvent, la vitesse a une corrélation inverse avec la lisibilité / maintenabilité. Dans presque tous les cas, le code doit être lisible par l'homme pour pouvoir être conservé. Le seul moment où la lisibilité peut être compromise, c'est lorsque la vitesse est une exigence essentielle. L’obligation de rendre le code plus rapide que ne le permettent totalement la lisibilité / la maintenabilité n’est pratiquement jamais applicable, mais dans certains cas, cela sera le cas. La principale chose à retenir est que le code micro-optimisé est souvent du code hacky. Par conséquent, à moins d’une exigence définie quelque part, c’est presque toujours la mauvaise façon de résoudre le problème. Par exemple, l'utilisateur ne remarquera presque jamais la différence entre des durées d'exécution de 0,5 seconde et 1 seconde dans les opérations CRUD. Vous n'avez donc pas besoin de participer à une assemblée-interop-hackfest pour en arriver à cette seconde. Oui, je pourrais piloter un hélicoptère au travail et ce serait 10 fois plus rapide, mais je ne le fais pas à cause du prix et du fait que l'hélicoptère est beaucoup plus difficile à piloter.Lorsque vous optimisez inutilement le code, c'est exactement ce que vous faites: ajouter une complexité et des coûts inutiles pour atteindre un objectif superflu.

La micro-optimisation est importante lorsque vous frappez une contrainte. Ce qui compte pour vous peut être la mémoire, le débit, la latence ou la consommation électrique. Notez qu'il s'agit de caractéristiques au niveau du système. vous n'avez pas besoin (et ne pouvez pas) optimiser chaque fonction de toutes les manières.

Les systèmes embarqués auront probablement plus besoin de la micro-optimisation, car les contraintes sont plus facilement impactées. Cependant, même là, la micro-optimisation ne vous mène que jusque-là; vous ne pouvez pas micro-optimiser votre sortie d'un mauvais design. Le point sur la bonne conception d’un système est qu’il est possible de raisonner sur le système dans son ensemble. Les composants nécessitant une micro-optimisation doivent être clairement exposés et optimisés de manière à ne pas compromettre la conception du système.

Notez qu’aujourd’hui, les petits systèmes «intégrés» peuvent être assez proches du Vaxen ou du PDP-11 d’aujourd’hui. Ces problèmes étaient donc plus courants. Sur un système moderne polyvalent faisant appel à l'informatique commerciale générale moderne, la micro-optimisation est rare. Cela fait probablement partie des raisons pour lesquelles votre père adopte la position qu'il adopte.

Cependant, peu importe si vous avez affaire à des nanosecondes, des millisecondes, des secondes ou des heures; les problèmes sont les mêmes. Ils doivent être évalués dans le contexte du système et de ce que vous essayez de réaliser.

Voici un exemple d'une question récente à laquelle j'ai répondu sur Stack Overflow pour un cas dans lequel une micro-optimisation était nécessaire: des encodeurs vidéo open source pour un système intégré .

Le principal problème de la micro-optimisation est qu’elle vous oblige à écrire un code plus difficile à gérer.

Un autre problème est que, selon la configuration de votre ordinateur, votre micro-optimisation peut parfois présenter de plus mauvaises performances que sans «optimisation».

Faire beaucoup de micro-optimisation vous prendra beaucoup de temps à lutter contre quelque chose qui ne compte pas vraiment.

Une meilleure approche consiste à créer un code plus propre, plus facile à gérer, et si vous rencontrez des problèmes de performances, vous créez un profil pour déterminer ce qui ralentit vraiment votre code. Et sachant exactement ce qui est vraiment mauvais, vous pouvez y remédier.

Je ne dis pas que ne pas faire de micro-optimisations est une excuse pour écrire du code stupide.

Si vous commencez à vous soucier des millisecondes, vous devriez envisager d'abandonner PHP et d'utiliser plutôt C ou Assembly. Non pas que je veuille faire cela, cela n’a aucun sens de discuter de tels nombres et d’utiliser un langage de script. Votre code itère-t-il souvent avec cette commande?

Les facteurs environnementaux sont hors de question ici, ces serveurs fonctionnent quand même 24 heures sur 24, 7 jours sur 7, et s’ils traitent réellement quelque chose, cela n’aura d’importance que s’il s’agit d’une tâche très longue.

Très probablement, la lumière dans votre bureau et l'énergie utilisée par nos ordinateurs pendant que nous tapions tous les questions et réponses utilisaient beaucoup plus d'énergie que toute optimisation que vous pouvez raisonnablement appliquer à vos applications.

Vous devez choisir le meilleur algorithme simple pour la tâche. La raison pour laquelle cela doit être simple est de garder le code lisible. La raison pour laquelle il doit être le meilleur est d'éviter de commencer avec de mauvaises caractéristiques d'exécution. Ne choisissez pas aveuglément BubbleSort lorsque vous savez que vous disposerez de grands ensembles de données. C'est bien, cependant, pour le type occasionnel de 10 éléments.

ALORS, si les chiffres de profilage montrent que votre choix du meilleur algorithme simple n’était pas suffisant, vous pouvez lancer l’optimisation (qui correspond généralement au coût de la lisibilité).

Je l'ai déjà dit, et je le dirai ici: "L'optimisation prématurée est la racine de tout mal" . Cela devrait être l’une des règles au centre de l’esprit de tout programmeur.

Le code peut, jusqu'à un certain point, toujours être plus rapide qu'il ne l'est actuellement. À moins que vous n'emballiez à la main avec une puce en tête, l'optimisation vous apportera toujours quelque chose à gagner. Cependant, à moins que vous VOULEZ réaliser un assemblage à la main pour tout ce que vous faites, vous devez définir un objectif quantitatif. Lorsque vous vous rencontrez, vous dites "c'est assez" et arrêtez l'optimisation, même s'il reste encore une performance éblouissante à regarder. vous en face.

Un code beau, élégant et extrêmement performant est inutile s'il ne fonctionne pas (et par "travail", je veux dire le résultat attendu compte tenu de tous les apports attendus). Par conséquent, produire du code qui fonctionne devrait TOUJOURS être la première priorité. Une fois que cela fonctionne, vous évaluez les performances et, le cas échéant, recherchez les moyens de l'améliorer, jusqu'au point où elles sont suffisamment performantes.

Il y a certaines choses que vous devez décider dès le départ qui auront une incidence sur les performances; décisions très basiques telles que la langue / le runtime que vous utiliserez pour implémenter cette solution. Nombre de ces problèmes auront davantage d’impacts sur les performances que d’appeler une méthode plutôt qu’une autre. Honnêtement, PHP, en tant que langage scripté, est déjà un succès en termes de performances, mais comme très peu de sites scriptés sont construits à partir de la base en C / C ++, ils sont comparables à d’autres technologies parmi lesquelles vous choisiriez probablement (Java Servlets, ASP.NET). , etc).

Après cela, la taille des messages d'E / S est votre prochain killer de performances. Optimiser ce que vous lisez et écrivez sur le disque dur, les ports série, les canaux réseau, etc. améliorera généralement l'exécution du programme de plusieurs ordres de grandeur, même si les algorithmes à l'origine des opérations d'E / S étaient efficaces. Après cela, réduisez la complexité de Big-O de l’algorithme lui-même, puis si vous le devez absolument, vous pouvez «optimiser» en choisissant des appels de méthode moins coûteux et en prenant d’autres décisions ésotériques à bas niveau.

Vous mentionnez que votre père est un programmeur à la retraite. Les programmeurs qui travaillaient dans le monde du mainframe devaient être très préoccupés par la performance. Je me souviens d’avoir étudié une activité de la US Navy dans laquelle leur ordinateur central était limité à 64 Ko de mémoire par utilisateur. Dans ce monde de programmation, vous devez chercher chaque fois que vous le pouvez.

Les choses sont très différentes maintenant et la plupart des programmeurs n'ont pas à se préoccuper autant de la micro-optimisation. Cependant, les programmeurs de systèmes intégrés et les utilisateurs de bases de données doivent encore beaucoup utiliser du code optimisé.

Le code doit être écrit pour être absolument clair sur ce qu'il fait. Ensuite, si et seulement si c'est trop lent, revenez en arrière et accélérez. Le code peut toujours être changé pour être plus rapide plus tard, s'il peut être compris - mais bonne chance, changez-le pour qu'il soit clair s'il est rapide.

C'est important si:

1) La vie de quelqu'un dépend de votre code. Une fonction prenant 25 ms à exécuter dans le moniteur de fréquence cardiaque est probablement une mauvaise idée.

Personnellement, j’adopte une double approche: vous pouvez faire des micro-optimisations qui n’affecteront pas la lisibilité et vous voudrez bien sûr les utiliser. Mais si cela affecte la lisibilité, attendez, vous n’obtiendrez pas beaucoup d’avantages et le processus de débogage à long terme risque de prendre plus de temps.

La micro-optimisation est-elle importante lors du codage?

Non, étant donné qu'il existe des plates-formes telles que JVM et .NET où le code est écrit pour une machine virtuelle et que, par conséquent, l'optimisation de l'exécution peut ne pas fonctionner aussi bien que ce qui est optimal sur le bureau d'un développeur n'est pas nécessairement le même sur un serveur. Regardez à quel point certains de ces logiciels de haut niveau sont éloignés du matériel pour un autre point. Un élément à prendre en compte est la diversité du matériel. À quel point est-il réaliste d'optimiser le code pour des puces spécifiques telles qu'un processeur ou un processeur graphique lorsqu'un nouveau modèle sortira probablement dans moins d'un an?

Une autre question à prendre en compte ici concerne les performances mesurées par la métrique: vitesse d’exécution, mémoire utilisée, vitesse de développement de nouvelles fonctionnalités, taille de la base de code sur un serveur sous forme compilée ou décompilée, évolutivité, maintenabilité, etc. . Si elle est prise au sens large, la question devient triviale, mais je ne suis pas sûre de savoir dans quelle mesure vous entendiez par performance le fait que cela puisse être presque n'importe quoi pourvu que cela puisse être mesuré d'une manière ou d'une autre.

Certaines micro-optimisations peuvent fonctionner et d'autres ne fonctionnent pas. C'est pourquoi on peut se demander à quel point il est intéressant de réaliser un tel travail par rapport à d'autres travaux pouvant être considérés comme prioritaires, telles que les nouvelles fonctionnalités ou la correction de bugs. L'autre question serait de savoir si une mise à niveau de matériel ou de logiciel pourrait également casser certaines de ces optimisations.

Je pense qu'il y a une grande différence entre une bonne programmation et une micro-optimisation.

S'il existe deux façons de faire la même tâche, l'une étant plus rapide que l'autre et offrant la même lisibilité, vous devriez utiliser la plus rapide. Toujours. Et c'est une bonne programmation. Il n'y a aucune raison de ne pas utiliser un meilleur algorithme pour résoudre un problème. Et même la documenter est simple: donnez le nom de l’algorithme, tout le monde pourra le rechercher sur Google et trouver plus d’informations sur son fonctionnement.

Et les bons algorithmes sont déjà optimisés. Ils seront rapides. Ils seront petits. Ils utiliseront la mémoire minimale requise.

Même si leur utilisation n’a toujours pas cette performance, vous pouvez envisager de la micro-optimiser. Et vous devrez vraiment connaître la langue pour pouvoir micro-optimiser.

Et il est toujours possible de dépenser plus d’argent en matériel. Le matériel est bon marché, les programmeurs sont chers . Ne dépensez pas trop de temps et d’argent en optimisant vos achats en achetant du matériel.

La lisibilité du code à mon humble avis est plus importante que la micro-optimisation, car dans la plupart des cas, la micro-optimisation n'en vaut pas la peine.

Article sur les micro-optimisations sans sens :

Comme la plupart d'entre nous, je suis fatiguée de lire des articles de blog sur les micro-optimisations non sensées, telles que le remplacement de print par echo, ++ $ i par $ i ++ ou les guillemets doubles par des guillemets simples. Pourquoi? Comme 99,999999% du temps, cela n'a aucune importance. Pourquoi? Parce que 99,99% du temps, vous feriez mieux d'installer un accélérateur PHP comme APC, d'ajouter ces index manquants dans les colonnes de votre base de données ou d'éviter les 1 000 demandes de base de données que vous avez sur la page d'accueil.

print utilise un autre opcode car il renvoie en réalité quelque chose. Nous pouvons en conclure que l'écho est plus rapide que l'impression. Mais un code d'opération ne coûte rien, vraiment rien.

J'ai essayé une nouvelle installation de WordPress. Le script s'arrête avant qu'il ne se termine avec une "erreur de bus" sur mon ordinateur portable, mais le nombre d'opcodes était déjà supérieur à 2,3 millions. Assez dit.

Ainsi, dans la plupart des cas, la micro-optimisation enregistre une opération parmi des millions, mais rend la lisibilité plus difficile.

D'autres réponses sont justes sur l'argent. Mais j'ajouterai un autre point où il faut différencier ce qui est prématuré d'optimisation / micro-optimisation et écrire un code performant qui reflète une compréhension du comportement des constructions langage / framework (désolé, impossible de trouver un mot pour le dernier) . Le dernier est une bonne pratique de codage et il faut généralement le faire!

Je vais expliquer. Une mauvaise optimisation (optimisation prématurée / micro de lecture) n’est pas le cas lorsque vous optimisez des sections de code sans profilage pour savoir s’il s’agit vraiment de goulots d’étranglement. C'est lorsque vous optimisez en fonction de vos hypothèses, de vos auditions et de vos comportements non documentés. Si elle est documentée et fait quelque chose d'une manière plus efficace / logique , aussi petite soit-elle, je l'appelle une bonne optimisation . Comme d’autres l’ont dit, ces deux services n’ont contre et presque aucun avantage en ce qui concerne les bonnes affaires, mais je fais tout de même le dernier, pas le premier, si cela ne nuit pas totalement à la lisibilité. Oui, la lisibilité / la maintenabilité est de la plus haute importance et concerne le point de départ de la ligne.

Je réitère les points soulevés par d’autres ici comme la futilité des bonnes et des mauvaises optimisations:

1. Vos dépendances à un problème spécifique peuvent changer et le temps consacré à l'optimisation avant de remplir la section logique de votre application est une perte de temps. Je veux dire optimiser à un stade relativement précoce. Aujourd'hui, vous avez un List<T>et au moment où votre application est expédiée, vous deviez la changer LinkedList<T>et maintenant, tout le benchmarking était une perte de temps et d'effort.

2. Généralement, le goulet d'étranglement réel de votre application (considéré comme une différence mesurable) pourrait représenter 5% de votre code (principalement les codes SQL) et l'optimisation des 95% restants n'apporte aucun avantage à vos clients.

3. Habituellement, un code "techniquement" plus performant signifie plus de verbosité, ce qui signifie plus de code sujet aux erreurs, ce qui signifie une maintenabilité plus difficile et plus de temps, ce qui signifie que vous gagnez moins.

4. L'empreinte carbone que vous économisez pour le monde entier grâce à un gain de performances de 1% est facilement compensée par les gaz à effet de serre que votre équipe devra émettre lors du débogage et de la maintenance de ce code.

Les inconvénients de la mauvaise optimisation sont notamment:

1. Cela ne vous donne pas souvent la performance que vous attendez. Voir cette question sur SO, où les optimisations ont mal tourné . En fait, cela peut avoir des effets indésirables. C'est le problème du comportement non documenté.

2. Les compilateurs principalement modernes le feront pour vous de toute façon.

Je vais donner quelques exemples d'optimisation mauvaise et bonne:

Le mauvais -

1. utilisation de types entiers plus petits au lieu de Int32.

2. ++i utilisé au lieu de i++

3. forau lieu de foreach(le pire que j'ai vu, défait totalement la logique)

4. éviter les variables fermées

   string p;
   foreach (var item in collection)
       p = ...;
   

5. utiliser à la charplace de chaîne lors de la concaténation de chaîne, comme:

   string me = 'i' + "me myself"; // something along that line - causes boxing
   

The good (from .NET world. Devrait être explicite) -

1. Double recherche

   if (Dictionary<K, V>.TryGetValue(K, out V))
       do something with V
   

   au lieu de

   if (Dictionary<K, V>.ContainsKey(K))
       do something with Dictionary<K, V>[K]
   

2. Chargez-les tous

   DirectoryInfo.EnumerateFiles();
   

   au lieu de

   DirectoryInfo.GetFiles();
   

3. Coulée en deux étapes:

   s = o as string;
   if (s != null)
       proceed
   

   au lieu de

   if (o is string)
       s = (string)o;
   

4. Si l'ordre n'a pas d'importance

   if (counter < X || expensiveFunction())
   

   au lieu de

   if (expensiveFunction() || counter < X)
   

5. Boxe

   void M<T>(T o) //avoids boxing
   {
   
   }
   

   au lieu de

   void M(object o)
   {
   
   }
   

Si vous me demandez si cela présente des avantages notables en termes de performances, je dirais non. Mais je suggérerais qu'on devrait les utiliser parce que cela découle d'une compréhension du comportement de ces constructions. Pourquoi faire deux appels alors que vous ne pouvez en faire qu'un? D'un point de vue philosophique, c'est une bonne pratique de codage. Et 1 & 3 sont également un peu moins lisibles au sens strict, mais ont-ils une valeur supérieure à la lisibilité? Non, pas beaucoup, alors je l'utilise. C’est la clé: maintenir un rapport performance / lisibilité décent. Et quand c'est ça, c'est à propos de l'endroit où vous tracez la ligne.

"Worth it" a besoin d'un contexte, comme la simplicité d'écriture, de lecture et de maintenance par rapport à la rapidité avec laquelle il rend quelque chose nettement plus réactif à l' utilisateur, plus interactif et nécessitant moins de temps d'attente.

Économiser quelques sous pour acheter une canette de soda ne me fera pas grand bien si je dois parcourir une certaine distance pour les économiser, d'autant plus que je bois rarement de soda de nos jours. Économiser quelques centimes par canette à l’achat d’un million de canettes de sodas pourrait être une grosse affaire.

En attendant, économiser quelques centimes quand deux personnes sont à côté de moi et que l'une offre exactement la même chose pour quelques centimes moins cher et l'autre pas, et j'ai choisi la plus chère parce que j'aime mieux que leur chapeau ressemble à un cas insensé de pessimisation.

Ce que je trouve souvent chez les gens qui appellent "micro-optimisations" semble être curieusement dépourvu de mesures, de contexte et de discussions entre utilisateurs, alors qu'il devrait être impératif que tous les trois envisagent de telles optimisations si elles ne sont pas faciles à appliquer. Pour moi, une micro-optimisation appropriée de nos jours concerne des choses telles que la disposition de la mémoire et les modèles d'accès, et bien qu'elles puissent sembler "micro" focalisées, elles ne le sont pas.

Il n’ya pas si longtemps, j’ai réussi à réduire une opération de 24 secondes à 25 millisecondes (environ 960 fois plus rapide), avec des sorties identiques (sécurisées par des tests automatisés), sans modification de la complexité algorithmique, pour le skinning par diffusion de chaleur volumétrique, à travers des "micro-optimisations" (dont la plus importante a été causée par une modification de la structure de la mémoire qui a réduit le délai à environ 2 secondes, puis les autres tâches ont consisté à SIMD, à une analyse plus poussée des erreurs de cache dans VTune et à un réaménagement de la disposition de la mémoire).

Wolfire explique la technique ici, et il a lutté avec le temps requis: http://blog.wolfire.com/2009/11/volumetric-heat-diffusion-skinning/

Mon implémentation a réussi à être capable de le faire en millisecondes alors qu'il luttait pour le réduire à moins d'une minute:

Après avoir «optimisé micro» le temps passé de 24 secondes à 25 ms, cela a changé la donne en termes de flux de travail. Désormais, les artistes peuvent changer de plate-forme en temps réel à plus de 30 images par seconde sans attendre 24 secondes à chaque fois qu’ils modifient légèrement leur plate-forme. Et cela a en fait changé la conception de mon logiciel puisque je n'avais plus besoin de barre de progression et que des choses de ce genre étaient devenues interactives. Donc, cela pourrait être une "micro-optimisation" dans le sens où toutes les améliorations ont été apportées sans aucune amélioration de la complexité algorithmique, mais c'était plutôt une "méga-optimisation" qui a rendu ce qui était auparavant un processus douloureux et non interactif en temps réel et interactif, ce qui a complètement changé le mode de travail des utilisateurs.

Mesure, besoins de l'utilisateur, contexte

J'ai vraiment aimé le commentaire de Robert ici et peut-être que j'ai échoué à faire le point que je voulais:

Eh bien, allez. Personne ne dira que ce genre de changement n'en vaut pas la peine. Vous avez pu démontrer un avantage tangible; beaucoup de micro-optimisations ne peuvent pas.

C’est, même si je travaille dans un domaine très critique en termes de performances avec des exigences souvent en temps réel, le seul moment où je considère toute micro-optimisation qui nécessite de sortir de mon chemin.

Et j'insisterais non seulement sur les mesures, mais sur le côté utilisateur. Je suis curieux de savoir que je suis arrivé dans mon domaine actuel (et anciennement gamedev) en tant qu'utilisateur / fan, puis développeur. Je n’ai donc jamais été aussi enthousiasmé par les choses habituelles qui excitent les programmeurs comme résoudre des énigmes techniques; Je les ai trouvés un fardeau, mais je les supporterais à travers le rêve utilisateur que je partageais avec d'autres utilisateurs. Mais cela m'a aidé à m'assurer que si j'optimisais quelque chose, cela aurait un impact réel sur les utilisateurs avec des avantages réels. C'est ma protection contre la micro-optimisation sans but.

C’est aussi important que le profileur à mon avis, car j’avais des collègues qui micro-optimisent la subdivision d’un cube en un milliard de facettes uniquement pour s’étouffer avec des modèles de production réels tels que des personnages et des véhicules. Leur résultat était impressionnant au sens de "démo technologique", mais presque inutile pour les utilisateurs réels, car ils profilaient, mesuraient et comparaient les cas qui ne correspondaient pas aux cas d'utilisation réels. Il est donc primordial de comprendre en premier lieu ce qui est important pour les utilisateurs, soit en apprenant à penser et à utiliser le logiciel comme un logiciel, soit en collaborant avec eux (idéalement, les deux, au moins, en leur collaborant).

Je vais le dire ainsi: la micro-optimisation est un processus d'optimisation de quelque chose qui n'est pas du tout un goulot d'étranglement. Par exemple, si votre programme appelle deux fonctions A et B et que A prend 100 millisecondes à compléter et que B prend 2 microsecondes, et que vous continuez d’optimiser la fonction B. C’est non seulement non important, mais il est tout à fait faux. Mais l'optimisation de la fonction B s'appelle optimisation et non micro-optimisation. L'importance de l'optimisation dépend. Supposons que vous n’ayez plus rien à faire et que votre programme soit exempt de bogues, alors oui, c’est important. Mais généralement, vous avez des priorités. Supposons que vous deviez ajouter / écrire la fonction C. Si vous pensez que l'écriture de la fonction C vous rapportera plus d'argent que de rendre votre programme plus rapide sans cette fonctionnalité, optez pour l'optimisation. Sinon poursuivre la fonctionnalité. Aussi, les programmeurs expérimentés qui se concentrent sur les performances ne passent pas beaucoup de temps à optimiser, ils écrivent simplement des programmes rapides. Au moins, ils savent quels outils utiliser et quoi faire pour ne pas passer des années à optimiser (lire des micro) optimisations.