<!--
  canonical-url: https://www.avonture.be/fr/blog/docker-assembly
  published:     2023-11-30
  This is a static plain-Markdown mirror generated at build time.
  Visit the canonical URL above for the fully rendered page, with images and interactive components.
-->

# Jouer avec Docker et le langage Assembleur

> Apprenez à combiner la technologie Docker moderne avec le classique langage Assembleur x86. Ce guide propose un exemple « Hello, World! » pas à pas pour les environnements MS-DOS et Linux.

---
![Jouer avec Docker et le langage Assembleur](/img/v2/experiments.webp)

**TL;DR**

Cet article réveille la nostalgie de l'Assembleur x86 des années 90 en assemblant et en exécutant un fichier `.asm` « Hello, World! » sans aucune installation locale, grâce à l'image Docker `esolang/x86asm-nasm`, depuis une console DOS/PowerShell (`%CD%`) comme depuis Linux (`${PWD}`).

Quand j'étais plus jeune qu'aujourd'hui, pendant mes études, je jouais avec le langage Assembleur x86 sur mon ordinateur `386DX40` ; c'était dans les années 1993-1995. Les débuts de Windows 3.1, que je n'aimais pas. *Si on m'avait demandé si les interfaces graphiques allaient avoir du succès, j'aurais dit non, bien sûr que non.*

Je me souviens avoir écrit un programme résident (TSR, pour **T**erminate and **S**tay **R**esident) qui, une fois chargé en mémoire, surveillait le clavier et enregistrait les touches pressées dans un fichier sur le disque dur. Oui, c'était un voleur de mots de passe. Juste pour le fun et, surtout, pour le défi.

Et maintenant, en 2023, je me demandais s'il était encore possible d'exécuter des fichiers `.asm` sur mon ordinateur. C'était une excellente raison pour écrire cet article.

*Le même voyage nostalgique, un langage plus tard : [Play with Docker and Pascal](/blog/docker-pascal), où je compile des sources Turbo Pascal que j'ai publiées il y a trente ans.*

En cherchant sur [Docker Hub](https://hub.docker.com/), j'ai trouvé cette image : <https://hub.docker.com/r/esolang/x86asm-nasm>

## Jouons sous MS-DOS {#lets-play-in-ms-dos}

Testons notre image Docker sous DOS cette fois. Démarrez une console **DOS** et lancez `mkdir C:\tmp\assembly && cd C:\tmp\assembly` pour créer un dossier appelé `assembly` dans votre environnement DOS et y entrer.

Créez un nouveau fichier appelé `Hello.asm` avec ce contenu :

**Hello.asm**

```asm
; Our data section (i.e. our variables)
SECTION .data
    ; Our null terminated string
    hello: db 'Hello, World! This message comes from Docker.', 0

; Our entry point
SECTION .text
    global _start

_start:
    mov edx, 45    ; 45 is the length of our "hello" message
    mov ecx, hello ; The name of our variable is "hello"
    mov ebx, 1     ; We'll write to stdout
    mov eax, 4     ; System call number (sys_write)
    int 0x80       ; Triggers software interrupt 80

    mov ebx, 0     ; Next three lines are equivalent to exit 0
    mov eax, 1
    int 0x80
```

Pour exécuter le script, il suffit d'appeler Docker, comme ceci :

```bash
$ docker run --rm -v %CD%:/code -w /code esolang/x86asm-nasm x86asm-nasm hello.asm
Hello, World! This message comes from Docker.
```

> **Bien sûr, vous pouvez jouer sous Linux:**
>
> Remplacez simplement `%CD%` par `${PWD}` et l'instruction sera reconnue par Linux : `docker run --rm -v ${PWD}:/code -w /code esolang/x86asm-nasm x86asm-nasm hello.asm`

Même idée, autre langage : j'ai aussi joué avec [Pascal](/blog/docker-pascal), [Python](/blog/docker-python) et [Java](/blog/docker-java) avec cette même approche Docker « zéro installation locale ».
