Teaching Service Details

Ingénierie Logicielle (Cours magistraux et TP), Polytech’Lille, Master 2 (2 + 10h)
Ce cours est une intervention donnée chaque année depuis 2013 dans le cours d’Ingénierie Logiciel (IL) à Polytech’Lille. Cette intervention de 2h est une introduction à la génération de code à partir des modèles. Le cours se concentre en premier lieu sur la génération de code directe à partir d'Acceleo, puis sur les notions d’écarts sémantique entre un modèle et le langage cible. Sont ensuite abordés les thématiques de changement d’espace technologiques en utilisant des transformations de modèles. Les notions de chaînage de transformations (intérêt, réutilisation et l’importance de l’ordre du chaînage). Le cours se termine sur une présentation de cas concrets tirés de réels chaînes de transformations utilisées chez Axellience/GenMyModel avec des observations précises sur la façon dont les différentes transformations sont réutilisées entre chaque chaîne. Dans ce même module, j’ai été aussi en charge de TPs présentant un projet de génération de code comme fil rouge. Cette fois la technologie utilisée était Java, avec le framework de modélisation EMF.

Programmation Avancée (Cours magistraux et TP), Polytech’Lille, Licence 3 (2 + 22h)
Le module de programmation avancée propose aux étudiants d’aborder différentes structures de données, comme les listes chaînées, les arbres binaires ou encore les tables de hachage. Le cours est orienté autours du langage C et de ses spécificités en termes de gestion de la mémoire et de compilation séparée. En complément des TPs, j’interviens aussi pour 2h de cours magistraux où sont développés sur plusieurs exemples les principes des tables de hachage et de pointeurs de fonctions.

Système d’exploitation (Cours magistraux, TD et TP), Polytech’Lille, Licence 3 (10 + 2 + 10h)
Le module de système d’exploitation propose aux étudiants de voir en détails le fonctionnement d’un système d’exploitation. Les cours sont articulés autours de la manipulation efficace du shell, ainsi que la compréhension de son mode de fonctionnement. Sont ensuite abordés les notions de processus, leur ordonnancement, ainsi que la gestion et l’organisation de la mémoire ou encore l’abstraction d’un disque dur et la façon dont le système le manipule. Les TPs sont organisés autours de plusieurs mini-projets au cours desquels les étudiants doivent écrire un mini-shell ainsi que plusieurs shell-scripts abordant les différents points vues en cours. Aux vues du nombre d’heures de TPs réduit, les notions abordées sont manipulées d’un point de vue utilisateur seulement.

Architecture et matériel (Cours magistraux, TD et TP), Polytech’Lille, Licence 3 (10 + 4 + 8h)
Ce cours a pour objectif de montrer à très bas-niveau comment fonctionne un processeur en partant des théories sur le codage de l’information, en passant par l’algèbre booléenne, les tables de Karnaugh, les bascules et les circuits combinatoires/séquentiels. Associé à ce cours, des notions plus "utilisatrices" relatives à la manipulation du shell ont aussi été proposés. Les TDs se sont naturellement organisés autours de la manipulation des tables de Karnaugh, la "conception" d’additionneurs, soustracteurs…​ binaires. Les TPs ont été concentrés sur la manipulation du shell, mais surtout sur la réalisation en C d’un mini désassembleur pour un sous-ensemble d’instructions d’un processeur Chip8. Vu le manque de temps (le niveau L3 est peut-être un peu tôt pour ce genre d’exercice), ceux-ci n’avaient pu faire que partiellement la partie de désassemblage du bytecode. Néanmoins, l’exercice a été très apprécié et à motiver certains étudiants à continuer sur leurs temps libre.

C et système avancé (TP), Polytech’Lille, Master 1 (24h)
Ce cours propose aux étudiants d’approcher la programmation système en C. Les différents points abordés sont les processus, la gestion de la mémoire, la communication inter-processus en utilisant les pipes ainsi que la redirection d’entrées/sorties. Les TPs sont organisés autours de ces points où des outils de manipulation fichier/filtrage sont développés.

Structure de données (TP), Polytech’Lille, Licence 3 (24h)
Ce cours présente différente structures de données et incite les étudiants à se familiariser avec la gestion de la mémoire en \textsc{C}. Les structures étudiées sont les listes chaînées, les piles, les files, les tables de hachages et les arbres de recherche.

Langages et traducteurs (TP), Polytech’Lille, Licence 3 (12h)
Ce cours permet aux étudiants d’approcher les principes de compilation et de traduction de langages. Les TPs proposaient aux étudiants de construire une grammaire pour la reconnaissance d’un langage basé sur XML, sa validation sémantique et sa traduction en un graphe GraphViz}.

Assembleur et C (Cours magistraux, TD et TP), IUT Lille 1, Licence 1 (8 + 36 + 36h)
Au fil de ce cours, les étudiants ont eu l’occasion d’approcher la programmation C ainsi que la programmation en assembleur Motorola 68k. Les cours relatifs à l’apprentissage du C allaient de la découverte du langage à la manipulation des structures et des pointeurs. Concernant les cours plus bas-niveau, les étudiants ont pu apprendre le fonctionnement d’un langage d’assemblage, la gestion de registres et le parcours de la mémoire via un simulateur 68k.

Codage de l’information (TD et TP), IUT Lille 1, Licence 1 (24 + 24h)
Ce cours était un cours très général sur le codage et le décodage d’informations et proposait une étude du codage binaire/octal/hexadécimal, du codage des flottants en norme IEEE754, du décodage d’instructions, du codage d’images et de flux vidéos. Au cours des différents TPs, j’ai aussi guidé les étudiants pour qu’ils puissent écrire en Java une mini machine virtuelle capable d’interpréter certains opcodes 68K.

Programmation Orientée Objets (TD et TP), IUT Lille 1, Licence 1 (32 + 32h)
Ce cours avait pour triple objectif de présenter les paradigmes de programmation objets aux étudiants, de leur présenter des structures de données et algorithmes classiques (pile, arbres, graphes, recherche de plus cours chemin…​), mais aussi de leur inculquer des notions de conception objets. À travers ce cours, même si ce n’était pas au programme, j’ai beaucoup incité les étudiants à utiliser JUnit afin de tester leurs structures et leurs algorithmes.

Architecture des systèmes d’exploitation (TD et TP), Université Lille 1, Master 1 (24 + 18h)
Le but de ce cours est de présenter en détail le mode de fonctionnement d’un système d’exploitation. Les points abordés vont de la gestion de la mémoire (organisation mémoire, MMU), à la gestion des processus et à la gestion du stockage de l’information (système de fichier…​etc). Les TPs proposaient aux étudiants de développer via un simulateur IDE maison un mini système de fichier, ou encore divers mécanismes de sauvegarde/restauration de contexte d’exécution pour la proposition de genres d’ordonnanceurs.

Algorithmique et programmation impérative (TD et TP), Université Lille 1, Licence 1 (18 + 30h)
Ce module était un module d’introduction à la programmation enseigné lors de la première année de licence. Les points abordés étaient à la fois un peu de programmation fonctionnelle, mais surtout beaucoup de programmation impérative (bien qu’un peu perturbant en utilisant \textsc{OCaml}). De façon assez classique, les structures de bases d’un langage (\textit{if/then/else}, boucles \textit{for}…​) étaient abordées ainsi que des algorithmes de tris. Lors des TPs, des minis projets étaient effectués par les étudiants afin de se familiariser avec la ``pensée'' algorithmique. Certains des étudiants étant très avancés dans les TPs et désireux de travailler un peu plus, j’avais proposé à certains d’entre eux d’effectuer un travail de décodage d’information en considérant un micro langage d’assemblage reposant sur une simple machine (imaginaire) à registre.

Pratique du C (TD et TP), Université Lille 1, Licence 2 (20 + 19.5h)
L’objectif de ce module était d’enseigner à l’étudiant la maîtrise du langage C en partant de la base. Les points abordés étaient la création de fonctions, les tableaux, les manipulations de références et pointeurs ainsi que les structures et structures auto-référentes.

Programmation des systèmes (TD et TP), Université Lille 1, Licence 3 (24 + 18h)
L’objet de ce module était de permettre à l’étudiant de maîtriser les paradigmes de programmation des systèmes (et plus particulièrement des systèmes Unix). Le système de fichiers, les processus, la synchronisation et la manipulation de processus léger étaient étudiés. En TPs, l’équivalent d’outils classique UNIX étaient programmés, jusqu’à la programmation d’un shell avec gestion des processus et des redirections d’entrées-sorties.

Réseaux (TD), Université Lille 1, Licence 3 (20h)
Ce module avait pour objectif d’enseigner aux étudiants les algorithmes sous-jacents à tout support réseaux ainsi que les bases de fonctionnement des réseaux TCP/IP. Dans les TDs étaient abordés la notion de topologie, de couche physique, de codage de l’information ainsi que le routage ou encore le fonctionnement des DNS.

Bases de données avancées (TD), Université Lille 1, Master 1 (24h)
A l’issue de cet enseignement, l’étudiant devait être capable de mettre en oeuvre des transformations de données XML en utilisant les standards définis par le W3C. Les points abordés en TDs étaient à la fois les principes de base du XML, les schemas XML et les transformations de XSLT. En complément, les arbres B+ étaient aussi présentés et manipulés.