Paradigms of Artificial Intelligence

What Hacker News says

1. anthkAug 2026
   Indeed. Scheme it's amazing for embedded (such as s9) and its small size. Also, the SICP it's cool to do with Chicken Scheme and this ~/.csirc (and chicken install srfi-203 and srfi-216):

       (import scheme)
       (import (srfi 203))
       (import (srfi 216))
    
    (define (displaynl x)
     (display x)
     (newline))
    
    (define pi (* 4 (atan 1.0)))
    

   Even if Chicken has Hypergiant to play with 3D objects, Common Lisp has Kandria, Sketch, Kons-9...

   From Scheme, after finishing SICP as an Scheme exercise (and CS course), just jump into Common Lisp, and finish both Gentle Introduction to Symbolic Computation and Paradigms of Artificial Intelligence, where you will implement a micro-Scheme in Common Lisp itself as an exercise.

   SBCL allows you to create working stuff with very few dependencies (uiop and the like from QuickLisp/Ultralisp). With Scheme/Chicken you will get lost in a maze of eggs and SRFI's.

   And, on CS/academics, if you finish SICP both GITC and PAIP on on Common Lisp will be a breeze and it will give you superpowers with these three books.

   Show morethread
2. anthkAug 2026
   Sorry, I hit the nested comment limit. On MIT Scheme, it used to recommend some older version, specially the first edition, but on Chicken 5 with the SICP related SRFI's loaded and maybe scm-sicp you can hit an almost 100% compatibility.

   On differences, I already said that there's local library overlapping from the own subdialect implementations, such as Chicken Eggs and Guile ice-9 modules, but if you start them with R5RS or RSR7 standard compatibility flags the differences fade away, altough there are rough edges:

   https://doc.guix.gnu.org/guile/latest/en/html_node/R6RS-Inco...

   It's like ANSI C vs C99 but worse.

   So I use Scheme for small scripts with S9 (R4RS standard) plus Unix and NCurses related addons.

   For learning SICP, I use Chicken 5 with 203 and 216 eggs plus the ~/.csirc and call it done. Most of the R5RS stuff from SICP will run fine under S9 too with tons of patience (and you can maybe adapt the postscript generating Scheme code from the "Computer Abstraction" books for the frame language and just spit out some PS file). It's just basic geometry with vectors in the end, something SICP will teach you throughly. If you finish SICP with Chicken you for sure will be able to even adapt the threading Scheme code from the chapters for an R4RS compliant Scheme like S9 as it already has some Unix/thereading support. Just generate some wrapping functions and call it done :). It's, for sure a great exercise for Lisp and CS, and far easier to do, for example, than making a ANSI C compiler being C99 compatible. Or, as a modern example, backporting modern Rust/Java functions to older compilers.

   On S9 Scheme (s9fes) you could just hack away most of the exercises at blinding speed...

   I prefer Common LIsp for bigger tasks (altough you can learn a lot of CS with Gentle Introduction to Symbolic Computation and Paradigms of Artificial Intelligence Programming too), but SICP it's 'harder' and it will put you on God low-level mode making the CL exercises at light speeds despite the design differences between Scheme and CL:

   Common Lisp:

     (defun hello () (princ "hello"))
      (hello)
   

   Scheme:

      (define (hello) (display "hello")) 
      (hello)
   

   The reason on picking CL over Scheme: If the code runs under SBCL, CCL and ECL call it done, it will almost run on every Common Lisp compiler/interpreter, even the commercial ones. Quicklisp (and UltraLisp) will handle the dependencies itself and CLHS (Common Lisp Hyper Spec) will have everything doccumented on your hands. The editor? Emacs+Slime or Lem, with both have functions to look up functions and autocomplete, with help about a function or library in the spot. Far better than Scheme in the end for big projects.

   Both will teach you iteration vs recursion, anonymous functions (lambdas), closures and so on.

   Show morethread
3. upghostDec 2024
   In case anyone is wondering, "when would I EVER use this (in hand-written code)?", it's a trick that makes DSL (domain specific language) and small language implementation much easier. A great reference for this is Peter Norvig's Paradigms of Artificial Intelligence Programming, when he implements a subset of Prolog and bolsters the functionality using CPS[1].

   The second, although more obscure, is that you can use it in languages that do not have "non-local exits" to terminate a deeply nested computation early or return to an earlier point in the call stack. For example, Clojure does not have nonlocal exits, as only the final form of the function is returned. However, using CPS, you can terminate the expression early and return to the original caller without executing the rest of the function. You probably only want to use this in specialized cases though or it may upset your team, they are tricky to debug.

   Lastly and probably most controversially, you can make an extensible "if" statement using CPS if you are in a dynamic language and you have no other tools to do so. Admittedly I do sometimes use this in ClojureScript. This allows you to write "append only" code without continually growing the "cond". Again, most teams don't like this, so it depends on the circumstances, but might be nice to have in your back pocket if you need it.

   [1]: https://github.com/norvig/paip-lisp/blob/main/docs/chapter12...

   Show morethread
4. sourcepluckNov 2024
   A historical tidbit which I loved in Paradigms of Artificial Intelligence Programming (available in PDF and EPUB here - https://github.com/norvig/paip-lisp):

   > The name lambda comes from the mathematician Alonzo Church's notation for functions (Church 1941). Lisp usually prefers expressive names over terse Greek letters, but lambda is an exception. A better name would be make-function. Lambda derives from the notation in Russell and Whitehead's Principia Mathematica, which used a caret over bound variables: x̂(x + x). Church wanted a one-dimensional string, so he moved the caret in front: ^x(x + x). The caret looked funny with nothing below it, so Church switched to the closest thing, an uppercase lambda, Λx(x + x) . The Λ was easily confused with other symbols, so eventually the lowercase lambda was substituted: λx(x + x). John McCarthy was a student of Church's at Princeton, so when McCarthy invented Lisp in 1958, he adopted the lambda notation. There were no Greek letters on the keypunches of that era, so McCarthy used (lambda (x) (+ x x)), and it has survived to this day.

   So, yes, on the topic of this post - Church pops up in loads of Lisp retrospectives. Maybe he's "forgotten" by people with very little engagement in the history of computing.

   Show morethread
5. upghostNov 2024
   Hot take: SICP and SD4F "considered harmful (without counterpoint)"*.

   Why? The modus operandi of problem solving in these books is object oriented programming masquerading as functional programming, and it is presented as a _neutral_ beginner book. It is _not neutral_. This is a very opinionated approach to programming.

   To be fair, I do not believe the authors intended for this style of programming to be taken as gospel, but it is often presented _without counterpoint_.

   The most powerful technique introduced -- implementing complex behavior via extensible polymorphic generics -- is virtually unmaintainable without a compiler-supported static type checker. You would know that if you ever tried to implement the code yourself in a dynamic language of your choice.

   The ramifications of these choices can be felt far and wide and are largely unquestioned.

   Ironically, they make code hard to understand, hard to extend, and hard to maintain. I need to reiterate, I do not believe the intention of the authors was to suggest these ideas should be used beyond a pedagogical setting, but they often are.

   As a specific critique to SD4F, which states as a goal making code more resilient by emulating biology, I would point to Leslie Lamport's talk on logic vs biology[1].

   I would add that I think SICP would be fine if it were taught in tandem with Paradigms of Artificial Intelligence Programming by Peter Norvig[2]. PAIP offers a completely different approach to solving problems, also using lisp. This approach is much closer to constructing a language to model a problem and then solving the problem symbolically using the language created. Areas that use OO techniques, such as the chapter in CLOS, are clearly marked as such.

   In other words, I say "SICP considered harmful" because thrusting it upon an eager newcomer as a trusted neutral guide to beginner coding (without offering any counterpoint) could set them back by a decade, filling their head with "functional object oriented programming" concepts that don't translate well to industry or CS.

   [*]: I say this as someone who has thoroughly studied both books, implemented the code, taken Dave Beazely courses to have the information spoon fed to me (dabeaz is awesome btw, take all his stuff) and used the techniques in production code bases.

   [1]: https://lamport.azurewebsites.net/pubs/future-of-computing.p...

   [2]: https://github.com/norvig/paip-lisp

   Show morethread
6. anthkOct 2024
   Two books, for beginners and experts:

   - A Gentle Introduction to Symbolic Computation. Get both the book and the figures.

   https://www.cs.cmu.edu/~dst/LispBook/

   Paradigms of Artificial Intelligence Programming

   https://github.com/norvig/paip-lisp

   https://unglueit-files.s3.amazonaws.com/ebf/59f74a93bbc1435c...

   Get SBCL as the compiler/interpreter, it's the fastest FLOSS one.

   Portacle has everything to begin with minus the books.

   https://portacle.github.io/

   Show morethread