Mac Forum / Applications / Mac Applications / July 2007

I'd say a few months at least, depending on the speed of their legal
department.

Yep, it has always been that way with me, stubborn as a donkey.

You don't even want to know what poor Tom Stiller and others went
through when they were trying to teach me a little bit of Unix.

They FINALLY got though to me, taught me a tiny bit about dd for example.

I have been thinking of renting myself out to new teachers, on the basis
that if they can teach me, they can teach anyone else  :)

I had the tables turned on me when I ran into a student of the Lisp
language, he just could not understand how the advanced concept "Y"
worked, even though everyone TRIED to teach him by conventional means.

Here is the classical definition of the Y combinator that everyone was
trying to explain to that student, in the "Scheme" dialect of Lisp:

(define y
   (lambda(m)
       ((lambda(u)
           (m (lambda(arg)
                    ((u u) arg) )))
         (lambda(u)
             (m (lambda(arg)
                       ((u u) arg) ))) )))

Understand that Lisp is a simple language to learn.  At MIT, even today
they do not bother to teach Lisp to their engineering students, instead
the students are expected to learn Lisp 'on the fly' because the
language is so easy to learn.

The thing that makes Y so hard to grasp is the (u u) part, where the
function "u" accepts itself as an immediate argument.

If you try that in the C language, you get an immediate error, because C
is not nearly as 'flexible' a language as Lisp is.

Lisp normally works this way:
(the functions +3 and +6 have to be defined by the user
 ahead of time, of course)

(+3 2)  <returns 5>

(+6 2)  <returns 8>

Then you can:

(+ (+3 2) 4)  <returns 9>

(+ (+6 2) 4)  <returns 12>

The Y combinator segment works like this, however:

((u u) arg)

Much tougher to wrap your brain around that!

I succeeded in explaining Y to that student where others failed, by
breaking that hairy concept down into tiny bite sized pieces that he
could understand.

I was not gentle to the student, the version of Y that I explained to
him was even more complex; I substituted the lambda version of Y for the
global variable Y, such that no global variables were used anywhere at
all.

(all global variables were all replaced by lambda expressions)

Here is "lambda Y" applied to the lambda version of a length function,
which is what I required the student to learn, inside out, until he was
no longer 'frightened' by the Y combinator:

( ((lambda(m)  ;;; this line is the start of Y
        ((lambda(u)
            (m
                (lambda(arg)
                   ((u u) arg) )))
                       (lambda(u)
                         (m (lambda(arg)
                              ((u u) arg))) )))  ;;; end of Y

         (lambda(foo)  ;;; start of length function
           (lambda(n)
              (cond
                ((null? n) 0)
                (#t (add1 (foo (cdr n)) ))) )))  ;;; end of length
     
    (quote (a b c)) )   ;;; argument for length function

That whole mess of code just returns 3, by the way, when you run it in
any standard dialect of Scheme.

Y has its uses, when you are training students in artificial
intelligence techniques, like creating the robot spacecraft that are
expected to navigate and explore on their own, without any help from
earthbound scientists.

Mark-