PROGRAMMATION
Concepts, techniques et modèles

par Peter Van Roy et Seif Haridi

Traduit et adapté de l'anglais par Peter Van Roy

Dunod Éditeur, broché, 354pp+xiv, ISBN 978-2-10-051196-9, Sept. 2007

La programmation comme discipline unifiée

English-language courses that are precursors of this course

Translation of this page into English using Google Translate

Errata

“Plus n'est pas mieux (ou pire) que moins, simplement différent.”
— Le paradoxe de Van Roy.

Cet ouvrage présente l'originalité d'expliquer les concepts majeurs de la programmation à l'aide d'une approche synthétique qui en fait ressortir l'unité sous-jacente. Il présente les trois principaux paradigmes de programmation dans un cadre uniforme avec une panoplie de techniques pratiques de développement de programmes. Il commence avec un paradigme simple, la programmation fonctionnelle, qui ne contient que quelques concepts. Ensuite, il construit deux autres paradigmes, la programmation orientée objet et la programmation concurrente dataflow, en ajoutant à chaque fois un seul concept au langage de base. Nous constatons que chacun des trois paradigmes a sa place: “plus n'est pas mieux (ou pire) que moins, simplement différent.”

Le livre propose une sémantique simple et complète qui permet de comprendre tous les concepts sans pour autant sacrifier la rigueur. Toutes les notions théoriques présentées sont illustrées par des centaines d'extraits de code. En outre, 51 énoncés d'exercices fournissent au lecteur l'occasion de tester ses connaissances. Le livre est la traduction partielle d'un cours de référence publié par MIT Press. Le livre s'adresse à des étudiants qui ont déjà une première expérience de la programmation, qu'ils soient en licence d'informatique (niveaux L2 ou L3) ou en écoles d'ingénieurs. Sur ce site, nous proposons deux compléments au livre: un outil d'apprentissage, le Labo interactif, qui est vendu pour une somme modique par la société ScienceActive, et un ensemble complet de transparents pour des cours.

Sommaire: Introduction aux concepts de programmation. La programmation déclarative. Techniques de programmation déclarative. La programmation concurrente dataflow. La programmation avec état explicite. La programmation orientée objet.

Apprendre avec le Labo interactif

Le livre est complété par le Labo interactif, un outil d'apprentissage et d'exploration qui vous permettra de compiler et d'exécuter tous les exemples de code du livre et de nombreux autres, afin de comprendre par l'expérience comment fonctionnent les programmes, les modifier, voire en écrire de nouveaux. Le Labo interactif est construit comme un véritable outil d'accompagnement du livre, avec la même structure et une interface qui facilite grandement l'utilisation du livre. Les exemples sont choisis pour permettre un véritable apprentissage du métier de la programmation: ils forment une bibliothèque complète de bonnes techniques. Le Labo interactif est basé sur le Mozart Programming System, ce qui lui permet de marier la facilité d'utilisation avec le pouvoir d'expression de la plate-forme complète qui est Mozart. Le Labo interactif a été conçu par Yves Jaradin et Peter Van Roy. Il est édité et vendu séparément par ScienceActive.

Deux cours de programmation

Ce site complète le livre avec des transparents, des énoncés d'examens, un lexique français/anglais et d'autres suppléments. Nous vous proposons les transparents pour deux cours de programmation en français basés sur ce livre: un cours complet de 12 à 14 séances de deux heures et un cours abrégé de 7 séances de deux heures. (Il y a aussi des cours en anglais sur le site supplémentaire de la version anglaise du livre.) Les deux cours sont destinés aux étudiants universitaires de seconde année.

Notre approche est basée sur les concepts de programmation, pas sur les langages ou les accidents de syntaxe. Nous commençons avec un langage simple et nous ajoutons des concepts au fur et à mesure pour surmonter les limitations en expressivité du langage.

Comme prérequis, les étudiants doivent avoir eu une première introduction à la programmation et aux concepts mathématiques simples tels que les ensembles et les séquences. Par exemple, les étudiants peuvent avoir eu un premier cours basé sur Java. Notre expérience montre que la deuxième année est presque idéale pour ce cours: en première année les étudiants manquent de maturité pour comprendre les concepts et en troisième ou quatrième année les étudiants sont devenus trop conservateurs. En deuxième année les étudiants ont assez de maturité pour comprendre les concepts et assez d'ouverture d'esprit pour les apprécier.

Pour vous aider il y a des suppléments à ces cours:

Un lexique bilingue français/anglais de tous les termes techniques utilisés dans le cours. Le but du lexique est de faciliter le lien entre la matière du cours et le monde de l'informatique en anglais.
Une syntaxe sommaire du langage Oz. Cette syntaxe décrit la partie du langage utilisée dans le cours.
Un résumé des commandes principales dans l'environnement de travail du système Mozart.
Une série d'exercices avec solutions. Ces exercices sont des versions modifiées de certains exercices proposés dans le cours. Les solutions ont été faites par Raphaël Collet.
Une solution pour une question d'examen sur la sémantique. Une des qualités de notre approche est qu'elle donne une sémantique simple et complète de tous les concepts.
Les principaux paradigmes de programmation (affiche)
Un cours de programmation pour la première année. Ce cours est basé sur l'enrichissement progressif des micromondes multi-agents.

Vous êtes libre d'utiliser et de modifier les transparents et tous les autres documents pour vos propres cours si vous gardez les noms des développeurs originaux.

Cours complet (12 à 14 séances de deux heures, 731 transparents)

Ce cours ajoute les concepts suivants au cours abrégé: les algorithmes sur les listes y compris le tri, les enregistrements et les arbres, la complexité calculatoire, les exceptions, des techniques de programmation orientée objet, la programmation en Java, la programmation à grande échelle (“in the large”) et la concurrence déclarative et multi-agent. Le cours a été donné à tous les étudiants informatiques et ingénieurs de seconde année en printemps 2005 (sigle LINF1251) et automne 2005 (sigle FSAB1402) (environ 350 étudiants en tout), et en automne 2006 et 2007 (sigle FSAB1402, environ 250 étudiants pour chaque cours). Pierre Dupont a fait la séance sur la complexité calculatoire. Raphaël Collet et Jonathan Fallon ont aidé pour développer les premières séances pratiques. Voici les transparents des cours magistraux et les séances pratiques (tous en français). Les deux cours marqués supplémentaire peuvent être ajoutés à volonté.

Introduction et concepts de base (58 transparents) (PPT, PDF, session pratique).
Récursion sur les entiers (50 transparents) (PPT, PDF, session pratique).
Récursion sur les listes (51 transparents) (PPT, PDF, session pratique).
Complexité calculatoire (51 transparents) (PPT, PDF, session pratique, indications de solutions).
Cours supplémentaire: Algorithmes sur les listes (51 transparents) (PPT, PDF, session pratique).
Enregistrements et arbres, introduction à la sémantique (49 transparents) (PPT, PDF, session pratique).
Sémantique formelle (64 transparents) (PPT, PDF, session pratique).
Projet (en groupes) (Projet 1: calcul symbolique, Projet 2: dessin des arbres).
L'état et l'abstraction de données (77 transparents) (PPT, PDF, session pratique).
Programmer avec des types abstraits (43 transparents) (PPT, PDF, session pratique).
Objets, classes, polymorphisme et héritage (51 transparents) (PPT, PDF, session pratique).
Cours supplémentaire: Techniques de programmation orientée objet (42 transparents) (PPT, PDF, session pratique).
Le langage Java et les exceptions (53 transparents) (PPT, PDF, session pratique).
Concurrence et systèmes multi-agents (45 transparents) (PPT, PDF, session pratique).
Concurrence déclarative (46 transparents) (PPT, PDF, pas de session pratique).
Examen final: il a une durée de 3h. Nous vous proposons plusieurs jeux de questions: examen 1 (solution à la question sur la sémantique), examen 2, examen 3 (solution à la question 1), examen 4, examen 5, examen 6, examen 7 (solution à la question 1 des examens 6 et 7), solutions à quelques exercices. Pour information, voici les taux de réussite (sur la première session) en automne 2005 (74% de 304 étudiants, une note moyenne de 11.3/20), automne 2006 (84% de 248 étudiants, une note moyenne de 12.6/20) et automne 2007 (78% de 254 étudiants, une note moyenne de 11.7/20). Le Labo interactif a été utilisé dans le cours d'automne 2007. Nous pouvons dire que les étudiants travaillent bien dans ce cours.

Ce jeu de transparents est la version de janvier 2008.

Cours abrégé (7 séances de deux heures, 358 transparents)

Ce cours abrégé donne une introduction simple et profonde aux concepts de programmation les plus importants: la portée lexicale, la programmation déclarative, la récursion, les fermetures lexicales, la spécification, les invariants, le raisonnement, la sémantique formelle, l'état, l'abstraction de données, les types abstraits, les objets, les classes, le polymorphisme, l'héritage, la concurrence et les systèmes multi-agents. Pour chaque concept, le cours explique à la fois l'utilisation pratique et la compréhension théorique. Le cours fait une distillation de notre expérience de recherche de façon adaptée aux étudiants de seconde année. Après ce cours, il y a beaucoup de continuations possibles, comme par exemple la programmation orientée objet, la programmation concurrente de toutes formes, le génie logiciel, le développement pratique avec outils industriels et l'informatique théorique.

Le cours contient sept séances magistrales de deux heures, six séances en laboratoire de quatre heures, un test de mi-chemin et un examen final. Avec le sigle FSAC1450, le cours a été donné à tous les étudiants ingénieurs de seconde année à l'UCL en automne 2004 (environ 300 étudiants). Le cours a été développé par Peter Van Roy, en s'inspirant des cours précédents développés par Seif Haridi, Christian Schulte et Peter Van Roy. Les séances en laboratoire ont été développées par Raphaël Collet, Isabelle Dony, Boris Mejías et Luis Quesada. Voici le site officiel du cours FSAC1450. Voici les transparents des cours magistraux et les séances en laboratoire (tous en français):

Introduction et concepts de base (cours magistral (54 transparents), session pratique).
Récursion sur les entiers (cours magistral (40 transparents), session pratique).
Test: en troisième semaine, il a une durée d'une heure et compte pour un tiers des points (questions avec réponses).
Récursion sur les listes (cours magistral (52 transparents), session pratique).
Sémantique formelle (cours magistral (61 transparents), session pratique).
L'état et l'abstraction de données (cours magistral (58 transparents), session pratique).
Objets, classes, polymorphisme et héritage (cours magistral (48 transparents), session pratique).
Séance de clôture: Concurrence et systèmes multi-agents (cours magistral (45 transparents), pas de session pratique).
Examen final: il a une durée de 2h30 et compte pour le deux tiers des points (questions). Pour information, il y a eu un taux de réussite de 74% de 278 étudiants à l'examen final et une note moyenne de 11.6/20.

Voici un site avec des solutions à quelques exercices.

PROGRAMMATION Concepts, techniques et modèles