Un défi majeur pour les programmeurs, en particulier pour les novices, est de comprendre les messages d'erreurs émis par le compilateur. Nous nous intéresserons au problème d'affichage de bon message d'erreur de compilation. Dans certains langages, tels que Typer, la vérification du type des expressions est faite lors de la compilation; ce qui oblige le compilateur à déduire les types de certaines ou de toutes les expressions; mais aussi d'envisager la meilleure manière d'écrire le type (dans le langage source) dans un message d'erreur (ce qui est infaisable pour le moment dans Typer). Cependant l'interprétation du type des expressions faite par le compilateur est toujours différente de ce que l'utilisateur aimerait voir en cas d'erreur de compilation. En effet, lorsque le code source est converti en une représentation interne via une fonction complexe (appelée \Code{elaborate}), il peut être difficile de trouver une correspondance entre le type "t\_source" (type du code source) et le type "t\_interne" (type de la représentation interne du code source) en cas d'erreur. Parfois, "t\_source" peut ne pas être disponible ou même n'avoir jamais existé car "t\_interne" a été créé de toute pièce par inférence de type. Il peut donc être difficile de trouver un "t\_source" correspondant, d'autant plus qu'il doit être clair et compréhensible pour le programmeur. En d'autres termes, il n'existe pas d'algorithme déterministe permettant de trouver une représentation naturelle dans le code source correspondant à la représentation interne d'un type. D'où l'importance d'implémenter un système heuristique tel que les algorithmes génétiques ou les réseaux de neurones qui nous donne cette information, permettant ainsi une meilleure affichage du texte des messages d'erreurs. Nous avons donc décidé de travailler sur l'amélioration des messages d'erreur du compilateur Typer, dans sa phase de traduction du langage (interprétation et représentation des différentes expressions dans le langage source) en proposant une approche basée sur les algorithmes génétiques. \\ / A major challenge for programmers, especially for novices, is to understand the error messages issued by the compiler. We are interested in the problem of displaying correct compiler error messages. In some languages, such as Typer, the type checking of expressions is done at compile time; this forces the compiler to deduce the types of some or all expressions; but also to consider the best way to write the type (in the source language) in an error message (which is unfeasible for the moment in Typer). However, the interpretation of the type of expressions made by the compiler is always different from what the user would like to see in case of a compilation error. Indeed, when the source code is converted into an internal representation via a complex function (called ‘elaborate’), it can be difficult to find a correspondence between the type "t_source" (type of the source code) and the type "t_interne" (type of the internal representation of the source code) in case of error. Sometimes, "t_source" may not be available or even have never existed because "t_interne" was created from scratch by type inference. It can therefore be difficult to find a corresponding "source_t", especially since it must be clear and understandable for the programmer. In other words, there is no deterministic algorithm to find a natural representation in the source code corresponding to the internal representation of a type. Hence the importance of implementing a heuristic system such as genetic algorithms or neural networks that gives us this information; thus allowing a better display of the text of error messages. We therefore decided to work on the improvement of the error messages of the Typer compiler, in its language translation phase (interpretation and representation of the different expressions in the source language) by proposing an approach based on genetic algorithms.