Problème — Un ordinateur à programme enregistré, en Python

1. La machine. Le cycle tient en une dizaine de lignes : c'est exactement le schéma de l'architecture à programme enregistré.

def executer(memoire):
    acc = 0          # accumulateur
    co = 0           # compteur ordinal
    while True:
        instruction = memoire[co]
        code = instruction // 100
        adresse = instruction % 100
        co = co + 1                      # on avance AVANT d'executer
        if code == 0:
            return memoire
        elif code == 1:
            acc = memoire[adresse]
        elif code == 2:
            memoire[adresse] = acc
        elif code == 3:
            acc = acc + memoire[adresse]
        elif code == 4:
            acc = acc - memoire[adresse]
        elif code == 5:
            co = adresse
        elif code == 6:
            if acc > 0:
                co = adresse

Le programme s'écrit directement en nombres, puisque c'est ainsi qu'il est rangé :

memoire = [0] * 100
memoire[0] = 121   # CHARGE 21          acc <- somme
memoire[1] = 320   # AJOUTE 20          acc <- somme + n
memoire[2] = 221   # RANGE 21           somme <- acc
memoire[3] = 120   # CHARGE 20          acc <- n
memoire[4] = 422   # SOUSTRAIT 22       acc <- n - 1
memoire[5] = 220   # RANGE 20           n <- acc
memoire[6] = 600   # SAUTE_SI_POSITIF 0 si n > 0, on recommence
memoire[7] = 0     # STOP
memoire[20] = 5    # n
memoire[21] = 0    # somme
memoire[22] = 1    # la constante 1

executer(memoire)
print(memoire[21])   # affiche 15

2. Déroulé. En co = 0, l'instruction vaut $121$ : code $1$, adresse $21$, donc acc $\leftarrow$ memoire[21] $=0$. En co = 1, l'instruction $320$ donne acc $\leftarrow 0+5=5$. En co = 2, l'instruction $221$ range $5$ dans la case $21$. Les instructions $3$ à $5$ décrémentent le compteur rangé en case $20$, et l'instruction $6$ renvoie l'exécution en $0$ tant qu'il reste positif.

3. Résultat. La case $21$ contient successivement $5$, $9$, $12$, $14$, puis $15$ : c'est bien $5+4+3+2+1=\text{15}$, la case $20$ valant alors $0$.

4. Un programme qui se modifie lui-même. Puisque les instructions sont des nombres rangés en mémoire, rien n'interdit de les manipuler :

memoire[30] = 1
# CHARGE 0 ; AJOUTE 30 ; RANGE 0
# l'instruction 121 (CHARGE 21) devient 122 (CHARGE 22)

Cette possibilité découle directement du choix de 1945 : une seule mémoire pour les instructions et les données. C'est elle qui rend possibles les compilateurs, les interpréteurs et les systèmes d'exploitation — un programme qui en fabrique ou en lance un autre. Très employée dans les années 1950 faute de mémoire, on l'évite aujourd'hui : un programme qui se réécrit est illisible, impossible à tester, et c'est le mécanisme même de nombreuses attaques informatiques — les systèmes modernes marquent d'ailleurs les zones de code comme non modifiables. La leçon est générale : la puissance d'un mécanisme et sa dangerosité ont souvent la même origine.