Pourquoi le jeu d’instructions 6502 convient bien comme premier langage d’assemblage

• L’assembleur étant directement lié à l’architecture du CPU, le premier sujet d’apprentissage compte beaucoup ; le 6502 est une plateforme d’initiation qui combine une structure simple et un véritable écosystème
• Avec seulement 6 registres et 56 instructions d’origine, on peut assimiler rapidement les concepts de base comme les registres, le chargement/stockage, les opérations logiques et arithmétiques, et les branchements
• Comme il s’agit d’un vrai CPU utilisé dans l’Apple II, le Commodore VIC 20, le Commodore 64, le BBC micro, etc., il est facile de mener un apprentissage par la pratique avec des émulateurs, des machines recréées et des ressources gratuites
• Easy 6502 fournit un assembleur et un simulateur en JavaScript directement utilisables sur le Web, ce qui permet de se faire une idée en peu de temps
• Le Z80, les RISC modernes et x86-x64 valent aussi la peine d’être appris, mais pour une première étape, le 6502, moins complexe, réduit la charge d’apprentissage

---

Pourquoi le 6502 convient bien aux débutants

• La programmation en assembleur a un lien avec le matériel plus fort que les langages de haut niveau ; le premier CPU que l’on aborde influence donc fortement la difficulté d’apprentissage
• L’assembleur 6502 n’est pas aujourd’hui un environnement confortable pour écrire des applications professionnelles
  • Si la programmation rétro elle-même ne vous intéresse pas, il n’est pas nécessaire de rester longtemps sur le 6502
• Ses atouts comme plateforme d’initiation sont sa simplicité et son existence concrète
  • Sa structure simple permet d’assimiler rapidement les concepts de base
  • Les vraies machines, émulateurs, livres et ressources en ligne sont nombreux, ce qui facilite la construction d’un parcours d’apprentissage

• Registres et instructions restent peu nombreux

  • Le 6502 ne compte que 6 registres
    • 1 accumulateur
    • 2 registres d’index
    • registre d’état
    • registre de pile
    • compteur ordinal
  • Le seul registre 16 bits du 6502 est le compteur ordinal
  • Le faible nombre de registres est une contrainte pour écrire de vraies applications, mais aide à comprendre le rôle et le fonctionnement des registres
  • Le jeu d’instructions 6502 d’origine ne contient que 56 instructions
  • Même avec ce petit ensemble d’instructions, on peut apprendre les principaux types d’instructions
    • chargement/stockage
    • opérations logiques
    • opérations arithmétiques
    • branchements
  • Ces catégories existent encore, sous une forme ou une autre, dans les CPU modernes
  • Avec x86-x64, il n’est déjà pas simple de compter le nombre de registres et d’instructions, et même les jeux d’instructions RISC modernes comme ARM ne peuvent pas vraiment être considérés comme petits et simples

Écosystème réel et autres options

• Un écosystème ancien, mais toujours vivant

  • Le 6502 a été introduit au milieu des années 1970 par MOS Technology comme une version moins chère et simplifiée du Motorola 6800
    • La même équipe avait auparavant développé le Motorola 6800
  • Il est ensuite rapidement devenu populaire et a été utilisé dans plusieurs micro-ordinateurs célèbres
    • Apple II
    • Commodore VIC 20
    • Commodore 64
    • BBC micro
  • Les émulateurs de ces machines sont faciles à trouver, et certaines disposent aussi de recréations modernes
  • Des successeurs du 6502 sont encore produits au moment de la rédaction, et de nouvelles machines comme le Neo6502 d’Olimex exécutent aussi des dérivés du 6502
  • Les ressources d’apprentissage gratuites sont nombreuses sur Internet, et une grande partie se trouve sur 6502.org

• Des ressources pour pratiquer immédiatement

  • Easy 6502 est un livre électronique de Nick Morgan, adapté aux apprenants qui veulent découvrir brièvement le 6502
  • Outre du texte et des images, il inclut un assembleur et un simulateur 6502 écrits en JavaScript
    • On peut écrire directement du code assembleur 6502 simple dans la page Web
  • Visual6502.org est moins un outil d’apprentissage de l’assembleur qu’une ressource qui montre visuellement la simplicité du 6502

• Différences avec d’autres candidats pour débuter

  • Les CPU virtuels conçus pour l’enseignement peuvent avoir un jeu d’instructions propre et « parfait », mais il leur est difficile d’égaler le 6502 en richesse de ressources pédagogiques et de communauté
  • Les CPU rétro comme le Z80, le 6809 et le 68000 sont aussi de bons choix
    • Ces trois CPU sont considérés comme meilleurs que le 6502 pour une programmation sérieuse
    • Pour apprendre les concepts de base, la simplicité du 6502 est plus avantageuse
  • Le Z80 possède beaucoup plus de registres que le 6502 et dispose aussi d’un jeu de registres alternatif, ce qui le rend moins facile pour commencer
  • Les architectures RISC modernes comme ARM, MIPS et RISC-V sont des sujets qu’un programmeur assembleur sérieux devra apprendre à un moment donné
    • Elles ne sont toutefois pas idéales pour débuter
    • Leur simplicité relève davantage de l’implémentation interne de la puce que du jeu d’instructions
  • Les microprocesseurs modernes sont pour la plupart programmés en langages de haut niveau, et l’expérience consistant à écrire directement des instructions assembleur n’est pas une priorité majeure dans la conception des CPU
  • Sur ARM64, charger une constante 64 bits dans un registre peut nécessiter 4 instructions, avec des décalages de bits
    • Sur 6502, le processus de chargement d’une constante dans un registre est plus simple en comparaison
  • x86-x64 peut être considéré comme le jeu d’instructions le plus répandu sur les postes de travail et serveurs modernes, tandis qu’ARM est en train de le rattraper
    • Sans contrainte de taille 32 bits, et avec des instructions riches au nombre d’opérandes variable, il peut à certains égards être plus facile à coder qu’ARM
    • Mais il reste très complexe pour les débutants, et 40 ans d’histoire n’ont pas rendu x86-x64 plus simple

[GN⁺]

Avis sur Hacker News

• J’ai du mal à être d’accord avec l’idée que la simplicité du 6502 serait préférable à celle du 68000
  Le 68000 a plus de registres et des largeurs de types plus importantes, mais sa structure est régulière. En pratique, il y a deux familles, A et D, répétées sous forme de D0 à D7 et A0 à A7, donc ce qu’on peut faire avec D0 est aussi possible avec D3. La simplicité de la structure doit être équilibrée avec la simplicité de programmation, et avec le 6502, dès qu’on écrit un programme un peu complexe, on se heurte sans cesse à ses contraintes
  La meilleure façon d’apprendre à contourner les limites d’une petite machine consiste plutôt à ignorer ces limites et à devenir un ingénieur logiciel expérimenté. Pour un débutant, il vaut mieux commencer avec quelque chose qui offre davantage de modes d’adressage, facilite la manipulation de grands tableaux, et propose des registres ainsi que des largeurs d’entiers confortables

  • Point de vue proche, mais différent. Au cours des dernières décennies, j’ai surtout travaillé avec le 6502, le 68k, le z80 et le x86/64 dans le domaine de la démo, et je me suis même demandé si cet article n’avait pas été écrit par une IA
    L’article affirme que le 6502 est simple parce qu’il a six registres, mais après seulement une semaine passée à manipuler le 6502, on comprend qu’en pratique on travaille avec trois registres. C’est aussi ce qui lui a valu le surnom de CPU à sémaphores
    Le 6502 est amusant et élégant, mais il ne convient pas si l’on cherche une approche moderne. Si l’on veut suivre la voie glorieuse façon années 90, mieux vaut commencer par MIPS, ou tout simplement par Neon. On peut aussi considérer que le Z80, avec ses registres et sa complexité, ressemble davantage à ce qu’on rencontre aujourd’hui
    L’assembleur moderne n’est pas intrinsèquement complexe. Commencer avec FASM n’est pas difficile, mais l’approche bas niveau devient toujours rapidement compliquée. On finit alors par créer des macros, puis par ajouter sa propre sorte de C du pauvre
  • Apprendre à contourner les limites d’une petite machine est une bonne étape pour devenir un ingénieur logiciel/matériel expérimenté
    L’avantage des petits systèmes, c’est qu’on peut en comprendre entièrement l’ensemble, du silicium au système d’exploitation en passant par le logiciel
    Le 6809 est plus simple que le 68K, plus puissant que le 6502 et assez orthogonal, mais il ne dispose pas du même socle logiciel. À mon avis, Motorola avait pris une assez bonne direction avec les jeux d’instructions et l’architecture vue par le programmeur du 6809 et du 68K. Je me souviens que les PDP-11/VAX et NS32K étaient aussi relativement orthogonaux
  • Le 6502 est un meilleur assembleur de jouet que le Z80, mais ce n’est pas dire grand-chose. Il est aussi difficile de le considérer comme clairement meilleur que le jeu d’instructions AVR 8 bits
    Si l’on pense à des plateformes plus modernes, enseigner RISC-V plutôt que MC68k est nettement plus convaincant. Si l’on ne considère que le jeu d’instructions entier de base, RISC-V est très simple et élégant, tout en ressemblant aux architectures modernes comme ARM, Aarch-64 ou MIPS. Il existe en 32 bits et en 64 bits, et la documentation officielle est facile d’accès
    Le MC68k comporte trop de particularités qui ne sont plus vraiment pertinentes aujourd’hui. Ses avantages sont d’avoir été utilisé sur plusieurs plateformes matérielles et de disposer encore d’une communauté rétro active, mais cela relève surtout de l’intérêt historique plutôt que d’une pertinence réelle
  • Le 68K est lui aussi un peu pénible à cause de son bus 24 bits, de ses contraintes d’alignement et de son support ambigu de l’indexation de tableaux. L’absence de facteur d’échelle est également gênante
    Le 68020 est probablement ce qui se rapproche le plus d’une architecture de jeu d’instructions pensée pour être proche du C, et il est très agréable à utiliser
  • J’ai appris à programmer sur 6510, mais je suis d’accord pour dire que le jeu d’instructions du 68000 était bien meilleur, et plus facile à lire et à apprendre. Moi aussi, je choisirais le 68000
    Cela dit, utiliser les 65XX sur les premiers ordinateurs Commodore était très gratifiant. Comme il n’y avait pas de protection mémoire, on pouvait modifier directement la mémoire vidéo, toucher aux sprites, aux polices, aux bordures et aux interruptions, et même écrire du code automodifiant. L’assembleur 68000 sur Amiga offrait un environnement plus sûr et plus contrôlé

• À mon avis, le 6502 n’est pas un bon premier jeu d’instructions pour apprendre l’assembleur. On finit par passer beaucoup de temps à gérer les particularités d’une architecture ingénieuse, mais profondément imparfaite.
  Ces idiomes de contournement ne se transposent pas très bien à de meilleures architectures qui n’étaient pas contraintes par les outils et le budget dont disposait MOS à l’époque.
  Si vous voulez apprendre un jeu d’instructions petit mais puissant, avec quelques particularités, ARM v6M est un meilleur choix. Il est encore produit de manière significative aujourd’hui, et les chaînes d’outils open source modernes offrent un bon support côté débogueur, compilateur, assembleur et linker.
  Si l’ouverture de l’architecture vous importe et que vous pouvez accepter une plateforme encore moins mature, choisissez un MCU RISC-V. Si vous n’arrivez pas à trancher, prenez un RP2350.
  Le jeu d’instructions ARMv6M est petit, et le chargement de constantes, si l’on utilise le chargement relatif au PC comme le documente l’architecture, ne nécessite pas de longues suites d’instructions fastidieuses. Il n’y a pas non plus besoin de code auto-modifiant ni d’indexer la mémoire via une page zéro, et la largeur des registres est la même que celle de l’espace d’adressage. Le fait que ce soit du 32 bits le rend même plus facile à apprendre et à enseigner que la plupart des jeux d’instructions 8/16 bits. Si cela paraît ennuyeux, pas d’inquiétude : ARMv6 a aussi assez de particularités pour faire du code golf.

  • J’aime l’architecture 6502, mais si un débutant intéressé par les anciens ordinateurs n’a aucune expérience préalable en assembleur, je l’oriente généralement ailleurs.
    J’ai commencé avec l’assembleur PIC16 et j’ai touché un peu à plusieurs architectures, mais en matière de propreté, c’est MIPS32 qui m’a le plus plu.
    Petit complément : on peut encore acheter des 6502 nouvellement fabriqués par Western Design Center, ainsi que des MCU à cœur 6502 et des puces périphériques. On en trouve aussi chez des distributeurs comme Mouser.
    https://www.mouser.com/c/?m=Western%20Design%20Center%20%28W...
  • J’ai beaucoup écrit en assembleur 6502 à une époque, et on passe pas mal de temps à composer avec une architecture 8 bits.
    Rien que multiplier deux nombres 16 bits demande déjà un bon bloc de code. Je ne vois pas trop l’intérêt de faire lutter un nouveau programmeur avec ce genre de choses.
    Comme indiqué, les premiers jeux d’instructions ARM sont un bon choix.
  • ARM aussi a quelques points douloureux pour les débutants, à cause de la manière dont les valeurs immédiates sont encodées dans les instructions. Il peut être peu intuitif de comprendre pourquoi certaines valeurs immédiates ou certains offsets sont acceptés et d’autres non.
    Bien sûr, c’est un problème que l’on retrouve dans plusieurs langages assembleur, mais pour commencer, j’aimerais bien partir d’un jeu d’instructions qui n’a pas ce souci.
  • Je n’arrive même pas vraiment à deviner ce que « profondément imparfaite » est censé désigner.
  • Cela me fait sans cesse penser à la série de Ben Eater sur le 65C02 sur breadboard[1]. Y aurait-il un moyen de reproduire ce qu’il fait dans ces vidéos avec un CPU ARM ?
    [1] https://youtube.com/playlist?list=PLowKtXNTBypFbtuVMUVXNR0z1...

• Pour avoir enseigné l’assembleur pendant plusieurs années à des étudiants de licence, je suis d’accord pour dire que le 6502 est bien adapté aux débutants. Mais ce n’est pas seulement dû aux qualités du langage 6502 lui-même.
  J’ai enseigné le 68K, MIPS, ARM, x86, etc., et la principale raison pour laquelle les étudiants ont bien réagi quand j’ai enseigné le 6502 tenait au contexte autour du CPU. Avec le 6502, nous programmions une vraie machine facile à comprendre : la Nintendo Entertainment System.
  Entrées/sorties élémentaires mappées en mémoire, pas de système d’exploitation, pas d’instructions pipelinées, pas de delay slots, pas de réseau, pas de bruit inutile. C’est presque une simple boîte avec, à l’intérieur, une horloge, un CPU, quelques adresses mémoire, des puces auxiliaires et des E/S mappées sur des adresses mémoire. Le 6502 n’est pas le jeu d’instructions le plus simple, mais cette simplicité du système aide énormément.
  Les contraintes du 6502 étaient aussi importantes pour aider les étudiants à comprendre pourquoi les instructions ont cette forme. Le CPU a été conçu et câblé dans les contraintes de l’époque, et cela se reflète dans la manière de le programmer.
  Choisir le 6502 et la NES pour enseigner aux débutants a été un succès. Pas tant parce que c’était le 6502, mais parce que le 6502 obligeait à rendre simple le système même qui déplace les bits.
  Une fois que les étudiants avaient manipulé le 6502 et vu des tuiles NES bouger à l’écran, il devenait naturel d’élargir vers la manière différente dont le 68000 traite les choses, l’apparition de MIPS, l’exploitation du pipelining et des delay slots, ou la comparaison entre RISC et CISC. Avec les bases, la progression devient très simple.

• Si l’objectif n’est pas d’apprendre un jeu d’instructions encore utilisé aujourd’hui, je suis un peu surpris que l’assembleur PDP-11 soit si rarement cité comme bon point de départ.
  C’est peut-être parce que le PDP-11 est le premier que j’ai vraiment appris, mais tous les premiers microprocesseurs m’ont donné l’impression d’un pas en arrière. J’ai bien utilisé l’assembleur Z80 pendant plusieurs années, mais je ne le recommanderais pas aujourd’hui. Son jeu d’instructions n’est pas orthogonal, et le 6502 a trop peu de registres pour vraiment donner de bonnes sensations d’écriture en assembleur.

  • De nos jours, il est assez difficile de se procurer un PDP-11, et obtenir un système d’exploitation, des compilateurs, etc., n’est pas évident non plus.
    Si vous aimez le PDP-11, le MSP430 offre des qualités similaires sous une forme un peu limitée, et le 68000 sous une forme un peu renforcée.
    Mais en réalité, le mieux est d’oublier ces reliques et d’apprendre RISC-V. Ou alors de choisir l’une des nombreuses variantes d’Arm. Personnellement, j’ai un attachement sentimental pour l’ARM7TDMI, que j’ai beaucoup utilisé au milieu des années 2000. Le mode Thumb est peut-être un peu plus facile à apprendre que le mode Arm d’origine, mais aucun des deux n’est aussi satisfaisant que RISC-V.
  • D’accord. Le PDP-11 est tellement plus agréable qu’il n’y a pas vraiment de comparaison.
    On peut soutenir que ses modes d’adressage sont conceptuellement plus complexes que ceux de RISC, mais en pratique, les modes d’adressage du 6502 risquent fort d’être plus difficiles à comprendre que ceux du PDP-11.
  • Apprendre l’assembleur PDP-11 permet aussi de comprendre pourquoi certains idiomes du C existent. Par exemple, les pointeurs de pointeurs correspondent directement à un mode d’adressage natif de l’architecture.
  • Le jeu d’instructions du -11 est un chef-d’œuvre d’ingénierie. DEC avait tout ce qu’il fallait pour dominer complètement le marché des micro-ordinateurs.
    Mais DEC a ignoré cette occasion, et IBM a pris la place avec le pesant jeu d’instructions 8086.
    Il n’y a désormais plus de raison d’apprendre le -11.

• Je ne vois pas bien comment on arrive à cette conclusion. Quand des étudiants découvrent la programmation informatique, il peut être logique de commencer par un langage jouet/petit langage sans usage réel. Mais l’assembleur ne devrait pas être le premier langage appris
  L’assembleur est un outil très pratique, généralement beaucoup utilisé pour le débogage et la rétro-ingénierie. Alors pourquoi consacrer du temps à l’assembleur d’une plateforme disparue depuis longtemps ?
  La meilleure façon d’apprendre l’assembleur, c’est l’expérimentation. On peut écrire du code dans son langage préféré et regarder la sortie assembleur intermédiaire, ou explorer l’intérieur avec objdump ou gdb. On peut aussi modifier des choses et voir ce qui se passe
  C’est possible aussi avec des émulateurs d’anciens ordinateurs, mais c’est plus difficile. Même pour afficher un simple texte à l’écran, il faut apprendre l’architecture de cette machine, son matériel et les fonctions de sa ROM, et ces connaissances ne s’appliquent presque pas à Linux ou Windows sur x86-64

  • J’ai eu du mal à comprendre C, puis la voie s’est ouverte quand j’ai appris l’hexadécimal et la programmation assembleur sur 68HC11
    Pour un débutant complet, des concepts comme les pointeurs sont trop abstraits et obscurs, mais quand j’ai appris l’adressage indirect en assembleur, il est soudain devenu clair pourquoi C a des pointeurs et comment ils fonctionnent
    Avant, j’utilisais surtout Python, qui était bien plus abstrait. Les gens oublient souvent que des fonctionnalités comme les pointeurs existent à cause de contraintes matérielles et de performance. Si l’on ne sait pas ce que fait réellement le CPU en interne, et pourquoi, la compréhension intuitive reste limitée
  • Après quelques mois à manipuler du matériel et à programmer en assembleur, on comprend le fonctionnement de base de l’ordinateur d’une façon complètement différente de celle des langages de haut niveau
    Je n’ai pas écrit une seule ligne d’assembleur depuis le lycée, mais grâce à cette compréhension fondamentale de l’exécution des opérations et du fonctionnement des registres, il m’est devenu beaucoup plus facile de comprendre les raisons, conditions et exceptions liées à la programmation et à l’optimisation. J’apprécie aussi davantage le code propre et efficace
  • Même à dix ans, nous nous en sommes plutôt bien sortis avec ça comme deuxième langage après une bande dessinée sur la programmation BASIC
    Si vous voulez goûter un peu au passé, c’est ici
    https://www.atariarchives.org/
  • Il y a grosso modo deux façons d’apprendre la programmation. L’approche descendante, qui part de concepts abstraits pour aller vers l’implémentation réelle, par exemple SICP, et l’approche ascendante, qui commence par du code bas niveau concret et laisse les abstractions émerger naturellement
    Comme j’ai étudié l’électronique, j’ai naturellement commencé par l’assembleur (Motorola HC11). À la fin du cours, tout le monde avait créé indépendamment des macros pour des choses comme les boucles for, et le passage à C s’est fait naturellement. À la fin du cours de C, l’orienté objet façon C est apparu tout aussi naturellement, menant au cours suivant en C++
    L’inconvénient de cette approche, c’est qu’elle n’offre pas de chemin progressif vers le paradigme fonctionnel ou, plus généralement, les paradigmes non impératifs. Elle donne aussi l’habitude de toujours réfléchir à la façon dont le langage fonctionne en interne, ce qui peut parfois être contre-productif. Quand j’ai essayé d’apprendre Haskell, mon esprit voulait d’abord comprendre le fonctionnement de l’interpréteur
    Apprendre l’assembleur, ce n’est pas seulement apprendre un langage, c’est comprendre comment fonctionne la machine : bus, périphériques à mappage mémoire, etc. Sur les anciennes plateformes, cette partie est beaucoup plus simple. Ainsi, même si les instructions ARM sont plus faciles à apprendre que les instructions CISC du HC11, tout le reste est plus accueillant pour un débutant du côté du HC11
  • Dans le compilateur dmd, compiler avec -vasm affiche l’assembleur généré pendant la compilation. Certains ont jugé ça peu utile en disant qu’on pouvait utiliser objdump ou -S, mais quand on l’essaie soi-même, on comprend pourquoi c’est pratique. Cela affiche directement l’assembleur seul, sans l’énorme code passe-partout nécessaire pour créer un fichier objet
    Par exemple, si l’on travaille sur un générateur de code AArch64, plus précisément sur la génération de code en virgule flottante, et qu’on a cette fonction
    float test(float a, float b) { return a * b; }
    En compilant avec dmd -c test.c -arm -vasm, on obtient les adresses, les instructions hexadécimales, les mnémoniques des instructions et les URL des spécifications des instructions
    Je sais que le code n’est pas parfaitement correct. J’ai dit que c’était encore en cours :-)

• Pour moi, le jeu d’instructions 6502 a été un bon premier langage assembleur
  En 1977, je vivais dans une petite cabane dans l’Oregon et, pour m’occuper, j’ai acheté un Apple II. En moins d’un an, je me suis retrouvé à travailler sur le programme qui allait devenir Apple Writer, entièrement écrit en assembleur
  https://en.wikipedia.org/wiki/Apple_Writer
  Ici, on dit que l’assembleur 6502 est assez fruste et difficile à écrire, et avec le recul je suis d’accord. Mais en 1977, je n’avais aucun point de comparaison
  Comme l’Apple II n’avait pas de langage de haut niveau rapide, mon petit programme est devenu un produit Apple faute d’alternative
  Quand on y pense, Apple Writer tenait dans 8 Ko de RAM, mais il faisait réellement le travail. Il avait même un langage de macros que les gens utilisaient pour traiter des listes d’adresses
  Récemment, pour faire tourner DeepSeek plus facilement en local, j’ai porté mon système principal à 96 Go de RAM, et j’ai aussi une RTX 4090. Je me suis soudain rendu compte qu’avec cette quantité de RAM, on pourrait y mettre près de 12 millions d’Apple Writer
  C’est assez surréaliste, mais depuis 1977, j’ai eu plusieurs occasions de dire ce genre de chose

• Comme langage assembleur de départ, je préfère RISC-V. Sa conception est bonne et plus intuitive, il bénéficie du support de langages et d’outils modernes comme GCC, LLVM et Rust, et il fonctionne dans QEMU ainsi que sur du matériel réellement disponible à l’achat

  • ARMv7 remplit aussi ces critères et il est agréable à utiliser. On peut l’utiliser en inline dans BBC Basic sur Acorn Archimedes
  • La dernière fois que j’ai vérifié, RISC-V n’avait pas encore de macro-assembleur digne de ce nom
  • Pour ce qui est du « matériel réellement disponible à l’achat », la dernière fois que j’ai vérifié, le 65C02 était encore fabriqué et vendu
    Il peut même fonctionner à pas moins de 14 MHz

• Le thème de la simplicité du jeu d’instructions 6502 me hérisse personnellement. Les gens qui pensent que cette simplicité est une bonne chose donnent l’impression de ne jamais être allés au-delà de Hello World.
  Programmer quelque chose de moyennement complexe en 6502 est difficile. Le 8 bits est beaucoup trop limité, par exemple rien qu’en regardant l’adressage de l’écran du Commodore 64. Il faut implémenter soi-même la multiplication et la division, et même l’addition/soustraction sur 16 bits, bien que simples, ne sont jamais triviales si l’on veut les faire efficacement.
  Si l’objectif est d’apprendre les bases de l’assembleur, la plateforme 8086+DOS est, en comparaison, bien plus facile à prendre en main.

  • Dans le contexte d’un premier contact avec l’assembleur, devoir implémenter soi-même la multiplication/division est au contraire une bonne chose.
    Porter divers algorithmes de multiplication et de division en assembleur est une très bonne façon d’apprendre.
  • Les contraintes font partie du plaisir. L’assembleur 8086 n’est pas aussi amusant.
    De toute façon, si l’on veut apprendre quelque chose qui n’est pas pertinent aujourd’hui — ni x86-64, ni RISC-V, ni ARM — je ne vois pas très bien quel est l’avantage du 8086.
  • L’assembleur que j’ai le plus écrit est probablement du 8086, plus précisément du 80286 en mode réel.
    J’en ai aimé chaque instant, et même les registres de segment ne m’ont pas vraiment dérangé.

• Je suis dans une école technique orientée informatique, et un professeur d’informatique qui aime le rétro et adore montrer sa borne d’arcade a préféré se concentrer sur le 6502 au lieu de l’assembleur 8808 prévu au programme.
  Honnêtement, ça a été l’une des meilleures expériences d’apprentissage de ma vie, et je ne voudrais pas que cela se soit passé autrement. Il nous a même fait construire l’ordinateur sur breadboard de Ben Eater, ce qui donnait un côté particulièrement concret et vraiment passionnant.

• Mon premier contact avec le langage assembleur a été sur PDP-10, et je n’avais rien d’autre que le manuel du processeur DEC-10.
  J’étais complètement perdu. Il y avait des centaines d’instructions et les explications étaient opaques. Je ne savais absolument pas ce qu’étaient un registre, un accumulateur, une adresse ou une pile. David Rolfe m’a un peu aidé en écrivant quelques sous-routines nécessaires pour ma version Fortran d’Empire, mais j’étais encore dans le brouillard.
  Un jour, j’ai demandé à mon ami Shal Farley ce qu’était une pile, et il m’a répondu : « Imagine une pile d’assiettes. Tu poses une assiette dessus (push), puis tu en retires une (pop). » À cet instant, la lumière s’est faite et j’ai compris.
  Ensuite, j’ai commencé à travailler avec un microprocesseur 6800 sur une petite carte. Il y avait une quarantaine d’instructions, qui tenaient toutes sur une seule fiche. Ces 40 instructions étaient faciles à apprendre, et soudain tout est devenu clair.
  Quand je suis revenu au manuel du -10, tout a commencé à avoir du sens.