OpenLLM-France/wikimedia huggingface dataset:
# Italien/Vocabulaire/Alimentation
## Repas

| français | italien |
| le petit déjeuner | la colazione |
| le déjeuner | il pranzo |
| le goûter | la merenda |
| le dîner | la cena |

## Menu

| français | italien |
| entrée | antipasto |
| premier plat | primo |
| second plat | secondo |
| dessert | dolci |

## Viande et poisson

| français | italien |
| la viande | la carne |
| le bœuf | il manzo |
| le poisson | il pesce |
| les fruits de mer | i frutti di mare |

## Légumes

| français | italien |
| les légumes | la verdura |
| la tomate | il pomodoro |
| la carotte | la carota |
| le céleri | il sedano |
| l'aubergine | la melanzana |
| le potiron, la courge | la zucca |
| la courgette | la zucchina (o il zucchino) |
| le radis | il ravanello |
| l'oignon | la cipolla |
| les épinards | gli spinaci |
| l'ail | l'aglio |
| le persil | il prezzemolo |
| la salade | l'insalata |
| la laitue | la lattuga |
| le chou | il cavolo |
| le chou-fleur | il cavolfiore |
| le chou de Bruxelles | il cavoletti di Bruxelles |
| le haricot | il fagiolo |
| le navet | il navone |
| la betterave | la barbabietola |
| le panais | il pastinaca |
| la pomme de terre | la patata |
| le poivron | il peperone |
| le concombre | il cetriolo |
| le cornichon | il cetriolino |
| le brocoli | il broccolo |
| l'asperge | l'asparago |

## Céréales

| français | italien |
| le blé | il grano |
| le maïs | il mais |
| le riz | il riso |

## Fruits

| français | italien |
| un fruit | la frutta |
| la banane | la banana |
| la pêche | la pesca |
| l'abricot | l'albicocca |
| la cerise | la ciliegia |
| la cerise noire | l'amarena |
| le cassis | il ribes nero |
| la poire | la pera |
| la pomme | la mela |
| la fraise | la fragola |
| l'orange | l'arancia |
| le citron | il lemone |
| le pamplemousse | il pompelmo |
| la mandarine | il mandarino |
| la clémentine | la clementina |
| l'ananas | l'ananas |
| le raisin | l'uva |
| la myrtille | il mirtillo |
| la framboise | il lampone |
| le melon | il melone |
| la pastèque | l'anguria (o il cocomero) |
| la noix | la noce |
| la noisette | la nocciola |
| la noix de coco | la noce di cocco |
| la figue | il fico |
| l'avocat | l'avocado |
| la grenade | il melagrana |
| le kiwi | il kiwi |
| la groseille | la ribes |

## Aliments de base

| français | italien |
| le pain | il pane |
| un œuf | un uovo |

## Lait et produit laitiers

| français | italien |
| le lait | il latte |
| un yaourt | uno yogurt |
| le beurre | il burro |
| le fromage | il formaggio |
| Sommaire | Anatomie et santé |
# Italien/Vocabulaire/Animaux
## Les animaux domestiques

| français | italien |
| un chien | un cane |
| un chat | un gatto |
| un oiseau | un uccello |
| un perroquet | un pappagallo |
| une perruche | una cocorita |
| un mouton | un montone |
| un agneau | un agnello |
| une brebis | una pecora |
| un bœuf | un bue |
| une vache | una mucca |
| un veau | un vitello |
| un cochon | un maiale |
| une truie | una troia, una scrofa |
| une poule | una gallina |
| un coq | un gallo |
| un poussin | un pulcino |
| un canard | un'anatra |
| une oie | un'oca |
| une pintade | una faraona |
| un dindon | un tacchino |
| une dinde | una tacchina |
| un dindonneau | un tacchinotto |

## Les animaux sauvages

| français | italien |
| une hirondelle | una rondine |
| un martinet | un rondone |
| une biche | una cerva |
| un cerf | un cervo |
| un renard | una volpe |
| un hibou | un gufo |
| une chouette | una civetta |
| un aigle | un' aquila |
| une mésange | una cincia |
| un lion | un leone |
| une lionne | una leonessa |
| une panthère | una pantera |
| un tigre | una tigre |
| une tigresse | una tigre |
| un éléphant | un elefante |
| une éléphante | un elefantessa |
| un hippopotame | un ippopotamo |
| un rhinocéros | un rinoceronte |
| une gazelle | una gazzella |
| un zèbre | una zebra |

## Les animaux marins

| français | italien |
| un poisson | un pesce |
| un manchot | un pinguino |
| un phoque | una foca |
| un ours blanc | un orso bianco |
| une mouette | un gabbiano |
| une baleine | una balena |
| un dauphin | un delfino |
| un requin | uno squalo |
| un hippocampe | un cavalluccio marino |
| un morse | un tricheco |
| Anatomie et santé | Nombres |
# Linguistique DMS/Mieux s'exprimer
## Afin de mieux exprimer notre pensée dans un langage

| Malsain | Infralingue |
# Linguistique DMS/Malsain
## Des pratiques malsaines

| Règles | Mieux s'exprimer |
# Linguistique DMS/Objectif
## Si l'objectif de la lecture est cognitif

| Signes et sens | Production |
# Linguistique DMS/Objectifs

De faire comprendre les paradoxes de la théorie de Ferdinand de Saussure qui entravent le développement actuel de la sémantique, qui est fondé sur un dogme non avéré, qui refuse à l'homme la liberté de penser, et qui fait croire qu'il est possible qu'une machine, un ordinateur, puisse penser comme un être humain.
# Linguistique DMS/Présentation de la leçon

Cette leçon présente une théorie linguistique non-saussurienne, qui respecte et qui tient compte de la nature et des contraintes du mental humain, en particulier de l'impossibilité de définir du sens collectif, le sens étant un quale, qui refuse certains concepts paradoxaux tels que signifié et mot qui ne sont que des fantasmes dans l'esprit de leurs créateurs. qui rejette certains présupposés comme de croire que le sens ne peut être directement perceptible (que font les animaux qui sont aussi des êtres de sens, que nous ne pourrions pas faire ?) et qu'il passe obligatoirement par des formes signifiantes, ce que contredisent les faits, et qui tente de dominer les problèmes actuels que pose le sens à la linguistique.
# Linguistique DMS/Règles
## Quelques règles à respecter

| Incohérences | Malsain |
# Linguistique DMS/Le signe
## Le signe

| Une Langue | Le référent |
# Linguistique DMS/Prérequis conseillés

Pas de pré-requis
# Complexes et géométrie/Devoir/Construction du pentagone régulier

On pose :
    $z_{0}=\operatorname {e} ^{\mathrm {i} {\frac {2\pi }{5}}}$.
1° On pose :
    $\alpha =z_{0}+z_{0}^{4}$ et $\beta =z_{0}^{2}+z_{0}^{3}$.
    a) Montrez que :
          $1+z_{0}+z_{0}^{2}+z_{0}^{3}+z_{0}^{4}=0$
       et déduisez-en que α et β sont solutions de l'équation :
          $X^{2}+X-1=0\qquad [1]$.
    b) Déterminez α en fonction de cos⁡ 2π/5 {\textstyle \cos {\frac {2\pi }{5}}}.
    c) Résolvez l'équation [1] et déduisez-en la valeur de cos⁡ 2π/5 {\textstyle \cos {\frac {2\pi }{5}}}.
2° On appelle $A_{0}$, $A_{1}$, $A_{2}$, $A_{3}$ et $A_{4}$ les points d'affixes respectives $1$, $z_{0}$, $z_{0}^{2}$, $z_{0}^{3}$ et $z_{0}^{4}$, dans le plan muni d'un repère orthonormal $(0;{\vec {u}},{\vec {v}})$.
    a) Soit $H$ le point d'intersection de la droite $(A_{1}A_{4})$ avec l'axe $(O;{\vec {u}})$. Montrez que :
          ${\overrightarrow {OH}}=\cos {\frac {2\pi }{5}}\,{\vec {u}}$.
    b) Le cercle dont le centre a pour affixe −1/2 {\textstyle -{\frac {1}{2}}} et qui passe par le point d'affixe $\mathrm {i}$ coupe $(O;{\vec {u}})$ en $M$ et $N$ (on note $M$ le point d'abscisse positive). Montrez que :
          ${\begin{cases}{\overrightarrow {OM}}=\alpha {\vec {u}}\\{\overrightarrow {ON}}=\beta {\vec {u}}\end{cases}}$
       et que $H$ est le milieu de $[OM]$.
    c) Déduisez-en une construction simple d'un pentagone régulier dont on connaît le centre $O$ et un sommet $A_{0}$.
1° a) $1+z_{0}+z_{0}^{2}+z_{0}^{3}+z_{0}^{4}={\frac {1-z_{0}^{5}}{1-z_{0}}}={\frac {0}{1-z_{0}}}=0$ donc $\alpha \beta =\alpha +\beta =-1$, c'est-à-dire que $\alpha$ et $\beta$ sont les deux solutions de l'équation [1].
    b) $z_{0}^{4}=z_{0}^{-1}={\overline {z_{0}}}$ donc $\alpha =2\cos {\frac {2\pi }{5}}$.
    c) Les deux solutions de [1] (de signes contraires) sont ${\frac {1\pm {\sqrt {5}}}{2}}$, or $0<{\frac {2\pi }{5}}<{\frac {\pi }{2}}$, donc $\cos {\frac {2\pi }{5}}={\frac {1+{\sqrt {5}}}{4}}$.
2° a) $\operatorname {Re} \left(A_{1}\right)=\operatorname {Re} \left(A_{4}\right)=\cos {\frac {2\pi }{5}}$.
    b) Les affixes de $M$ et $N$ sont les solutions de [1] car $\left(x+{\frac {1}{2}}\right)^{2}=\left|\mathrm {i} +{\frac {1}{2}}\right|^{2}\Leftrightarrow x^{2}+x+{\frac {1}{4}}={\frac {5}{4}}$. Ce sont donc bien $\alpha$ et $\beta$ et d'après a) et 1° b), $H$ est le milieu de $[OM]$.
    c) Tracer le cercle de centre $O$ et de rayon $[OA_{0}]$.
       Construire le milieu $\Omega$ du rayon opposé, et une extrémité $I$ du diamètre perpendiculaire.
       Tracer (partiellement) un second cercle, de centre $\Omega$ et passant par $I$, et noter $M$ son intersection avec la demi-droite $[OA)$.
       Construire les intersections $A_{1}$ et $A_{4}$ du premier cercle avec la médiatrice de $[OM]$.
       Placer $A_{2}$ et $A_{3}$ sur ce cercle, en reportant la longueur $A_{0}A_{1}=A_{0}A_{4}$ à partir des points $A_{1}$ et $A_{4}$.
| Étude d'une transformation | Étude d'une similitude indirecte |
# Compilation/Présentation de la leçon

Cette leçon présente la structure d'un compilateur ce qui comprends :
* l'analyse lexicale ;
* l'analyse syntaxique descendante et ascendante ;
* analyseurs LL(1), SLR (1), LR (1) et LALR (1) ;
* les grammaires attribuées et notion d'actions sémantiques ;
* le traitement des erreurs ;
* la gestion de la table des symboles ;
* la production de code intermédiaire ;
* l'optimisation de code ;
* la génération de code objet.
La leçon permettra d’aborder le développement d'un mini-compilateur en guise d'exercice avec les outils Lex et Yacc.
# Complexes et géométrie

| Chap. 1 : | Affixe d'un barycentre |
| Chap. 2 : | Utilisation des complexes en géométrie |
| Chap. 3 : | Détermination d'ensembles de points |
| Exos. 1 : | Nombres complexes et géométrie |
| Exos. 2 : | Écritures complexes de transformations |
| Exos. 3 : | Détermination de transformations |
| Exos. 4 : | Rotation |
| Exos. 5 : | Symétrie |
| Exos. 6 : | Similitude |
| Exos. 7 : | Étude de figures |
| Exos. 8 : | Suite de points |
| Exos. 9 : | Lieu géométrique |
| Exos. 10 : | Fonction complexe |
| Exos. 11 : | Pour les cracks |
| Devoir 1 : | Étude d'une transformation |
| Devoir 2 : | Construction du pentagone régulier |
| Devoir 3 : | Étude d'une similitude indirecte |
| Devoir 4 : | Un problème de géométrie |
Sur les autres projets Wikimedia :

## Présentation [Modifier]

L'utilisation des nombres complexes en géométrie est apparue tardivement vers 1̠800. Elle est due essentiellement à Jean-Robert Argand mais ne s'est imposée pleinement que sous l'autorité de Carl Friedrich Gauss. Cette leçon, d'un bon niveau car s'adressant à des sections scientifiques, expose les principales applications des complexes à la géométrie. Y seront étudiées quelques transformations classiques du plan comme les translations, homothéties, symétries et similitudes. Nous étudierons aussi l'affixe d'un barycentre ainsi que la représentation dans le plan complexe des solutions d'une équation d'inconnue complexe.

## Objectifs [Modifier]

* Écriture complexe d'une transformation.
* Lieu géométrique.
* Translation, Homothétie, rotation, symétrie, similitude.
* Étude sur des figures.

## Niveau et prérequis conseillés [Modifier]

Leçon de niveau 13.
* Calcul avec les nombres complexes

## Référents [Modifier]

Ces personnes sont prêtes à vous aider concernant cette leçon :
* Nicostella (discuter)
* Loïc Fabiou (discuter)
# Complexes et géométrie/Affixe d'un barycentre
## Isobarycentre de trois points

Soit G l’isobarycentre de trois points A, B et C du plan.
Soient $z_{G},z_{A},z_{B}$ et $z_{C}$ les affixes respectives de ces points.
Alors : $z_{G}={\frac {z_{A}+z_{B}+z_{C}}{3}}$.
| Sommaire | Utilisation des complexes en géométrie |
# Complexes et géométrie/Devoir/Étude d'une similitude indirecte

Le plan est muni d'un repère orthonormal direct $(O;{\vec {u}},{\vec {v}})$ d'unité graphique 2 cm.
On note $A$ le point d'affixe $a=-2\mathrm {i}$.
À tout point $M$ du plan d'affixe $z$ on associe le point $M'$ d'affixe :
    $z'=-2{\bar {z}}+2\mathrm {i}$.
1° On considère le point $B$ d'affixe $b=3-2\mathrm {i}$.
    a) Déterminer la forme algébrique des affixes $a'$ et $b'$ des points $A'$ et $B'$ associés respectivement aux points $A$ et $B$.
    b) Placer les points $A$, $B$, $A'$ et $B'$.
2° Démontrer que si $M$ appartient à la droite $D$ d'équation $y=-2$, alors $M'$ appartient aussi à $D$.
3° a) Démontrer que pour tout $z$, $|z'+2\mathrm {i} |=2|z+2\mathrm {i} |$.
    b) Interpréter géométriquement cette égalité.
4° Dans cette question, on considère $c=4+2\mathrm {i}$.
    a) Déterminer un argument de $c+2\mathrm {i}$ et en donner une interprétation géométrique.
    b) Déterminer un argument de $c'+2\mathrm {i}$ et en donner une interprétation géométrique.
    c) Placer $C$ et $C'$, les points associés respectivement à $c$ et $c'$. Tracer les demi-droites $[AC)$ et $[AC')$.
5° On se place à nouveau dans le cas général. On note $\theta$ un argument de $z+2\mathrm {i}$.
    a) Démontrer que $(z+2\mathrm {i} )(z'+2\mathrm {i} )$ est un réel négatif ou nul.
    b) En déduire un argument de $z'+2\mathrm {i}$ en fonction de $\theta$.
    c) Que peut-on en déduire pour les demi-droites $[AM)$ et $[AM')$ ?
    d) Proposer une construction géométrique du point $M'$ associé au point $M$.
1° a) $a'=-2\mathrm {i}$ et $b'=-6-2\mathrm {i}$.
    b) Cette section est vide, insuffisamment détaillée ou incomplète. Votre aide est la bienvenue ! Comment faire ?
2° $-2({\overline {x-2\mathrm {i} }})+2\mathrm {i} =-2x-2\mathrm {i}$.
3° a) $|z'+2\mathrm {i} |=|-2{\bar {z}}+4\mathrm {i} |=|-2z-4\mathrm {i} |=2|z+2\mathrm {i} |$.
    b) L'application $M\mapsto M'$ double la distance au point $A$.
4° a) $\arg \left(c+2\mathrm {i} \right)=\arg \left(4+4\mathrm {i} \right)\equiv {\frac {\pi }{4}}{\bmod {2\pi }}$. La demi-droite $[AC)$ fait un angle de ${\frac {\pi }{4}}$ avec l'axe orienté $(O;{\vec {u}})$.
    b) $\arg \left(c'+2\mathrm {i} \right)=\arg \left(-8+8\mathrm {i} \right)\equiv {\frac {3\pi }{4}}{\bmod {2\pi }}$. La demi-droite $[AC')$ fait un angle de ${\frac {3\pi }{4}}$ avec l'axe orienté $(O;{\vec {u}})$.
    c) Cette section est vide, insuffisamment détaillée ou incomplète. Votre aide est la bienvenue ! Comment faire ?
5° a) $(z+2\mathrm {i} )(z'+2\mathrm {i} )=-2|z+2\mathrm {i} |^{2}$
    b) $\theta '\equiv \pi -\theta {\pmod {2\pi }}$.
    c) Les demi-droites $[AM)$ et $[AM')$ sont symétriques par rapport à $D$.
    d) Sur la demi-droite symétrique de $[AM)$ par rapport à $D$, placer $M'$ à distance $2AM$ de $A$.
| Construction du pentagone régulier | Un problème de géométrie |
# Dynamiques de la mondialisation/Référents

* Lvcvlvs (une question ou une remarque ?) ;
# La diversité des outils

La programmation et le débogage impliquent des successions d'actions réparties en plusieurs phases: l'écriture du programme; la compilation; l'exécution du programme. Des différentes techniques interviennent suivant les phases: l'analyse statique du code lors de la phase d'écriture ou de compilation; les tests unitaires; le débogage interactif; la vérification sémantique dynamique des accès mémoires.

# Les tests unitaires

Écrire les tests unitaires pendant la rédaction des programmes fait partie des bonnes pratiques. Dans des langages récents comme Rust et Go, ils sont complètement intégrés dans les chaînes de fabrication d'un programme. De manière notable, directement, dans les commentaires du code, sous une forme complémentaire à la programmation lettrée de Knuth (literate programming).

# Le compilateur

Le compilateur (ou l'interpréteur) peut parfois détecter des aspects du code qui lui semble incohérents dans un cadre général, même si le code est valide du point de vue purement syntaxique.
Il est très important dans la phase de débogage de favoriser cette remontée d'information. Mais comme ces détections augmentent le temps de compilation, il faut les activer explicitement.

## Les avertissements

Il y a plusieurs niveaux dans la détection. Le mieux est d'en demander le plus possible.
Néanmoins, pour un code déjà ancien et de taille importante, il est parfois difficile de refactoriser le code pour les éliminer. Mais plutôt que de ne demander aucun avertissement, il vaut mieux supprimer uniquement ceux dont vous avez vérifié l'inocuité.

## L'analyseur statique

L'analyseur statique du compilateur fera une analyse beaucoup plus fine de la totalité du code, et donc beaucoup plus coûteuse en temps. L'activation est différente, et complémentaire, des avertissements.
Pour gcc, c'est relativement simple
Pour clang, l'analyse statique et sa visualisation sont plus intrusives dans le processus de compilation.
La page web de l'analyseur statique de clang est https://clang-analyzer.llvm.org/ .

## AddressSanitizer

AddressSanitizer est une bibliothèque de détection d'erreurs mémoire à l'exécution du programme. Elle est relativement rapide et détecte de nombreuses erreurs. Par contre, il faut demander explicitement au compilateur de l'utiliser.
Cette instrumentation est incompatible ou rend difficile, l'utilisation de valgrind sur l'exécutable.

# Le débogueur

GDB

# Ce qui n'est pas (encore) dans les TP

* les protections des cadres des piles (stack smashing) (-fstack-protector, -lssp)
* le débogage des threads (fil) (valgrind -tool=helgrind, valgrind --tool=drd)
* Débogage avancé/La mémoire
# Débogage avancé/Présentation de la leçon

Le débogage est l'une des activités principales lors du développement d'un logiciel. Pour aider le programmeur, plusieurs outils existent. Comprendre ces outils et en maîtriser les différents aspects au-delà des bases permet de gagner du temps. Cette leçon se concentre sur le débogage en C, dont les pointeurs, véritable opérateur de description des contenus mémoire, permettent de créer des bugs subtils avec un petit nombre de lignes de code.
Cette leçon est construite pour revenir, globalement, et par la pratique (les travaux pratiques), sur les différents points nécessaires à la compréhension d'une exécution (Algorithmique, Programmation, Compilation, Système d'exploitation, Architecture des ordinateurs). Le débogage est l'une des activités en Informatique qui nécessite la mobilisation simultanée de tous ces points.
Les exercices consistent en : compiler un petit code C ayant un type de bug particulier, exécuter le code compilé et comprendre l'état du processus au moment du bug avec différentes techniques et outils.
N'hésiter pas à regarder la solution d'un TP, même avant d'avoir commencer à le faire. Les réponses sont construites pour être des mini-tutoriaux d'appropriations des outils et de rappels des pré-requis par la pratique.
Les chapitres ont pour but d'expliciter et de revenir brièvement sur plusieurs des points abordés dans chaque TP.
# Débogage avancé/Travail pratique/Allocation: 0, Libération: 1
## But de ce TP

Il existe deux principales façons d'allouer de la mémoire dans un programme: dans la pile (les variables locales) et dans le tas (malloc/free). Un pointeur dans un langage comme C ou C++ peut donc pointer de la mémoire valide mais qui n'a jamais été allouée avec un malloc.
La fonction free sert exclusivement à libérer de la mémoire allouée dans le tas avec malloc, calloc ou realloc.
Le code dans ce TP utilise un tableau alloué dynamiquement dans la pile. Ce tableau ne doit surtout pas être libéré. Cela n'a pas de sens du point de vue de la mémoire.

## Le code à déboguer

Créer un fichier bug_stackallocthenfree.c contenant le code suivant.

## Les consignes

* Compiler le programme. Un analyseur statique récent détecte le bug
* Lancer le programme bug_stackallocthenfree
* Lancer le programme avec Valgrind. Valgrind vous indique que votre variable a été allouée dans la frame de la fonction main (les variables locales de main) mais il ne vous indique pas laquelle.
* Relancer le programme avec Valgrind en demandant à ce dernier de s'arrêter avant le début de l'exécution pour vous laisser vous connecter avec GDB. Connecter GDB. Continuer l'exécution. Remonter dans la pile d'appel et afficher l'adresse de la variable p.
* Recompiler avec ASan. Lancer le programme. ASan indique que ce qui est libéré vient de la pile
* Lancer la commande ulimit -s pour obtenir la taille maximum de votre pile (probablement 8192 Kio, soit 8 Mio). Lancer le programme avec comme argument une valeur au moins 256 fois plus grandes (2097152 = 8192 * 1024/4 car *1024 pour avoir la taille en octet /4 car un entier est sur 4 octets). ASan détecte cette fois un stack overflow. le tableau en variable local est trop grand pour rentrer dans la pile.
Vous devriez avoir tapé les commandes suivantes (certains affichages de GCC et Valgrind sont omis):
| Débogage avancé/Travail pratique/Double libération | Débogage avancé/Travail pratique/Débogage à la volée |
# Dynamiques de la mondialisation/Présentation de la leçon

Deuxième thème de géographie. L'objectif est d'approfondir l'étude sur la mondialisation, amorcée l'année précédente.
# Pile d'appels des fonctions

L'appel récursif de fonctions est devenu la norme dans les languages de programmation à partir de la fin des années 1950 avec Algol. Pour cela, il faut que l'exécution du programme utilise une zone de mémoire afin de pouvoir y accumuler les variables locales et les arguments d'un des appels d'une fonction particulière. Cette zone de mémoire est la pile d'exécution.
Lorsque l'on débogue un programme, pour pouvoir lire les variables locales, il faut savoir de quel appel, dans la pile d'appel, on souhaite lire les variables.
Les débogueurs comme GDB proposent donc lors d'un point d'arrêt de pouvoir remonter, ou descendre, dans la pile.
Pour être précis, il y a une pile différente par thread (fil d'exécution). GDB permet aussi de passer de l'observation d'une pile à une autre dans un programme multithreadé parallèle.

# Allocation dynamique dans le tas

TODO

# Observation du processus: activité et mémoire

TODO

# Allocation dynamique dans la pile

TODO
* Débogage avancé/Outils d'aide au débogage et fondamentaux
# Débogage avancé/Objectifs

Pour pouvoir correctement déboguer, le programmeur doit trouver la différence entre ce qui a été prévu et ce qui est implémenté. Pour cela, il doit construire une image mentale correct de ce qui se passe globalement dans son processus afin de pouvoir la comparer avec son autre image mentale de ce qui aurait dû se passer.
L'algorithmique utilisée dans le programme, ses structures de données et la programmation de cet algorithme (langage utilisé, expression des structures de données, fabrication de l'exécutable, exécution ou interprétation du script) sont les premières fondations utilisées dès les premiers débogages réalisés en ajoutant des 'print', 'printf' ou 'puts' au milieu du code.
Néanmoins, dès que le code devient un peu technique, que l'espace d'état du programme devient grand, ou bien que l'exécution est longue ou complexe (par exemple une exécution parallèle multi-threadée), il faut pouvoir inspecter tout le processus pendant son exécution afin de comprendre son état actuel.
Reconstruire mentalement son état implique alors de prendre en compte et de mobiliser des connaissances en compilation (code, données, mécanisme d'appel des fonctions, pile, tas), en système d'exploitation (allocation dynamique de mémoire, protection de la mémoire, thread, pile), et en architecture des ordinateurs (registres, assembleur, mémoire virtuelle).
Cette leçon porte sur les outils et rappelle les différents fondamentaux qui aident au débogage.