Nouveautés

11/06/02

• Donnée de la série 13.

12/06/02

• Précisions concernant le contenu de l'examen.

14/06/02

• Corrigé de la série 13.

17/06/02

• Transparents du cours 14.

19/06/02

• Donnée et corrigé de l'examen final.

Contenu de l'examen : étant donné que nous avons eu beaucoup de questions au sujet du contenu de l'examen, voici quelques précisions :

• l'examen portera sur l'ensemble du cours et des exercices jusqu'à la séance d'hier (11 juin),
• pour Lisp et Prolog, vous devez connaître les bases de ces deux langages et être capable d'écrire des programmes simples, du type de ceux vus au cours et aux exercices ; il n'est par contre pas indispensable que vous compreniez les détails des interpréteurs.
• les appareils électroniques sont interdits pendant l'examen, mais sinon vous pourrez consulter n'importe quel document papier que vous aurez apporté (transparents, notes de cours, etc...).

Une séance de réponse aux questions aura lieu le 11 juin 2002 de 13h à 15h dans la salle IN/M 201.

L'examen final aura lieu le 18 juin 2002 de 10h00 à 12h00 en salles CO/2 et CO/3.

Nous ferons un examen de test, non obligatoire, le 28 mai de 14h15 à 15h15 en salle CO/2.

Donnée de l'examen de test : (ps) (ps.gz). Corrigé : (ps) (ps.gz).

Donnée de l'examen final : (ps) (ps.gz). Corrigé : (ps) (ps.gz).

Survol

• la Programmation Fonctionnelle
• la Programmation Logique

Cours 1 (12 mars).

Introduction, programmation impérative : transformeurs de prédicats, programmation fonctionnelle : Scala, environnement et évaluation d'une fonction, appel par valeur, appel par nom, fonctions imbriquées, portée lexicale.

Cours 2 (19 mars).

Programmation fonctionnelle : modèle d'évaluation, récursion terminale, définition de valeurs, fonctions d'ordre supérieur, fonctions anonymes, currification, types fonctionnels.

Cours 3 (26 mars).

Abstraction des données : objets, méthodes, auto-référence, classes et substitutions, opérateurs, classes abstraites, extension d'une classe, liaison dynamique, classes standards

Cours 4 (9 avril).

Les listes : constructeurs, opérations primitives, polymorphisme, concaténation, les exceptions, la classe List, tri de listes, schémas récurrents avec les listes, généralisations avec des fonctions d'ordre supérieur.

Cours 5 (16 avril).

Tuples, traitements imbriqués sur les listes, preuves de programmes fonctionnels, induction structurelle.

Cours 6 (23 avril).

La notation For : syntaxe, utilisation, traduction, généralisation. Expressions de création d'objet.

Cours 7 (30 avril).

Classes cas et filtrage de motifs, application à la différentiation symbolique.

Cours 8 (7 mai).

Effets de bord, application à la simulation d'événements discrets.

Cours 9 (14 mai).

Programmation par contraintes.

Cours 10 (21 mai).

Flots et itérateurs.

Cours 11 (28 mai).

Lisp : présentation du langage, conception d'un interpréteur en Scala.

Cours 12 (4 juin).

Un interpréteur Lisp en Scala.

Cours 13 (11 juin).

Programmation logique (1): Prolog, présentation et implémentation (unification).

Cours 14 (18 juin).

Programmation logique (2): Implantation de la recherche par retour arrière, traitement de la négation, non correction et incomplétude.

• Série 1 : (ps) (ps.gz). Corrigé : (ps) (ps.gz).
• Série 2 : (ps) (ps.gz). Corrigé : (ps) (ps.gz).
• Série 3 : (ps) (ps.gz). Corrigé : (ps) (ps.gz). Code : (txt)
• Série 4 : (ps) (ps.gz). Corrigé : (ps) (ps.gz).
• Série 5 : (ps) (ps.gz). Solution partielle: queens-partial.scala Corrigé : (ps) (ps.gz).
• Série 6.
  • Corrigé du langage d'images : (ps) (ps.gz).
  • Preuve de la propriété de union (Exercice 3 Série 5) : (ps) (ps.gz).
  • Détails de la preuve (pour les mordus) : (ps) (ps.gz).
• Série 7 : (ps) (ps.gz). Code à améliorer : (txt). Corrigé : (ps) (ps.gz). Code complet : (txt).
• Série 8 : (ps) (ps.gz). Code à améliorer : (txt). Corrigé : (ps) (ps.gz). Code du simulateur : (txt).
• Série 9 : (ps) (ps.gz). Code à améliorer : (txt). Corrigé : (ps) (ps.gz).
• Série 10 : (ps) (ps.gz). Corrigé : (ps) (ps.gz).
• Série 11 : (ps) (ps.gz). Solution partielle: lisp-partial.scala Corrigé : (ps) (ps.gz).
• Série 12 : (ps) (ps.gz). Solution partielle: lisp-partial.scala Documentation de l'API Java. Corrigé : (ps) (ps.gz).
• Série 13 : (ps) (ps.gz). Interpréteur Prolog : prolog.scala. Corrigé : (ps) (ps.gz) (lang.prolog).

A chaque fois que vous utilisez un interpréteur interactif, comme siris, l'interpréteur Lisp de la série 12 ou l'interpréteur Prolog de la série 13, vous pouvez utiliser le petit programme ledit qui permet de retrouver les commandes tapées précédemment avec les flèches directionnelles, ou de corriger la ligne de commande qu'on vient de taper (comme dans un shell). Pour l'utiliser, tapez par exemple : ledit siris ou ledit surus lisp-partial.scala .

Comment tester vos programmes

/home/iclamp/soft/bin

setenv PATH /home/iclamp/soft/bin:$PATH

• siris: (SIris InteRprets Scala) interprète interactif
• surus: (SUrus RUns Scala) interprète non-interactif

Pour exécuter un programme, utiliser surus en lui passant en argument le nom du fichier à exécuter. Avec siris, vous avez un interprète interactif. Celui-ci commence par exécuter les programmes qui lui sont passés en argument puis il interprète tout ce qui vient de l'entrée standard.

Les programmes passés en argument à surus ou siris, ou tapés directement dans siris, peuvent contenir des définitions et des expressions. Dans l'interprète siris, les val et les expressions sont évalués et affichés immédiatement.

Remarques

• Le suffixe des fichiers contenant des programmes Scala est par convention .scala.
• Il n'est plus nécessaire de définir une fonction main comme point d'entrée d'un programme. Toute expression "top-level" sera exécutée immédiatement.
• Vous pouvez utiliser l'API Java.
• L'interprète est encore en cours de développement. Il risque donc d'y avoir quelques bogues. Soyez indulgents.

• Structure and Interpretation of Computer Programs. Harold Abelson and Gerald J. Sussman. 2nd edition. MIT Press 1996.
• Approche Fonctionnelle de la Programmation. Guy Cousineau et Michel Mauny. Ediscience International. 1998.
• Introduction to Functional Programming using Haskell. Richard Bird. Prentice Hall 1998.
• Foundations of Logic Programming. J.W. Lloyd. Springer Verlag. 1984.
• Effective Java. Joshua Bloch. Addison Wesley, 2001.

Le cours a maintenant son forum de discussion : epfl.ic.cours.programmationIV.

N'hésitez pas à y exprimer vos interrogations, vos problèmes D'autres étudiants pourront peut-être vous aider et les assistants s'engagent à traiter régulièrement les nouveaux messages. C'est aussi par ce biais que nous vous communiquerons des annonces générales concernant le cours.

• en utilisant le navigateur, ou
• directement par le web.

• Martin Odersky, Laboratoire des Méthodes de Programmation
      martin.odersky@epfl.ch, INR 319, tel. +41 21 693 6863

• Philippe Altherr, INR 318
• Vincent Cremet, INR 320
• Nikolay Mihaylov, INR 321
• Michel Schinz, INR 318
• Matthias Zenger, INR 321

• Maxime Gamboni
• Laurent Rolaz