Pourquoi programmez-vous en assemblage?
J'ai une question pour tous les hackers hardcore de bas niveau. J'ai croisé cette phrase dans un blog. Je ne pense pas vraiment que la source compte (c'est Haack si vous vous souciez vraiment) car cela semble être une déclaration commune.
Par exemple, de nombreux jeux 3D modernes ont leur moteur principal haute performance écrit en C++ et Assembly.
En ce qui concerne l'assembly - le code est-il écrit dans l'assembly parce que vous ne voulez pas qu'un compilateur émette des instructions supplémentaires ou utilise des octets excessifs, ou utilisez-vous de meilleurs algorithmes que vous ne pouvez pas exprimer en C (ou ne pouvez pas exprimer sans le compilateur les remue)?
Je comprends parfaitement qu'il est important de comprendre les choses de bas niveau. Je veux juste comprendre le programme pourquoi dans Assembly après l'avoir compris.
Je pense que vous avez mal interprété cette déclaration:
Par exemple, de nombreux jeux 3D modernes ont leur moteur de base haute performance écrit en C++ et Assembly.
Les jeux (et la plupart des programmes de nos jours) ne sont pas "écrits en Assembly" de la même manière qu'ils sont "écrits en C++". Ce blog ne dit pas qu'une partie importante du jeu est conçue dans Assembly, ou qu'une équipe de programmeurs s'assoit et se développe dans Assembly comme langue principale.
Ce que cela signifie vraiment, c'est que les développeurs écrivent d'abord le jeu et le font fonctionner en C++. Ensuite, ils le profilent, découvrent quels sont les goulots d'étranglement, et si cela en vaut la peine, ils optimisent le diable d'eux dans l'Assemblée. Ou, s'ils sont déjà expérimentés, ils savent quelles parties vont être des goulots d'étranglement, et ils ont des pièces optimisées provenant d'autres jeux qu'ils ont construits.
Le point de la programmation dans Assembly est le même qu'il l'a toujours été: vitesse . Il serait ridicule d'écrire un lot de code dans l'assembleur, mais il y a quelques optimisations dont le compilateur n'a pas connaissance, et pour une fenêtre de code suffisamment petite, un humain va faire mieux.
Par exemple, pour les virgules flottantes, les compilateurs ont tendance à être assez conservateurs et peuvent ne pas être au courant de certaines des fonctionnalités les plus avancées de votre architecture. Si vous êtes prêt à accepter une erreur, vous pouvez généralement faire mieux que le compilateur, et cela vaut la peine d'écrire ce peu de code dans Assembly si vous trouvez que beaucoup de temps est consacré à celui-ci.
Voici quelques exemples plus pertinents:
Exemples de jeux
Article d'Intel sur l'optimisation d'un moteur de jeu en utilisant SSE intrinsèques. Le code final utilise des intrinsèques (pas l'assembleur en ligne), donc la quantité d'assemblage pur est très petite. Mais ils regardent la sortie de l'assembleur par le compilateur pour déterminer exactement ce qu'il faut optimiser.
Quake's racine carrée inverse rapide . Encore une fois, la routine ne contient pas d'assembleur, mais vous devez savoir quelque chose sur l'architecture pour effectuer ce type d'optimisation. Les auteurs savent quelles opérations sont rapides (multiplication, décalage) et lesquelles sont lentes (division, sqrt). Ils proposent donc une implémentation très délicate de la racine carrée qui évite complètement les opérations lentes.
Calcul haute performance
En dehors du domaine des jeux, les gens de l'informatique scientifique optimisent fréquemment la merde des choses pour les faire fonctionner rapidement sur le dernier matériel. Considérez cela comme des jeux où vous ne pouvez pas tromper la physique.
Un excellent exemple récent de ceci est Lattice Quantum Chromodynamics (Lattice QCD) . Cet article décrit comment le problème se résume à un très petit noyau de calcul, qui a été fortement optimisé pour PowerPC 440 sur un IBM Blue Gene/L . Chaque 440 possède deux FPU et prend en charge certaines opérations ternaires spéciales difficiles à exploiter pour les compilateurs. Sans ces optimisations, Lattice QCD aurait fonctionné beaucoup plus lentement, ce qui est coûteux lorsque votre problème nécessite des millions d'heures de processeur sur des machines coûteuses.
Si vous vous demandez pourquoi c'est important, consultez article dans Science qui est ressorti de ce travail. En utilisant Lattice QCD, ces gars-là ont calculé la masse d'un proton à partir des premiers principes et ont montré l'année dernière que 90% de la masse provenait d'une forte énergie de liaison de force, et le reste de quarks. C'est E = mc2 en action. Voici un résumé .
Pour tout ce qui précède, les applications ne sont pas conçues ou écrites à 100% dans Assembly - même pas fermées. Mais lorsque les gens ont vraiment besoin de vitesse, ils se concentrent sur l'écriture des éléments clés de leur code pour voler sur du matériel spécifique.
Je n'ai pas codé en langage assembleur depuis de nombreuses années, mais je peux donner plusieurs raisons que j'ai souvent vues:
Tous les compilateurs ne peuvent pas utiliser certaines optimisations de processeur et jeu d'instructions (par exemple, les nouveaux jeux d'instructions qu'Intel ajoute de temps en temps). Attendre que les rédacteurs du compilateur rattrapent signifie perdre un avantage concurrentiel.
Associez plus facilement le code réel à l'architecture et à l'optimisation du processeur connues. Par exemple, ce que vous savez sur le mécanisme de récupération, la mise en cache, etc. Ceci est censé être transparent pour le développeur, mais le fait est que ce n'est pas le cas, c'est pourquoi les rédacteurs du compilateur peuvent optimiser.
Certains accès au niveau matériel sont uniquement possibles/pratiques via le langage d'assemblage (par exemple, lors de l'écriture du pilote de périphérique).
Le raisonnement formel est parfois en fait plus facile pour le langage d'assemblage que pour le langage de haut niveau, car vous savez déjà quelle est la disposition finale ou presque finale du code.
La programmation de certaines cartes graphiques 3D (vers la fin des années 1990) en l'absence d'API était souvent plus pratique et efficace dans le langage d'assemblage, et parfois impossible dans d'autres langues. Mais encore une fois, cela impliquait des jeux de niveau vraiment expert basés sur l'architecture d'accélérateur, comme le déplacement et l'entrée de données manuellement dans un certain ordre.
Je doute que beaucoup de gens utilisent le langage d'assemblage quand un langage de niveau supérieur le ferait, en particulier lorsque ce langage est C. L'optimisation manuelle de grandes quantités de code à usage général n'est pas pratique.
Il y a un aspect de la programmation des assembleurs que d'autres n'ont pas mentionné - le sentiment de satisfaction que vous obtenez en sachant que chaque octet dans une application est le résultat de vos propres efforts, pas ceux du compilateur. Je ne voudrais pas une seconde revenir à l'écriture d'applications entières dans l'assembleur comme je le faisais au début des années 80, mais ce sentiment me manque parfois ...
Habituellement, l'assemblage d'un profane est plus lent que C (en raison de l'optimisation de C), mais de nombreux jeux (je me souviens distinctement Doom ) devaient avoir des sections spécifiques du jeu dans l'assemblage afin qu'il fonctionne correctement sur les machines normales.
J'ai commencé la programmation professionnelle en langue d'assemblage dans mon tout premier travail (80's). Pour les systèmes embarqués, les besoins en mémoire - RAM et EPROM - étaient faibles. Vous pouviez écrire du code serré qui était facile sur les ressources.
À la fin des années 80, j'étais passé en C. Le code était plus facile à écrire, à déboguer et à maintenir. De très petits extraits de code ont été écrits dans l'assembleur - pour moi, c'était quand j'écrivais le changement de contexte dans un RTOS roll-your-own. (Quelque chose que vous ne devriez plus faire à moins qu'il ne s'agisse d'un "projet scientifique".)
Vous verrez des extraits d'assembleur dans du code de noyau Linux. Plus récemment, je l'ai parcouru dans les verrous tournants et autres codes de synchronisation. Ces morceaux de code doivent avoir accès aux opérations atomiques de test et de configuration, à la manipulation des caches, etc.
Je pense que vous auriez du mal à optimiser les compilateurs C modernes pour la plupart des programmes généraux.
Je suis d'accord avec @altCognito que votre temps est probablement mieux consacré à réfléchir plus sérieusement au problème et à mieux faire les choses. Pour une raison quelconque, les programmeurs se concentrent souvent sur les micro-efficacités et négligent les macro-efficacités. Le langage d'assemblage pour améliorer les performances est une micro-efficacité. Prendre du recul pour une vue plus large du système peut exposer les problèmes de macro dans un système. La résolution des problèmes macroéconomiques peut souvent entraîner de meilleurs gains de performances. Une fois les problèmes macro résolus, effondrez-vous au niveau micro.
Je suppose que les micro-problèmes sont sous le contrôle d'un seul programmeur et dans un domaine plus petit. La modification du comportement au niveau macro nécessite une communication avec plus de personnes - une chose que certains programmeurs évitent. Tout ce cow-boy contre l'équipe.
"Oui". Mais, comprenez que pour la plupart, les avantages de l'écriture de code dans l'assembleur ne valent pas la peine. Le retour reçu pour l'écrire dans Assembly a tendance à être plus petit que le simple fait de se concentrer davantage sur le problème et de passer son temps à réfléchir à une meilleure façon de faire les choses.
John Carmack et Michael Abrash, qui étaient en grande partie responsables de l'écriture de Quake et de tout le code haute performance qui est entré dans les moteurs de jeu ID, expliquent cela en détail dans ce livre .
Je conviendrais également avec Ólafur Waage qu'aujourd'hui, les compilateurs sont assez intelligents et utilisent souvent de nombreuses techniques qui tirent parti des améliorations architecturales cachées.
De nos jours, pour les codes séquentiels au moins, un compilateur décent bat presque toujours même un programmeur en langage assembleur très expérimenté. Mais pour les codes vectoriels, c'est une autre histoire. Les compilateurs largement déployés ne font pas un excellent travail en exploitant les capacités vectorielles parallèles de l'unité x86 SSE, par exemple. Je suis rédacteur de compilateur et exploitant SSE en tête de ma liste de raisons d'aller seul au lieu de faire confiance au compilateur.
Le code SSE fonctionne mieux dans Assembly que les éléments intrinsèques du compilateur, au moins dans MSVC. (c.-à-d. ne crée pas de copies supplémentaires des données)
Les défauts ont tendance à s'exécuter par ligne (instruction, point de code, etc.); S'il est vrai que pour la plupart des problèmes, Assembly utiliserait beaucoup plus de lignes que les langages de niveau supérieur, il y a parfois des cas où c'est la meilleure (la plus concise, le moins de lignes) qui correspond au problème en question. La plupart de ces cas impliquent les suspects habituels, tels que les pilotes et les coups dans les systèmes embarqués.
Certaines instructions/drapeaux/contrôles ne sont tout simplement pas là au niveau C.
Par exemple, la vérification du débordement sur x86 est l'indicateur de débordement simple. Cette option n'est pas disponible en C.
J'ai trois ou quatre routines d'assembleur (source d'environ 20 Mo) dans mes sources au travail. Tous sont SSE (2) , et sont liés aux opérations sur des images (assez grandes - pensez à 2400x2048 et plus grandes).
Pour les loisirs, je travaille sur un compilateur, et là vous avez plus d'assembleur. Les bibliothèques d'exécution en sont souvent remplies, la plupart d'entre elles ont à voir avec des choses qui défient le régime procédural normal (comme les aides pour les exceptions, etc.)
Je n'ai pas d'assembleur pour mon microcontrôleur. La plupart des microcontrôleurs modernes ont tellement de matériel périphérique (compteurs contrôlés par interruption, même entiers codeur en quadrature s et blocs de construction série) que l'utilisation d'assembleur pour optimiser les boucles n'est souvent plus nécessaire. Avec les prix flash actuels, il en va de même pour la mémoire de code. Il existe également souvent des gammes d'appareils compatibles avec les broches, donc la mise à l'échelle si vous manquez systématiquement d'alimentation CPU ou d'espace flash n'est souvent pas un problème
Sauf si vous expédiez vraiment 100000 appareils et que l'assembleur de programmation permet de faire de réelles économies en insérant simplement dans une puce flash une catégorie plus petite. Mais je ne fais pas partie de cette catégorie.
Beaucoup de gens pensent que l'intégration est une excuse pour l'assembleur, mais leurs contrôleurs ont plus de puissance CPU que les machines nix a été développé. (Microchip fourni avec 40 et 60 MIPS microcontrôleurs pour sous USD 10).
Cependant, beaucoup de gens sont coincés avec l'héritage, car changer l'architecture de la puce électronique n'est pas facile. Le code HLL dépend également de l'architecture (car il utilise la périphérie matérielle, les registres pour contrôler les E/S, etc.). Il y a donc parfois de bonnes raisons de continuer à maintenir un projet en assembleur (j'ai eu la chance de pouvoir configurer les affaires sur une nouvelle architecture à partir de zéro). Mais souvent, les gens se disent qu'ils ont vraiment besoin de l'assembleur.
J'aime toujours la réponse donnée par un professeur lorsque nous avons demandé si nous pouvions utiliser GOTO (mais vous pouvez aussi le lire comme ASSEMBLER): "si vous pensez que cela vaut la peine d'écrire un essai de 3 pages sur les raisons vous avez besoin de la fonctionnalité, vous pouvez l'utiliser. Veuillez soumettre l'essai avec vos résultats. "
Je l'ai utilisé comme principe directeur pour les fonctionnalités de bas niveau. Ne soyez pas trop à l'étroit pour l'utiliser, mais assurez-vous de le motiver correctement. Jetez même une barrière artificielle ou deux (comme l'essai) pour éviter le raisonnement alambiqué comme justification.
Une autre raison pourrait être que le compilateur disponible n'est tout simplement pas assez bon pour une architecture et que la quantité de code nécessaire dans le programme n'est pas aussi longue ou complexe que pour que le programmeur s'y perde. Essayez de programmer un microcontrôleur pour un système embarqué, généralement l'assemblage sera beaucoup plus facile.
Outre les autres choses mentionnées, toutes les langues supérieures ont certaines limites. C'est pourquoi certaines personnes choisissent de programmer en ASM, pour avoir un contrôle total sur leur code.
D'autres bénéficient de très petits exécutables, dans la plage de 20 à 60 Ko, par exemple, vérifiez HiEditor , qui est implémenté par l'auteur du contrôle HiEdit, superbe contrôle d'édition puissant pour Windows avec mise en évidence de la syntaxe et onglets en seulement ~ 50 Ko). Dans ma collection, j'ai plus de 20 de ces contrôles d'or d'Excell comme des feuilles de calcul aux rendus html.
Je pense que beaucoup de développeurs de jeux seraient surpris de cette information.
La plupart des jeux que je connais utilisent le moins d'assemblage possible. Dans certains cas, pas du tout, et au pire, une ou deux boucles ou fonctions.
Cette citation est trop généralisée et loin d'être aussi vraie qu'elle l'était il y a dix ans.
Mais bon, de simples faits ne devraient pas entraver une véritable croisade de hackers en faveur de l'Assemblée. ;)
Si vous programmez un microcontrôleur 8 bits bas de gamme avec 128 octets de RAM et 4K de mémoire de programme, vous n'avez pas beaucoup le choix d'utiliser Assembly. Parfois, cependant, lorsque vous utilisez un microcontrôleur plus puissant, vous avez besoin une certaine action doit avoir lieu à un moment précis. Le langage d'assemblage est alors utile car vous pouvez compter les instructions et mesurer ainsi les cycles d'horloge utilisés par votre code.
La dernière fois que j'ai écrit dans l'assembleur, je n'ai pas réussi à convaincre le compilateur de générer du code indépendant de la position et sans libc.
La prochaine fois, ce sera probablement pour la même raison.
Bien sûr, j'avais autrefois raisons .
Mis à part de très petits projets sur de très petits processeurs, je ne voudrais pas programmer un projet entier dans Assembly. Cependant, il est courant de constater qu'un goulot d'étranglement des performances peut être atténué avec le codage manuel stratégique de certaines boucles internes.
Dans certains cas, tout ce qui est vraiment nécessaire est de remplacer une construction de langage par une instruction que l'optimiseur ne peut pas s'attendre à comprendre comment utiliser. Un exemple typique est dans les applications DSP où les opérations vectorielles et les opérations de multiplication-accumulation sont difficiles à découvrir pour un optimiseur, mais faciles à manipuler.
Par exemple, certains modèles du SH4 contiennent une matrice 4x4 et 4 instructions vectorielles. J'ai vu une amélioration des performances énorme dans un algorithme de correction des couleurs en remplaçant les opérations C équivalentes sur une matrice 3x3 par les instructions appropriées, au moindre coût d'agrandissement de la matrice de correction à 4x4 pour correspondre à l'hypothèse matérielle. Cela a été réalisé en écrivant pas plus d'une douzaine de lignes d'assemblage et en effectuant des ajustements correspondants aux types de données associés et au stockage dans une poignée d'endroits dans le code C environnant.
Le seul codeur assembleur que je continue de faire est pour le matériel embarqué avec peu de ressources. Comme le mentionne Leander, Assembly est toujours bien adapté aux ISR s où le code doit être rapide et bien compris.
Une raison secondaire pour moi est de garder ma connaissance de l'Assemblée fonctionnelle. Être en mesure d'examiner et de comprendre les étapes que le processeur prend pour faire mes enchères est tout simplement agréable.
Les jeux sont assez gourmands en performances et bien qu'entre-temps les optimiseurs soient plutôt bons, un "maître programmeur" est toujours en mesure d'extraire des performances supplémentaires en codant à la main les bonnes pièces dans Assembly.
Ne commencez jamais à optimiser votre programme sans le profiler au préalable. Après que le profilage devrait être capable d'identifier les goulots d'étranglement et si trouver de meilleurs algorithmes et autres ne le coupe plus, vous pouvez essayer de coder manuellement certaines choses dans Assembly.
Presque tous les moteurs ou bibliothèques de jeux de taille moyenne à grande que j'ai vus à ce jour ont des versions d'assemblage optimisées à la main disponibles pour les opérations matricielles comme la concaténation matricielle 4x4. Il semble que les compilateurs manquent inévitablement certaines des optimisations intelligentes (réutilisation des registres, déroulement des boucles d'une manière maximale efficace, profitant des instructions spécifiques à la machine, etc.) lorsqu'ils travaillent avec de grandes matrices. Ces fonctions de manipulation de matrice sont presque toujours des "points chauds" sur le profil également.
J'ai également vu un assemblage codé à la main utilisé beaucoup pour la répartition personnalisée - des choses comme FastDelegate, mais spécifiques au compilateur et à la machine.
Enfin, si vous avez des routines de service d'interruption, asm peut faire toute la différence dans le monde - il y a certaines opérations que vous ne voulez tout simplement pas avoir lieu sous interruption, et vous voulez que vos gestionnaires d'interruptions "entrent et sortent rapidement". .. vous savez presque exactement ce qui va se passer dans votre ISR s'il est en asm, et cela vous encourage à garder les choses sanglantes courtes (ce qui est de toute façon une bonne pratique).
Beaucoup de gens adorent dénigrer le langage d'assemblage car ils n'ont jamais appris à coder avec lui et ne l'ont que vaguement rencontré et cela les a laissés soit consternés, soit quelque peu intimidés. Les vrais programmeurs talentueux comprendront qu'il est insensé de bash C ou Assembly car ils sont complémentaires. en fait l'avantage de l'un est le désavantage de l'autre. Les règles syntaxiques organisées de C améliorent la clarté mais renoncent en même temps à toute la puissance de l'Assemblée d'être libre de toute règle structurelle! Des instructions de code C sont faites pour créer un code non bloquant qui pourrait être soutenu force la clarté de l'intention de programmation mais c'est une perte de puissance. En C, le compilateur ne permettra pas un saut à l'intérieur d'un if/elseif/else/end. Ou vous n'êtes pas autorisé à écrire deux boucles for/end sur différentes variables qui se chevauchent, vous ne pouvez pas écrire de code auto-modifiant (ou ne peut pas d'une manière simple et transparente), etc. Les programmeurs conventionnels sont effrayés par ce qui précède, et auraient aucune idée comment même utiliser le pouvoir de ces approches car elles ont été soulevées pour suivre les règles conventionnelles. Voici la vérité: nous avons aujourd'hui une machine avec la puissance de calcul pour faire bien plus que l'application pour laquelle nous les utilisons, mais le cerveau humain est trop incapable de les coder dans un environnement de codage sans règles (= Assembly) et a besoin de règles restrictives qui réduire le spectre et simplifie le codage. J'ai moi-même écrit du code qui ne peut pas être écrit en code C sans devenir extrêmement inefficace en raison des limitations mentionnées ci-dessus. Et je n'ai pas encore parlé de vitesse que la plupart des gens pensent être la principale raison d'écrire dans Assembly, eh bien c'est si votre esprit se limite à penser en C, alors vous êtes l'esclave de votre compilateur pour toujours. J'ai toujours pensé que les maîtres des joueurs d'échecs seraient des programmeurs d'assemblage idéaux tandis que les programmeurs C jouent juste "Dames".
Cela ne semble pas être mentionné, alors j'ai pensé l'ajouter: dans le développement de jeux modernes, je pense qu'au moins une partie de l'assemblage en cours d'écriture n'est pas du tout pour le CPU. C'est pour le GPU, sous la forme de programmes de shader .
Cela peut être nécessaire pour toutes sortes de raisons, parfois simplement parce que le langage d'ombrage de niveau supérieur utilisé ne permet pas d'exprimer l'opération exacte dans le nombre exact d'instructions souhaité, pour s'adapter à certaines contraintes de taille, vitesse ou toute combinaison . Comme d'habitude avec la programmation en langage assembleur, je suppose.
Je n'ai parlé personnellement qu'à un développeur de son utilisation d'Assembly. Il travaillait sur le firmware qui traitait les commandes d'un lecteur mp3 portable. Faire le travail à l'Assemblée avait deux objectifs:
- Vitesse: les retards devaient être minimes.
- Coût: en étant minimal avec le code, le matériel nécessaire à son exécution pourrait être légèrement moins puissant. Lors de la production en masse de millions d'unités, cela peut s'additionner.
Si vous étiez là pour tous les efforts de correction de l'an 2000, vous auriez pu gagner beaucoup d'argent si vous connaissiez Assembly. Il y a encore beaucoup de code hérité qui a été écrit dedans, et ce code a parfois besoin de maintenance.
Plus de vitesse, mais Contrôle. La vitesse viendra parfois du contrôle, mais c'est le seule raison à coder dans Assembly. Toutes les autres raisons se résument au contrôle (c'est-à-dire SSE et autre optimisation manuelle, pilotes de périphérique et code dépendant du périphérique, etc.).
J'ai une fois repris un projet DSP que le programmeur précédent avait écrit principalement en code assembleur, à l'exception de la logique de détection de tonalité qui avait été écrite en C, en virgule flottante (sur un DSP à virgule fixe!). La logique de détection de tonalité a fonctionné à environ 1/20 du temps réel.
J'ai fini par réécrire presque tout à partir de zéro. Presque tout était en C, à l'exception de quelques petits gestionnaires d'interruptions et de quelques dizaines de lignes de code liées à la gestion des interruptions et à la détection de fréquence de bas niveau, qui s'exécutent plus de 100 fois plus vite que l'ancien code.
Une chose importante à garder à l'esprit, je pense, est que dans de nombreux cas, il y aura des possibilités beaucoup plus grandes d'amélioration de la vitesse avec de petites routines que de grandes, surtout si l'assembleur écrit à la main peut tout contenir dans les registres, mais un compilateur ne le ferait pas gérer assez. Si une boucle est suffisamment grande pour ne pas pouvoir tout garder dans les registres de toute façon, il y a beaucoup moins de possibilités d'amélioration.
Je n'ai pas écrit à l'Assemblée depuis quelques années, mais les deux raisons pour lesquelles j'étais:
- Le défi de la chose! Je suis passé par une période de plusieurs mois il y a des années quand j'écrivais tout en assemblage x86 (les jours de DOS et Windows 3.1). Il m'a essentiellement appris un bloc d'opérations de bas niveau, de matériel I/O , etc.
- Pour certaines choses, il a gardé une petite taille (encore une fois DOS et Windows 3.1 lors de l'écriture TSR s)
Je continue à regarder le codage de l'Assemblée à nouveau, et ce n'est rien de plus que le défi et la joie de la chose. Je n'ai aucune autre raison de le faire :-)
Si je suis capable de surperformer GCC et Visual C++ 2008 (également connu sous le nom de Visual C++ 9.0), alors les gens seront intéressés à m'interroger sur la façon dont c'est possible.
C'est pourquoi pour le moment je viens de lire des choses dans Assembly et d'écrire simplement __asm int 3 lorsque cela est nécessaire.
J'espère que cette aide ...
Le Dalvik VM qui interprète le bytecode pour Java applications sur Android utilisent l'assembleur pour le répartiteur. Ce film (environ 31 minutes, mais ça vaut le coup de regarder tout le film!) explique comment
"il y a encore des cas où un humain peut faire mieux qu'un compilateur".
Je ne le fais pas, mais je me suis fait un devoir d'essayer au moins, et d'essayer fort à un moment donné dans l'avenir (bientôt avec un peu de chance). Ce ne peut pas être une mauvaise chose de mieux connaître les choses de bas niveau et comment les choses fonctionnent en arrière-plan lorsque je programme dans un langage de haut niveau. Malheureusement, le temps est difficile à trouver avec un emploi à temps plein en tant que développeur/consultant et parent. Mais je donnerai au rendez-vous en temps voulu, c'est sûr.