Malheureusement, ce tutoriel qui était en bêta a été supprimé par son auteur.
J’en avais parlé, il est à présent de retour… mon cours d’introduction à l’assembleur x86(_64) est à nouveau disponible à la lecture sur ce site. Pour ceux qui n’auraient pas suivi la première mouture de la bête (et sachant que l’ancien sujet de bêta a été supprimé quand j’ai supprimé le tuto), voici un petit résumé.
Du vieux…
Je trouve que la plupart, si ce n’est la totalité, des cours sur l’assembleur x86 que l’on peut trouver sur Internet ou en livre sont nuls à chier. Ouais, je balance les SCUD directement… Il y a plusieurs raisons à cela.
La première, c’est que ces cours commencent généralement par enseigner le mode réel (16 bits), et souvent ne vont pas plus loin. Problème : cela fait bien depuis 1995 que le mode réel est considéré comme obsolète. Sur les systèmes d’exploitation récents, qui fonctionnent en mode 64 bits, il est même généralement impossible de faire tourner des programmes en mode réel, et il faut recourir à des émulateurs.
De mon côté, j’attaque directement par de l’assembleur 64 bits, pleinement intégré dans un système d’exploitation, et ce n’est que plus tard dans l’apprentissage qu’on pourra, éventuellement, revenir vers les autres modes de fonctionnement, voire se passer de système d’exploitation, tout à la fin.
La seconde, c’est qu’ils enseignent l’assembleur comme si c’était quelque chose de théorique et éthéré : il n’y a quasiment aucune mise en pratique, et les cours se contentent d’accumuler des dizaines et des dizaines de notions les unes à la suite des autres.
On m’a récemment renvoyé vers le cours en bêta sur OCR, et c’est exactement ça : il faut attendre le septième chapitre pour avoir un Hello World. Le premier livre avec lequel j’ai appris l’assembleur ne m’avait toujours pas enseigné comment afficher un simple texte à l’écran après plus de 250 pages de lecture. Et je pourrais continuer les exemples ainsi…
Je suis pour ma part persuadé que l’aspect rébarbatif et difficilement accessible de l’assembleur est en partie dû à cette approche. J’ai donc fait le choix d’amener aussi vite que possible à la pratique, avec un TP dès le quatrième chapitre, et des chapitres organisés non par thèmes (« les registres ») mais en fonction des outils nécessaires pour atteindre l’objectif suivant de mise en pratique.
Pour le reste, c’est un cours pour débutants. Je ne pars pas du principe que le lecteur connaît le C ou quelque autre langage de programmation, seulement qu’il a lu le cours d’intro à la programmation, et qu’il est un peu familier de son système d’exploitation.
… et du neuf !
Pour autant, il y a eu quelques changements plus ou moins importants par rapport à la dernière fois.
Tout d’abord, maintenant que le cours d’introduction à la programmation existe, j’ai un peu nettoyé le chapitre d’introduction, de manière à ne pas faire trop de redites.
Ensuite, et c’est certainement le changement le plus important : j’ai abandonné l’idée de me limiter à Linux. Je me suis dit que l’essentiel du cours concerne l’assembleur lui-même, et pas les appels systèmes, et qu’il serait dommage que les windowsiens ou applistes passent à côté pour une bête question d’OS.
Après quelques recherches, il s’avère que, OS X ayant la bonne idée d’être un BSD, les appels systèmes y sont quasiment identiques que sous Linux, et de même sous tous les BSD et sous Solaris. Seul Windows ne fait rien comme tout le monde, mais j’ai réussi à trouver des solutions, avec Wine et autres combines, pour pouvoir contourner le problème et tester quand même les programmes.
C’est donc un cours totalement multiplate-forme que je vous offre cette fois, même si dans un premier temps, Windows sera un peu laissé de côté, le temps d’acquérir les notions nécessaires à comprendre comment fonctionne son système d’appels système.
Enfin, le plan a été un peu revu. On a déjà discuté avec un certain nombre de gens de l’idée d’accélérer la validation des contenus, en publiant les gros contenus étape par étape, plutôt que d’un bloc quand tout est écrit, et en faisant participer les validateurs dès l’étape de la bêta, pour que la validation proprement dite ne soit plus qu’une formalité.
C’est pourquoi j’ai laissé tomber les parties sur le mode réel et le mode protégé, et adopté un plan de moyen-tuto : je basculerai sur un plan de big-tuto quand j’aurai suffisamment de chapitres pour le justifier.
J’ai par ailleurs bien conscience que 4 chapitres, c’est trop peu de contenu pour qu’il soit validé en l’état. Cependant, mon plan est fait de telle manière que ces quatre premiers chapitres fonctionnent ensemble, et que je ne les modifierai donc pas en rédigeant les suivants.
J’invite donc cordialement un validateur à me donner d’ores et déjà le feu vert sur ces premiers chapitres, lorsque les retours de la bêta se seront taris, bien sûr, afin de ne pas avoir à repasser dessus quand j’aurai écrit les chapitres suivants.
Et sur ces bonnes et longues paroles, je vous laisse à votre lecture.
