Re: peasant revolt against DrScheme!

["Jacob J. A. Koot" <jja.koot@wolmail.nl>]

Daniel Mahler,
I am not sure non-plt people are supposed to contribute to the plt list. If
not, then I'll be pleased to be corrected.
I am flattered by your your remark of making a good point. However, if I
understand your contribution well, I had quite something else in mind. I
have gone the way from electronic circuits, via assembler, fortran, c etc up
to Scheme (or downto if you like that better). I was lucky enough to start
with a very good assembler (CDC's COMPASS, long expired now, both the
company and the assembler, like many other good products). Nevertheless I
wish I had started with a neat language like Scheme. If I understand you
correctly, I disagree with your point of view. It was via Scheme that I met
lambda calculus. That was the point were I got the feeling of understanding
what programming is about. I feel humble that it took me almost 25 years to
go along this path. If only I had met DrScheme somewhat earlier!!! I spent
lots of time and hundreds of thousands of lines of code for mapping data
structures onto programs interpreting these data. If only I had met Scheme
somewhat earlier, I could have saved the trouble of writing all this code.
There it is: the close correlation between data structure and the programs
processing these data in Scheme. It takes a lot of effort to convert from a
programmer denoting side effects, to a programmer denoting the answer in a
more immediate way (and refining the details of this answer later). It is
difficult to abdicate a bad habit.
I have spent some time on teaching side-effect-programmers to write down
what they realy are supposed to do: writing down the desired results. Once
you are accustomed to think in terms of actions, it is rather difficult to
convert to writing down the answers in a more immediate way. Moreover, once
you have the feeling of mastering a trade that most other people do not, it
is difficult to give up your position as incrowed magician. The status
borrowed from this trade tends to be more important than the ultimate task
of producing correct answers. Let's trade the ability of avoiding  pittfalls
for the art of writing programs that in themselves are the proof of their
correctness. Imho Scheme is an excellent vehicle to achieve this goal.
There remains the problem of the level of abstraction required for
functional programming, but I think Daniel P. Friedman and Matthias
Felleisen have shown that it possible to introduce this concept starting
from very concrete basics. Elementary as these books may seem, many of my
pupils returned "The Little Lisper" and "The Seasoned Schemer" to me without
finishing them. All of them had more than 10 years of experience in side
effect programming and were good craftsman. (EPL was less of a problem for
them.) I am convinced that their side effect experience was the very reason
that
they could not finish these books. I am convinced they could easily have
mastered these books if they were not trapped in theire side effect
experience. If I could relive my life, I probably would make the same
mistakes, but I would wish that I would start with Scheme rather than
electronic circuits and assemblers.
Please append "ihmo" to every sentence of this contribution.
Kind regards, Jos
Jacob J. A. Koot (Jos)
http://home-1.wolmail.nl/~koot
----- Original Message -----
From: Daniel Mahler <mahler@cyc.com>
To: Jacob J. A. Koot <jja.koot@wolmail.nl>
Cc: plt <plt-scheme@fast.cs.utah.edu>
Sent: Thursday, January 25, 2001 5:48 PM
Subject: peasant revolt against DrScheme!


>
> I did not want to contribute to the non plt traffic on this list,
> but his is a very good point.
> Over ten years ago Latrobe University in Australia
> did something nasty to their 1st year CS students.
> about the first month or two they taught assemler.
> (a simplified none running on an emulater on the vaxes
>  kind of like Core Wars).
> After making them do an assignment implementing
> BCD arithmetic, they introduced them to Pascal.
> Boy did the students love Pascal!
> What is more, it was real easy to explain things
> like call by value vs call by reference to them
> (they knew if not understood addressing modes).
> One could even talk to them about call stacks
> and what tail recusion optimization is about.
> I have met quiet a few people, including AI profs,
> who thought that writing tail reacusive code was always good,
> even in Franz Lisp (which did no optimization as far as I know)
> and in lazy functional languages like Miranda and Haskell,
> where it just force strictness and cuts out the benefits of lazyness.
> As ancient cultures well know,
> traumatizing adolescents leads to enlightened adults :)
>
> Daniel Mahler
>
> Jacob J. A. Koot writes:
>  > After about 25 years of programming in all sorts of languages (Lisp
>  > included) I saw Scheme and felt I could eventually begin to learn
>  > programming. This is 10 years ago. (Yes Matthias F, you did help)
>  > If we want our students to appreciate our education, we must first make
them
>  > ask the right questions, I think. Answering a question before it is
asked is
>  > sermoning like a prophet in the desert. Why do we need first class
>  > procedures and continuations? It's difficult to explain to someone who
has
>  > never felt the need of them, be it to make things easier or to make
things
>  > more beautiful. May be knowing some of the pitfalls of things like
unix,
>  > ms/dos, C and C++ gives a programmer a feeling of being important,
almost a
>  > magician. To them Scheme may look too simple to be of interest. If they
only
>  > knew the complexity and abstraction of exploiting all of the
capabilities of
>  > a language like Scheme. Scheme is so simple that is puts you right at
the
>  > core of programming, but that's a boundary many programmers never
cross.
>  > Jos
>  > Jacob J. A. Koot (Jos)
>  > http://home-1.wolmail.nl/~koot
>  >
>
>