Peter Seibel : Practical Common Lisp

Posté par  . Modéré par Florent Zara.
Étiquettes : aucune
0
25
avr.
2005
Livre
Practical Common Lisp, disponible depuis début avril, offre une approche pragmatique inédite et approfondie du langage Common Lisp : au travers d'exemples pratiques et fonctionnels, tels que filtre antispam, serveur de MP3 ou bibliothèque de génération HTML, Peter Seibel couvre les concepts clés, les particularités et les idiomes du langage.

Destiné aux développeurs qui ont une expérience dans d'autres langages, ce livre permet de saisir la caractérisation de Common Lisp : "a programmable programming language" (que je laisserai non traduite).

J'ajoute en liens quelques références d'implémentations libres de Common Lisp. Une pléiade de stars (enfin, du point de vue du microcosme lispnik) signent les textes de présentation de l'ouvrage : Peter Norvig, Christian Queinnec, Philip Greenspun pour ne citer qu'eux. Il faut dire que les publications dédiées à ce langage ne sont pas légions, et que ce livre comble un manque : en plus de l'introduction normale au langage, il couvre en profondeurs des sujets peu abordés dans les ouvrages existants, de telle façon qu'il constitue un ouvrage complet permettant de se mettre sur de bons rails. De plus, les nombreux exemples décrits sortent des clichés : vous n'y trouverez pas de suite de Fibonacci, mais des sujets actuels.

On pourra conseiller aux lecteurs conquis de poursuivre leur (re)découverte avec les classiques tels que On Lisp de Paul Graham (disponible en ligne), ou Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp de Peter Norvig.

À noter que l'auteur a obtenu de son éditeur, Apress, de pouvoir conserver une version en ligne du livre. Il propose par ailleurs sur son site un paquetage, "Lispbox", permettant d'obtenir rapidement un environnement de développement fonctionnel afin d'expérimenter les exemples du livre, dont le code est téléchargeable.

Aller plus loin

  • # Pour débuter...

    Posté par  . Évalué à 2.

    Voici un autre excellent livre en ligne (en français) pour débuter en Common Lisp : http://dept-info.labri.fr/~strandh/Teaching/Programmation-Symboliqu(...)

    Il présente pas à pas la syntaxe de ce langage fonctionnel, et permet de se faire rapidement une idée de la puissance de ce langage.
    Ce livre est à la base destiné aux étudiants de l'université Bordeaux I et de l'ENSEIRB ; alors merci de respecter les clauses de la page de présentation.
    • [^] # Re: Pour débuter...

      Posté par  . Évalué à 1.

      Lis le livre avant de le recommender! Common Lisp n'est pas un langage fonctionnel. Il permet la programmation fonctionnelle, entre autres.
    • [^] # Re: Pour débuter...

      Posté par  . Évalué à 0.

      Super ça fera office de cale pour ma commode :\ enfin celle qui supporte les livres intéressants ou utiles
      • [^] # Re: Pour débuter...

        Posté par  (site web personnel) . Évalué à 0.

        je me disais aussi que cette news ne déclenchait pas l'hystérie des foules

        http://about.me/straumat

        • [^] # Re: Pour débuter...

          Posté par  (site web personnel) . Évalué à 0.

          C'est dinque... c'est la pière fois que je vois une news attirée si peu de commentaires!

          http://about.me/straumat

          • [^] # Re: Pour débuter...

            Posté par  . Évalué à 3.

            Mieux vaut peu de commentaires mais pertinents que le contraire.
            Ca manque de spécialistes ici, mais comme il s'agit d'un livre d'introduction à lisp la news servira quand même, et dans quelques années on n'aura que des pros.
          • [^] # Re: Pour débuter...

            Posté par  (site web personnel) . Évalué à 5.

            On voit souvent des news intéressantes attirer peu de commentaires, et des news moins intéressantes attirer des dizaines (centaines ?) de commentaires. À mon sens, la pertinence d'une news ne se mesure pas à son nombre de commentaires, mais à son contenu, tout simplement.
          • [^] # Re: Pour débuter...

            Posté par  . Évalué à 2.

            Peut-etre parce que ce n'est pas le genre de livres qui figure sur la table de chevet de la generation o'reilly:

            http://www.oreilly.com/oreilly/author/writeforus_1101.html:(...)

            "We're NOT looking for:

            * Books that overlap too heavily with our existing books.
            * Books on proprietary technologies that don't have a huge user base.
            * Books on miniscule (i.e., personal or nascent) products, even if they are open source.
            * Books on topics that have dismal sales despite quality books being available. (If you're addressing a topic where good books have sold dismally in the past (for instance, LISP, LaTeX, or Web-based training), you have a much higher threshold to clear with your proposal. Convince us why there is a revival of interest in your topic, or why your approach to a deadly topic will provoke interest nonetheless.)
            * Books that have been rejected by other publishers, in most cases.
            "

            Mais cela commence a changer un peu; en tout cas ce n'est pas par la grande porte:

            http://www.oreilly.com/catalog/hackpaint/index.html(...)
          • [^] # Re: Pour débuter...

            Posté par  (site web personnel) . Évalué à 1.

            Boh, 757 hits sur le lien du livre au moment ou je poste => tout le monde n'a pas fini de le lire pour en parler :)
  • # Bon bouquin

    Posté par  . Évalué à 3.

    Livre bien ecris et plutôt captivant. La version imprimée (edition Apress) est agréable (typographie, beau papier et couverture en carton dur), bien que le papier soit un peu fragile.
    On y decouvre petit à petit le style de developpement Common Lisp qui semble être des plus efficace et agréable. Le fait de ne plus être tres contraint par ce que les implémenteurs d'un language ont figés est un soulagement. Une tres bonne idée au depart (vs algol, voir par ex http://www.paulgraham.com/rootsoflisp.html(...) ), 45 ans d'evolution (compilateurs etc) derrière, common lisp est vraiment séduisant même vis-à-vis des dernières reférences (python,java etc).
  • # Quelques liens de plus

    Posté par  (site web personnel) . Évalué à 4.

    Pour ceux que ça intéresse, voila quelques liens supplémentaires :

    Les références :
    http://www.lispworks.com/documentation/HyperSpec/Front/index.htm(...)
    http://www-2.cs.cmu.edu/Groups/AI/html/cltl/cltl2.html(...)

    Les portails :
    http://www.lisp.org/(...)
    http://www.cliki.net/(...)
    http://common-lisp.net/(...)
    http://planet.lisp.org/(...)

    Le Common Lisp CookBook :
    http://cl-cookbook.sourceforge.net/index.html(...)

    Les tutoriels :
    http://cs.gmu.edu/~sean/lisp/LispTutorial.html(...)
    http://www.lisperati.com/(...)

    Et des articles en vracs :

    Pascal Costanza's Highly Opinionated Guide to Lisp :
    http://www.informatik.uni-bonn.de/~costanza/lisp/guide.html(...)

    A Retrospective on Paradigms of AI Programming - Peter Norvig
    http://www.norvig.com/Lisp-retro.html(...)

    The Right Tool For The Job - Sam Steingold
    http://www.podval.org/~sds/tool.html(...)

    Et les excellents essais de Paul Graham :
    http://www.paulgraham.com/(...)
    • [^] # Re: Quelques liens de plus

      Posté par  (site web personnel) . Évalué à 2.

      Dans le genre bon livre d'informatique dans lequel on apprend un langage (mais pas que ça):

      http://mitpress.mit.edu/sicp/full-text/book/book.html
      pour scheme (du Lisp moderne)

      ou encore
      http://pauillac.inria.fr/caml/books-fra.html#ocaml-oreilly
      et
      http://pauillac.inria.fr/caml/books-fra.html#camlprimer
      pour du CaML / OCaML (de la bête de langage, avec du typage fort).

      Bonne lecture

      (O:
  • # Exemple de test d'un code retour erreur en Lisp ?

    Posté par  . Évalué à 2.

    Question d'un programmeur C:
    Quand j'utilise une fonction je fais attention à tester la présence d'un code d'erreur retourné par cette fonction (paramètres incorrects, évènement imprévu, post condition fausse...).

    Cela donne quoi ce genre de test en Lisp ? Si quelqu'un a un exemple de code à me montrer... par avance, merci.
    • [^] # Re: Exemple de test d'un code retour erreur en Lisp ?

      Posté par  . Évalué à 3.

      Voir le chapitre 19 du premier url de la news.

      Une reponse simpliste pourrait etre: comme en C, avec un/des tests adaptés a la fonction, mais plus globalement chercher a transcrire directement des habitudes de C en CL n'est sans doute pas le meilleur moyen d'aborder ce langage, dynamic typing, higher order function, multiple return values, OOP (et non des moindre si l'on parle de pre/post conditions), offres a eux seuls une "foultitude" d'approches de ce probleme :)

      mais pour repondre le plus simplement possible a ta demande il est courant d'avoir une valeur de retour == nil (false) ou d'un type specifique en cas d'erreur, soit:

      (let ((valeur_retournée (la-fonction)))
      (if (predica-adapté valeur_retournée) 'tout_va_bien 'tout_va_mal))

      ou plus imperatif:

      (unless (predica-adapté (la-fonction)) 'tout_va_mal)
      • [^] # Re: Exemple de test d'un code retour erreur en Lisp ?

        Posté par  . Évalué à 2.

        Merci, c'est clair,.

        En fait, naïvement, je croyais que des langages comme Lisp évitaient à tout prix d'utiliser des variables temporaires. Et je me demandais quelle contorsion cela donnait quand il faut d'abord tester une valeur de retour, puis l'utiliser si tout va bien.

        Ton premier exemple utilise une variable exactement comme on le fait en C.
        • [^] # Re: Exemple de test d'un code retour erreur en Lisp ?

          Posté par  . Évalué à 2.

          Oui, mais on pourrait s'en passer en utilisant des macros, qui sont vraiment vraiment différentes de celles utilisés en C. Exemple avec une macro reprise du livre « On Lisp »:
          CL-USER 12 > (defmacro aif (test-form then-form &optional else-form)
                        `(let ((it ,test-form))
                           (if it ,then-form ,else-form)))
          AIF
          
          CL-USER 13 > (defun ma-function ()
                         120)
          MA-FUNCTION
          
          CL-USER 14 > (aif (ma-function)
                           (print it)
                         (print 'returned-value-is-nil))
          
          120 
          120
          
          CL-USER 15 > (defun ma-function ()
                         nil)
          MA-FUNCTION
          
          CL-USER 16 > (aif (ma-function)
                           (print it)
                         (print 'returned-value-is-nil))
          
          RETURNED-VALUE-IS-NIL 
          RETURNED-VALUE-IS-NIL
          
          Pour comprendre ce qu'il se passe, regarder la transformation (qui a lieu avant l'évaluation) qui va affecter la variable IT en appelant « test-form » et exécuter soit « then-form », soit « else-form », en fonction de la valeur de IT.
          CL-USER 17 > (macroexpand-1 '(aif (ma-function)
                                              (print it)
                                            (print 'returned-value-is-nil)))
          (LET ((IT (MA-FUNCTION))) 
               (IF IT 
          	 (PRINT IT) 
          	 (PRINT (QUOTE RETURNED-VALUE-IS-NIL))))
          T
          
          C'est grâce aux macros que Lisp peut être qualifié de « programmable programming language »... Autre example pour planquer du code avec WITH-OPEN-FILE (qui fait partie du standard):
          (with-open-file (mon-flux "fichier" :direction :output)
             (write "Bonjour!" mon-flux)
             (write "Au revoir!" mon-flux))
          
          qui donnera:
          (LET ((#:INTERNAL-STREAM631 (OPEN "fichier" :DIRECTION :OUTPUT)) 
                (#:DELETE632 T))
            (UNWIND-PROTECT
                (MULTIPLE-VALUE-PROG1 (LET ((MON-FLUX #:INTERNAL-STREAM631))
                                        (WRITE "Bonjour!" MON-FLUX)
                                        (WRITE "Au revoir!" MON-FLUX))
                                      (SETQ #:DELETE632 NIL))
              (WHEN #:INTERNAL-STREAM631 
          	  (CLOSE #:INTERNAL-STREAM631 :ABORT #:DELETE632))))
          
          • [^] # Re: Exemple de test d'un code retour erreur en Lisp ?

            Posté par  . Évalué à 1.


            Oui, mais on pourrait s'en passer en utilisant des macros, qui sont vraiment vraiment différentes de celles utilisés en C.


            Surtout qu'en C les macros sont ridicules puisque gérées par un préprocesseur simpliste.
    • [^] # Re: Exemple de test d'un code retour erreur en Lisp ?

      Posté par  . Évalué à 3.

      CL-USER 34 > (defun test (f)
                     (case (apply f nil)
                       ((ok-1 ok-2 ok-3) "OK...")
                       ((nok-1 nok-2 nok-3) "NOK...")
                       (failed "Failed...")
                       (t "unknown")))
      TEST
      
      CL-USER 35 > (test (defun ma-function () 'ok-1))
      "OK..."
      
      CL-USER 36 > (test (defun ma-function () 'nok-1))
      "NOK..."
      
      CL-USER 37 > (test (defun ma-function () 'failed))
      "Failed..."
      
      CL-USER 38 > (test (defun ma-function () 'quoi))
      "unknown"
      
      CL-USER 39 > (test #'(lambda () 'nok-3))
      "NOK..."
      
      • [^] # Re: Exemple de test d'un code retour erreur en Lisp ?

        Posté par  . Évalué à 2.

        Merci. Là je retrouve le "switch case" du C.
        Je commence à croire que les différences ne sont pas énormes entre les 2 languages.
        • [^] # Re: Exemple de test d'un code retour erreur en Lisp ?

          Posté par  . Évalué à -1.

          Les differences sont enormes...C'est un peu comme comparer python,perl/ ou ruby avec C.
        • [^] # Re: Exemple de test d'un code retour erreur en Lisp ?

          Posté par  . Évalué à 1.

          il y a surtout qu'en terme de multi paradigme CL est particulierement ouvert, en faisant reference a des usages de certains langages tu auras donc le plus souvent du code refletant les usages des langages en questions, j'avais au depart penser donner une reponse a base de cond Scheme (qui n'est lui meme qu'une macro hygienic a base de if) avant de me rappeler que le cond CL ne propose pas "l'operateur" => par defaut (il faudrait ecrire une macro hygienic pour, ce qui est toujours plus propre qu'introduire un symbole arbitraire :):
          (cond ( ((case0-function) 'pwet) ; classic CL usage
                  ((case1-function) => function-recevant-la-valeur-non-nil)
                  ((case2-function) => (lambda (x) `(pwet ,x)))
                  ((case3-function) => (lambda (x) (a-function 42 x "pwet")))
                  (else 'each_casex-fonction_return_nil))
          
          qui melange joyeusement case et erreur, le else devenant t en CL et l'usage du => demandant de passer par une macro. Evidemment pour des operateurs/statement aussi basic que if/switch c'est a peu de choses pret partout pareil.
    • [^] # Re: Exemple de test d'un code retour erreur en Lisp ?

      Posté par  . Évalué à 2.

      On peut faire du C en Lisp, mais quel est l'intérêt ?

      Le concept de code d'erreur de retour est une abomination remplacée depuis des lustres par de la gestion d'exceptions, ou à vrai dire dans le cas de (http://fr.wikipedia.org/wiki/Common_Lisp(...) ) Common Lisp, le système de conditions ( http://fr.wikipedia.org/wiki/Syst%C3%A8me_de_gestion_d%27exceptions(...) ).

      Un erreur, ça se signale (avec error, signal, warn ...). Ca se traite avec HANDLER-BIND et ça se répare (et la suite redémarre, quand c'est possible) avec des RESTARTS.

Suivre le flux des commentaires

Note : les commentaires appartiennent à celles et ceux qui les ont postés. Nous n’en sommes pas responsables.