I will give a short introduction to programming in the local school to 9-10
year old kids.
I do this in logo with younger (7-8 y) kids but would like to try lisp with
the older ones.
Has anybody tried this ?
I think I will make them play with predefined functions to create 3D objects
(cube, cylinder, etc...). These objects will be shown in OpenGL.
I want to keep it simple like :
(setf cyl1 (make-cylinder :height 100 :diameter 50) )
(move-object-to cyl1 :x 10 :y 20 :z 10)
make and manipulate list of objects
(setf objects (list cyl1 cyl2 cyl3))
Then make small functions like make-table etc...
Marc Battyani
PS: I will wait until the second semester to have them write persistant
objects with MOP...
On Thu, 26 Oct 2000 15:37:29 +0200, "Marc Battyani"
<·············@fractalconcept.com> wrote:
>I will give a short introduction to programming in the local school to 9-10
>year old kids.
>I do this in logo with younger (7-8 y) kids but would like to try lisp with
>the older ones.
>
>Has anybody tried this ?
This people have been doing it for years:
http://www.schemers.com/tsg.html
The bookuses scheme, but it might give you ideas.
//-----------------------------------------------
// Fernando Rodriguez Romero
//
// frr at mindless dot com
//------------------------------------------------
"Fernando Rodr�guez" <·······@must.die> wrote in message
·······································@4ax.com...
> On Thu, 26 Oct 2000 15:37:29 +0200, "Marc Battyani"
> <·············@fractalconcept.com> wrote:
>
> >I will give a short introduction to programming in the local school to
9-10
> >year old kids.
> >I do this in logo with younger (7-8 y) kids but would like to try lisp
with
> >the older ones.
> >
> >Has anybody tried this ?
>
> This people have been doing it for years:
> http://www.schemers.com/tsg.html
>
> The bookuses scheme, but it might give you ideas.
Very interesting!
Thanks,
Marc Battyani
On Thu, 26 Oct 2000 18:41:04 +0200, "Marc Battyani"
<·············@fractalconcept.com> wrote:
>
>"Fernando Rodr�guez" <·······@must.die> wrote in message
>·······································@4ax.com...
>> On Thu, 26 Oct 2000 15:37:29 +0200, "Marc Battyani"
>> <·············@fractalconcept.com> wrote:
>>
>> >I will give a short introduction to programming in the local school to
>9-10
>> >year old kids.
>> >I do this in logo with younger (7-8 y) kids but would like to try lisp
>with
>> >the older ones.
>> >
>> >Has anybody tried this ?
>>
>> This people have been doing it for years:
>> http://www.schemers.com/tsg.html
>>
>> The bookuses scheme, but it might give you ideas.
>
>Very interesting!
The authors have a school in lorida where they teach math and cs to
kids. You might find the url at schemers.com (I lost it). Maybe there's info
about the curriculum... :-?
Good luck
//-----------------------------------------------
// Fernando Rodriguez Romero
//
// frr at mindless dot com
//------------------------------------------------
Fernando Rodr�guez <·······@must.die> wrote:
+---------------
| <·············@fractalconcept.com> wrote:
| >I will give a short introduction to programming in the local school
| >to 9-10 year old kids. I do this in logo with younger (7-8 y) kids
| >but would like to try lisp withthe older ones.
| >Has anybody tried this ?
|
| This people have been doing it for years:
| http://www.schemers.com/tsg.html
+---------------
As have the Rice folks, with their "TeachScheme! Project" high school
computer curriculum:
<URL:http://www.cs.rice.edu/CS/PLT/Teaching/>
They claim over 65 high schools use their stuff (and ~170 universities).
-Rob
-----
Rob Warnock, 31-2-510 ····@sgi.com
Network Engineering http://reality.sgi.com/rpw3/
Silicon Graphics, Inc. Phone: 650-933-1673
1600 Amphitheatre Pkwy. PP-ASEL-IA
Mountain View, CA 94043
"Rob Warnock" <····@rigden.engr.sgi.com> wrote in message
···················@fido.engr.sgi.com...
> Fernando Rodr�guez <·······@must.die> wrote:
> +---------------
> | <·············@fractalconcept.com> wrote:
> | >I will give a short introduction to programming in the local school
> | >to 9-10 year old kids. I do this in logo with younger (7-8 y) kids
> | >but would like to try lisp withthe older ones.
> | >Has anybody tried this ?
> |
> | This people have been doing it for years:
> | http://www.schemers.com/tsg.html
> +---------------
>
> As have the Rice folks, with their "TeachScheme! Project" high school
> computer curriculum:
>
> <URL:http://www.cs.rice.edu/CS/PLT/Teaching/>
I looked at it, but there curriculum is way too advanced for 9-10 year old
kids...
Marc Battyani
>
> I will give a short introduction to programming in the local school
> to 9-10 year old kids. I do this in logo with younger (7-8 y) kids
> but would like to try lisp with the older ones.
>
> Has anybody tried this ?
>
I haven't tried lisp at this age, I use logo in elementary and middle
schools. Have you looked at the 3 volume Computer_Science_Logo_Style
textbooks by Brian Harvey? It is designed to teach computer science
at the high school level, I use it for middle school students. I
generally avoid 2nd grade (7 year old) and below because their
lack of spelling skills causes to many errors. Maybe you students
are brighter.
> I think I will make them play with predefined functions to create
> 3D objects (cube, cylinder, etc...). These objects will be shown
> in OpenGL.
>
> I want to keep it simple like :
>
> (setf cyl1 (make-cylinder :height 100 :diameter 50) )
> (move-object-to cyl1 :x 10 :y 20 :z 10)
>
> make and manipulate list of objects
>
> (setf objects (list cyl1 cyl2 cyl3))
>
> Then make small functions like make-table etc...
>
It is a good idea to start with graphics with the younger students,
but even at 9 their 3d spatial thinking is not well developed.
There is turtle graphics extensions for many lisp packages. It
sounds like your trying to teach ICAD. I would start with students
that knew logo and show them what is the same and what is different.
The biggest difference is that logo has commands that have no output,
and in lisp all functions are like logo operations that have output.
Another difference is that logo shifts gears to return the FIRST of
a word or a list, but in lisp words are strings with separate
operations. For the most part though logo is lisp without
parenthesis.
What lisp are you using (or how can you afford to outfit a computer
lab)? There is a Scheme that has the ASIC solid modeler embedded,
but at $500 a license I couldn't afford to put it on 25 computers.
And what logo are you using? We use the free UCBLogo and StarLogo.
> Marc Battyani
>
> PS: I will wait until the second semester to have them write
> persistant objects with MOP...
Thanks,
Jeff Sandys
Jeff Sandys <·······@asme.org> writes:
> >
> > I will give a short introduction to programming in the local school
> > to 9-10 year old kids. I do this in logo with younger (7-8 y) kids
> > but would like to try lisp with the older ones.
> >
> > Has anybody tried this ?
I've tried a little. I've found a few difficulties.
First, lisp is *very* intolerant of spelling errors, and this leads to
a lot of frustration. An interface with a spelling dwim would be
quite useful.
Second, I found that rather than being `confused by all the parens' as
many adults are, the kids don't seem to see them at all. I have some
wild speculations about this. I think it has something to do with how
natural language deals with sentences. In lisp, you seem have
clauses of the form (verb noun noun noun...) where the nouns are
pretty much direct objects. The subject of the clause is an implied
`you', meaning the computer.
Now in Lisp, it is vital that there be an open-paren before the verb,
and a close paren after the last direct object. The semantic class of
the words that the symbols may spell has nothing to do with it. But
English is not like that. If I command you `lunch! eat!', you
would recognize that the sentence is inverted because lunch is usually
a noun and eat is a verb. Lisp doesn't act that way.
Very often I saw the kids typing clauses without parens at all, and
it wasn't obvious to them that the parens were the key to the whole
thing.
Another problem is the nesting. English doesn't nest very much, maybe
a couple of levels. Sentence clauses don't obviously `return
values'. So something in lisp that might be:
(eat (bake (apply #'mix ingredients) :temp 450))
Is very difficult to express exactly in English. And if you can't say
it, you can't think it. So you would often end up with students doing
things like typing
mix ingredients
at the prompt (generally getting two levels of error handler in the
process), eventually hitting on
(mix ingredients)
And then being at a loss as to how to say `Then bake them.'
I'm not sure what the solution to these problems are. I don't like
the imperative style of LOGO very much (nor do I like it's other
quirks), and I haven't seen a `graphic oriented' language that seems
to be intuitive either.
-----= Posted via Newsfeeds.Com, Uncensored Usenet News =-----
http://www.newsfeeds.com - The #1 Newsgroup Service in the World!
-----== Over 80,000 Newsgroups - 16 Different Servers! =-----
Joe Marshall wrote:
>
> Second, I found that rather than being `confused by all the parens' as
> many adults are, the kids don't seem to see them at all. I have some
> wild speculations about this. I think it has something to do with how
> natural language deals with sentences. In lisp, you seem have
> clauses of the form (verb noun noun noun...) where the nouns are
> pretty much direct objects. The subject of the clause is an implied
> `you', meaning the computer.
>
> Now in Lisp, it is vital that there be an open-paren before the verb,
> and a close paren after the last direct object. The semantic class of
> the words that the symbols may spell has nothing to do with it. But
> English is not like that. If I command you `lunch! eat!', you
> would recognize that the sentence is inverted because lunch is usually
> a noun and eat is a verb. Lisp doesn't act that way.
This is the beauty of logo and the problem of lisp. There are no verbs
in lisp. First, rest, sum and all the other operators are nouns.
S-expressions are noun phrases that evaluate to an object or noun.
Action occurs in lisp as a side effect of evaluating the noun phrase.
In logo there are commands or verbs that cause an action with the noun
object they are given. So the logo syntax is an imperative sentence
starting with a ("you" understood) verb followed by a noun phrase.
> I'm not sure what the solution to these problems are. I don't like
> the imperative style of LOGO very much (nor do I like it's other
> quirks), and I haven't seen a `graphic oriented' language that seems
> to be intuitive either.
Above you argue for an imperative style in lisp but then state that
you don't like logo's imperative style? I am curious what other
quirks you don't like about logo, email me directly if you what to
take this out of the ng.
What lisp has that logo does not is an object oriented system.
Object logo tried and failed. StarLogo has some inheritance and
passes messages between multiple turtles and background cells, but
as a java application it has lost some of logo's lisp like powers
(to deal with functions as data).
The cad systems I use (catia and unigraphics) become intuitive after
about a 100 hours of training (or more). ICAD, a lisp based generative
geometry system, is not intuitive. Turtle geometry seems to have
a low threshold for intuition.
Thanks,
Jeff Sandys
In article <·················@asme.org>, Jeff Sandys <·······@asme.org>
wrote:
> The cad systems I use (catia and unigraphics) become intuitive after
> about a 100 hours of training (or more). ICAD, a lisp based generative
> geometry system, is not intuitive. Turtle geometry seems to have
> a low threshold for intuition.
Macintosh Common Lisp has Turtles in CLOS/Lisp as an example.
If you have MCL, see ccl:examples;turtles.lisp .
One does then write code like this:
(defparameter *t1* (make-instance 'turtle))
(dotimes (i 12)
(right *t1* 30)
(hexagon *t1* 30))
Where hexagon is:
(defmethod polygon ((turtle turtle) side-length number-of-sides)
(let ((angle-increment (/ 360 number-of-sides)))
(dotimes (i number-of-sides)
(fwd turtle side-length)
(right turtle angle-increment))))
(defmethod hexagon ((turtle turtle) size)
(polygon turtle size 6))
Actually this is all nice and simple.
--
Rainer Joswig, Hamburg, Germany
Email: ·············@corporate-world.lisp.de
Web: http://corporate-world.lisp.de/
Jeff Sandys <·······@asme.org> writes:
> Above you argue for an imperative style in lisp but then state that
> you don't like logo's imperative style?
I would never argue for an imperative style in lisp! (The horror!)
I was just making the observation that the way you give instruction to
another human being seems quite different from the way you give
instruction to lisp, and that functional composition (which I believe
to be one of the most tractable models of computation) seems more
difficult to express than sequential commands.
Starting off with `a computer program is just like a recipe from a
cookbook' puts us *immediately* on the wrong track.
I'd like to see a simple, intuitive, general, and extensible model of
computation that is based on `real-world' experience and
understanding, and completely avoids even a hint of imperative style.
It should have obvious concepts of combination and abstraction, and,
(here's the first really trick part) it should be able to express
general recursion and tail-recursion. (I want to approach the concept of
looping not as `repeated imperative actions' but as either an
`iterative improvement' or an `induction'.) The final tricky part
would be that higher order functions should be obvious (things like
mapping, currying).
> I am curious what other quirks you don't like about logo, email me
> directly if you what to take this out of the ng.
I don't want to start the `alt.logo.sucks' thread. I realize that
Logo is more than just a computer language; it is an engineered
archetype used as an illustration of the advantages of certain
socio-political views. (Just try talking about Logo *without*
bringing up the so-called Logo Philosophy.) I don't care to argue
about politics, so I'll just outline my prejudices against logo *as a
computer language*.
Obviously, my first objection is that it is *way* too imperative:
go here, turn that way, do it again. It seems too difficult to easily
express functional composition like the general notion of putting
something on top of something else. The logo books I have
glanced at seem to illustrate that drawing a house involves drawing a
square, moving to the upper left corner, then drawing a triangle,
rather than making a higher order combinator that simply places
drawing A on top of drawing B.
I think that the issue dynamic scoping is a serious problem. I
understand that it is supposed to be a more `accessible' concept, but
it would be better to find some way to make lexical scoping easier to
understand than to teach what I consider a seriously flawed model just
because it is easier to teach.
Quotation is a mess. This is a serious impediment to writing `code
that writes code'.
I don't like the notion of tagging variable names with a colon: it
leads to madness and Perl.
The method to define functions is far too different from the method to
define variables.
Infix notation is just evil.
Degrees are evil.
-----= Posted via Newsfeeds.Com, Uncensored Usenet News =-----
http://www.newsfeeds.com - The #1 Newsgroup Service in the World!
-----== Over 80,000 Newsgroups - 16 Different Servers! =-----
Joe Marshall <···@content-integrity.com> writes:
> I don't want to start the `alt.logo.sucks' thread. I realize that
> Logo is more than just a computer language; it is an engineered
> archetype used as an illustration of the advantages of certain
> socio-political views. (Just try talking about Logo *without*
> bringing up the so-called Logo Philosophy.) I don't care to argue
That's funny; I'd never heard that term before, so I did a quick
Google query. Kinda neat stuff. My elementary school used Logo in
one class, but it was along with a very strict curriculum. ("Class,
we're going to learn how to make a box. Wait, your box is 40 pixels
wide and at an angle. C'mon, get with the program! Everybody make a
30-pixel box.") I remember I was overjoyed when they let me code
BASIC in the corner instead of playing Number Boggle.
--
vsync
http://quadium.net/ - last updated Sat Oct 7 18:53:10 PDT 2000
(cons (cons (car (cons 'c 'r)) (cdr (cons 'a 'o))) ; Orjner
(cons (cons (car (cons 'n 'c)) (cdr (cons nil 's))) nil))
"Joe Marshall" <···@content-integrity.com> wrote in message
·················@content-integrity.com...
> I would never argue for an imperative style in lisp! (The horror!)
> I was just making the observation that the way you give instruction to
> another human being seems quite different from the way you give
> instruction to lisp, and that functional composition (which I believe
> to be one of the most tractable models of computation) seems more
> difficult to express than sequential commands.
>
> Starting off with `a computer program is just like a recipe from a
> cookbook' puts us *immediately* on the wrong track.
>
> I'd like to see a simple, intuitive, general, and extensible model of
> computation that is based on `real-world' experience and
> understanding, and completely avoids even a hint of imperative style.
> It should have obvious concepts of combination and abstraction, and,
> (here's the first really trick part) it should be able to express
> general recursion and tail-recursion. (I want to approach the concept of
> looping not as `repeated imperative actions' but as either an
> `iterative improvement' or an `induction'.) The final tricky part
> would be that higher order functions should be obvious (things like
> mapping, currying).
You said you have tried, but how old were the kids ?
The reason why I want to do it in 3D is to make a bridge between lisp and
the real world.
I will make the kids measure and describe the classroom objects and then
make functions to create these objects and then manipulate lists of objects
with mapping function. Do you think it's too hard?
Marc Battyani
"Marc Battyani" <·············@fractalconcept.com> writes:
> "Joe Marshall" <···@content-integrity.com> wrote in message
> ·················@content-integrity.com...
>
> > I would never argue for an imperative style in lisp! (The horror!)
> > I was just making the observation that the way you give instruction to
> > another human being seems quite different from the way you give
> > instruction to lisp, and that functional composition (which I believe
> > to be one of the most tractable models of computation) seems more
> > difficult to express than sequential commands.
> >
> > Starting off with `a computer program is just like a recipe from a
> > cookbook' puts us *immediately* on the wrong track.
> >
> > I'd like to see a simple, intuitive, general, and extensible model of
> > computation that is based on `real-world' experience and
> > understanding, and completely avoids even a hint of imperative style.
> > It should have obvious concepts of combination and abstraction, and,
> > (here's the first really trick part) it should be able to express
> > general recursion and tail-recursion. (I want to approach the concept of
> > looping not as `repeated imperative actions' but as either an
> > `iterative improvement' or an `induction'.) The final tricky part
> > would be that higher order functions should be obvious (things like
> > mapping, currying).
>
> You said you have tried, but how old were the kids ?
Around 8 years old.
> The reason why I want to do it in 3D is to make a bridge between lisp and
> the real world.
> I will make the kids measure and describe the classroom objects and then
> make functions to create these objects and then manipulate lists of objects
> with mapping function. Do you think it's too hard?
No, I don't think it is too hard. But the obstacles to doing it are
unexpected.
-----= Posted via Newsfeeds.Com, Uncensored Usenet News =-----
http://www.newsfeeds.com - The #1 Newsgroup Service in the World!
-----== Over 80,000 Newsgroups - 16 Different Servers! =-----
"Marc Battyani" <·············@fractalconcept.com> writes:
> The reason why I want to do it in 3D is to make a bridge between lisp and
> the real world.
> I will make the kids measure and describe the classroom objects and then
> make functions to create these objects and then manipulate lists of objects
> with mapping function. Do you think it's too hard?
You could do the measuring part first, and get them comfortable with
the online representation of the measurements. Treat Lisp as just a
funky way to organize data. Then start doing little bits of
calculation with it.
I've gotten coworkers comfortable with Lisp in just this fashion.
--
vsync
http://quadium.net/ - last updated Sat Oct 7 18:53:10 PDT 2000
(cons (cons (car (cons 'c 'r)) (cdr (cons 'a 'o))) ; Orjner
(cons (cons (car (cons 'n 'c)) (cdr (cons nil 's))) nil))
Joe Marshall wrote:
>
> I would never argue for an imperative style in lisp! (The horror!)
Good!
> I was just making the observation that the way you give instruction to
> another human being seems quite different from the way you give
> instruction to lisp, and that functional composition (which I believe
> to be one of the most tractable models of computation) seems more
> difficult to express than sequential commands.
Now I understand your argument. Logo syntax is very much like an
imperative sentence.
> Starting off with `a computer program is just like a recipe from a
> cookbook' puts us *immediately* on the wrong track.
Agreed.
> I'd like to see a simple, intuitive, general, and extensible model of
> computation that is based on `real-world' experience and
> understanding, and completely avoids even a hint of imperative style.
What would such a programming language look like?
Why avoid imperative style? In logo you command an action to take
place, in lisp actions are hidden as a side effect of evaluation.
> It should have obvious concepts of combination and abstraction, and,
> (here's the first really trick part) it should be able to express
> general recursion and tail-recursion. (I want to approach the concept of
> looping not as `repeated imperative actions' but as either an
> `iterative improvement' or an `induction'.)
I teach recursion as the application of a rule and stopping for
the exception, as in every rule has an exception.
> The final tricky part would be that higher order functions should
> be obvious (things like mapping, currying).
Check out Computer_Science_Logo_Style for the implementation of
mapping and lambda in logo.
> Obviously, my first objection <to logo> is that it is *way*
> too imperative: go here, turn that way, do it again.
Logo is both imperative and functional, I think this is just the way
it is taught, see _CSLS_ for more functional examples.
> It seems too difficult to easily express functional composition like
> the general notion of putting something on top of something else.
Logo Computer Systems developed an object system that did this, but
never marketed it.
> I think that the issue dynamic scoping is a serious problem. I
> understand that it is supposed to be a more `accessible' concept, but
> it would be better to find some way to make lexical scoping easier to
> understand than to teach what I consider a seriously flawed model just
> because it is easier to teach.
This is a difficulty. It is hard to prepare students for the eventual
change and it is difficult to explain the difference to someone who
has known only one style.
> Quotation is a mess. This is a serious impediment to writing `code
> that writes code'.
I haven't had this problem, it is simpler than tic, back-tic and comma,
and you can write code that writes code. Since it is interpreted
instead of compiled, you can read a function's code to create new
code.
> I don't like the notion of tagging variable names with a colon: it
> leads to madness and Perl.
UCBlogo has SET that allows variables names without the colon. Lisp
uses colons for keywords. The alternative is to tag each function
name with an open parenthesis. Logo has fewer tag characters than lisp.
Perl is evil. I heard that Larry quit developing Perl because there are
no more special characters on the keyboard ;)
> The method to define functions is far too different from the method to
> define variables.
DEFINE in logo is nearly like DEFUN in lisp.
> Infix notation is just evil.
when mixed with prefix notation.
My struggle is that I want to give young people (4th to 8th graders)
an experience in computer programming. I want it to be real, fun and
easy enough to have a low threshold and complete enough to have a high
ceiling. I believe that Logo meets this criteria and I have yet to
find anything else that does. I believe that even with dynamic scoping
that young people trained in Logo will become better programmers as they
mature than young people trained with other languages. And I believe
that students trained in Logo will have a natural affinity towards lisp
as they mature.
Of course much logo instruction is done by teachers with no computer
science background. The students only learn to make long lists of
commands instead of using their own functions, mapping and other
abstractions.
If there is a free version of lisp that will run on imacs and a
course outline suitable for middle school students, I will start
teaching lisp next quarter. I teach as a volunteer for an after
school programming group. Teachers and schools love volunteers
who can do these type of activities. We all could promote lisp
and create a new generation of lisp programmers with this volunteer
effort.
Thanks,
Jeff Sandys
Jeff Sandys <·······@asme.org> writes:
> Joe Marshall wrote:
>
> > I'd like to see a simple, intuitive, general, and extensible model of
> > computation that is based on `real-world' experience and
> > understanding, and completely avoids even a hint of imperative style.
>
> What would such a programming language look like?
If I knew that.....
> Why avoid imperative style?
I want to avoid side effects.
> > It should have obvious concepts of combination and abstraction, and,
> > (here's the first really trick part) it should be able to express
> > general recursion and tail-recursion. (I want to approach the concept of
> > looping not as `repeated imperative actions' but as either an
> > `iterative improvement' or an `induction'.)
>
> I teach recursion as the application of a rule and stopping for
> the exception, as in every rule has an exception.
There is a certain magic about proper recursion: you actually solve
the problem by assuming you can already solve it. (ok, the recursive
case is a `simpler' problem). But where in real life do you apply
this in an obvious way? (And I mean non-tail-recursively).
> > The final tricky part would be that higher order functions should
> > be obvious (things like mapping, currying).
>
> Check out Computer_Science_Logo_Style for the implementation of
> mapping and lambda in logo.
Yes. You *can* do it, but is it embarassingly simple?
> > Quotation is a mess. This is a serious impediment to writing `code
> > that writes code'.
>
> I haven't had this problem, it is simpler than tic, back-tic and comma,
> and you can write code that writes code. Since it is interpreted
> instead of compiled, you can read a function's code to create new
> code.
Well, the logo-l archive has some interesting arguments about the
differences between RUN vs. RUNPARSE, RAWASCII vs. ASCII, and "
vs. QUOTED. Sure back-tic is tricky, but you can go a long way with
regular old quote.
> > I don't like the notion of tagging variable names with a colon: it
> > leads to madness and Perl.
>
> UCBlogo has SET that allows variables names without the colon. Lisp
> uses colons for keywords.
Colons for keywords aren't so bad because I use keywords so much less
frequently than variables.
> The alternative is to tag each function name with an open
> parenthesis.
Or to have a single namespace.
> Perl is evil. I heard that Larry quit developing Perl because there are
> no more special characters on the keyboard ;)
Maybe he ran out of bad ideas?
> > Infix notation is just evil.
>
> when mixed with prefix notation.
And you have to mix them if you have any procedures with arity not
equal to 2.
> My struggle is that I want to give young people (4th to 8th graders)
> an experience in computer programming. I want it to be real, fun and
> easy enough to have a low threshold and complete enough to have a high
> ceiling. I believe that Logo meets this criteria and I have yet to
> find anything else that does. I believe that even with dynamic scoping
> that young people trained in Logo will become better programmers as they
> mature than young people trained with other languages. And I believe
> that students trained in Logo will have a natural affinity towards lisp
> as they mature.
>
> Of course much logo instruction is done by teachers with no computer
> science background. The students only learn to make long lists of
> commands instead of using their own functions, mapping and other
> abstractions.
>
> If there is a free version of lisp that will run on imacs and a
> course outline suitable for middle school students, I will start
> teaching lisp next quarter. I teach as a volunteer for an after
> school programming group. Teachers and schools love volunteers
> who can do these type of activities. We all could promote lisp
> and create a new generation of lisp programmers with this volunteer
> effort.
Oh, I agree, and I wish you luck. I'm just of the opinion that maybe
logo isn't the best way to teach computer science to younger kids.
This doesn't mean that I know a better way, or that logo is bad, it
means that I think logo has some serious deficiencies that might want
to be rethought.
There are advantages to using logo: the programs are visually
engaging, the teaching community is predisposed toward logo, and there
is a small amount of corporate support.
-----= Posted via Newsfeeds.Com, Uncensored Usenet News =-----
http://www.newsfeeds.com - The #1 Newsgroup Service in the World!
-----== Over 80,000 Newsgroups - 16 Different Servers! =-----
Joe Marshall <···@content-integrity.com> writes:
> I'm not sure what the solution to these problems are. I don't like
> the imperative style of LOGO very much (nor do I like it's other
> quirks), and I haven't seen a `graphic oriented' language that seems
> to be intuitive either.
Have you looked at John Maeda's Design by Numbers project? It's at
<URL:http://dbn.media.mit.edu>
--
chr
"Jeff Sandys" <·······@asme.org> wrote in message
······················@asme.org...
> I haven't tried lisp at this age, I use logo in elementary and middle
> schools. Have you looked at the 3 volume Computer_Science_Logo_Style
> textbooks by Brian Harvey? It is designed to teach computer science
> at the high school level, I use it for middle school students. I
> generally avoid 2nd grade (7 year old) and below because their
> lack of spelling skills causes to many errors. Maybe you students
> are brighter.
No but they are older. As I said I use logo with 7-8 year old students and I
will only try lisp with 9-10 year old students.
> It is a good idea to start with graphics with the younger students,
> but even at 9 their 3d spatial thinking is not well developed.
This is a good point to know. I will be careful.
> There is turtle graphics extensions for many lisp packages. It
> sounds like your trying to teach ICAD. I would start with students
> that knew logo and show them what is the same and what is different.
> The biggest difference is that logo has commands that have no output,
> and in lisp all functions are like logo operations that have output.
> Another difference is that logo shifts gears to return the FIRST of
> a word or a list, but in lisp words are strings with separate
> operations. For the most part though logo is lisp without
> parenthesis.
>
> What lisp are you using (or how can you afford to outfit a computer
> lab)? There is a Scheme that has the ASIC solid modeler embedded,
> but at $500 a license I couldn't afford to put it on 25 computers.
> And what logo are you using? We use the free UCBLogo and StarLogo.
I use my company's computers (PIII 700 400Mb RAM laptops) and lisp compilers
(Xanalys LispWorks).
It could work with the free LispWorks personal edition but I didn't tried.
May be, if it works well, I can deliver a standalone win32 executable.
Marc Battyani
"Wade Humeniuk" <········@cadvision.com> wrote in message
······················@cadvision.com...
>
> >
> > I use my company's computers (PIII 700 400Mb RAM laptops) and lisp
compilers
> > (Xanalys LispWorks).
> > It could work with the free LispWorks personal edition but I didn't
tried.
> > May be, if it works well, I can deliver a standalone win32 executable.
> >
> > Marc Battyani
>
> Here is common lisp ladybug program for kids. They can place and move
> ladybugs and aphids on a capi pinboard. A tar file is attached with
> code and bitmaps for the ladbug and aphid. You will have to modify
> full-capi.lisp so you bitmap load directory is correct.
>
> It may give you some more ideas kids programs.
Yes it's the kind of program I want to to but in 3D.
Did you try it with kids ?
Marc Battyani
> Yes it's the kind of program I want to to but in 3D.
>
> Did you try it with kids ?
>
> Marc Battyani
Yes I did, my own, but there was not alot of interest in the programming
part. That was a few years ago when they were only 4 and 6. I brought
it to my kids elementary school but they ended up using Logo in their
computer club. When I told them the language was Lisp they just gave a
blank stare. They are geting older now, 7 and 9, maybe time to try
again.....
Wade
In article <············@reader1.fr.uu.net>, "Marc Battyani"
<·············@fractalconcept.com> wrote:
> I will give a short introduction to programming in the local school to 9-10
> year old kids.
> I do this in logo with younger (7-8 y) kids but would like to try lisp with
> the older ones.
>
> Has anybody tried this ?
>
> I think I will make them play with predefined functions to create 3D objects
> (cube, cylinder, etc...). These objects will be shown in OpenGL.
>
> I want to keep it simple like :
>
> (setf cyl1 (make-cylinder :height 100 :diameter 50) )
> (move-object-to cyl1 :x 10 :y 20 :z 10)
>
> make and manipulate list of objects
>
> (setf objects (list cyl1 cyl2 cyl3))
>
> Then make small functions like make-table etc...
How about a 3d interface for "Blocks World". ;-)
> Marc Battyani
>
> PS: I will wait until the second semester to have them write persistant
> objects with MOP...
Hey, you should recruit them for the FreeCLIM project. ;-)
--
Rainer Joswig, Hamburg, Germany
Email: ·············@corporate-world.lisp.de
Web: http://corporate-world.lisp.de/
Marc Battyani wrote:
>
> I will give a short introduction to programming in the local school to 9-10
> year old kids.
> I do this in logo with younger (7-8 y) kids but would like to try lisp with
> the older ones.
>
> Has anybody tried this ?
>
> I think I will make them play with predefined functions to create 3D objects
> (cube, cylinder, etc...). These objects will be shown in OpenGL.
>
> I want to keep it simple like :
>
> (setf cyl1 (make-cylinder :height 100 :diameter 50) )
> (move-object-to cyl1 :x 10 :y 20 :z 10)
>
> make and manipulate list of objects
>
> (setf objects (list cyl1 cyl2 cyl3))
>
> Then make small functions like make-table etc...
>
> Marc Battyani
>
> PS: I will wait until the second semester to have them write persistant
> objects with MOP...
Funny!
This is (almost) the purpose of an undergraduate research project I
worked on with my comrades.
We actually implemented a functionnal OpenGL subset (the most used
primitives) in Common Lisp from scratch (CMU/CL, CLX, Linux). We do
ligting, but no texturing, and we can only display in 320*200 in a X
window. The animation speed is about 1/4 of MesaGL, too (not enough time
to optimize a lot).
Maybe you should consider using a MesaGL interface for optimal speed,
but I don't know the exact consequences or restrictions this choice
would imply.
I'd be happy to learn more about this...
--
----------------------------
Bailleul Jonathan
DEA Informatique
LaBRI, Universite Bordeaux I
"Jonathan BAILLEUL" <········@labri.u-bordeaux.fr> wrote in message
······················@labri.u-bordeaux.fr...
> This is (almost) the purpose of an undergraduate research project I
> worked on with my comrades.
I'm happy to see that there are still a few French universities that use
lisp. (I learned LELISP on a TRS80 a long time ago). I hope that we will add
the primary school of Hericy (near fontainebleau) to them...
> Maybe you should consider using a MesaGL interface for optimal speed,
> but I don't know the exact consequences or restrictions this choice
> would imply.
I will use OpenGL under W2K.
I've been converted to FreeBSD by this newsgroup but I don't think there are
optimized OpenGL/MesaGL drivers for FreeBSD.
> I'd be happy to learn more about this...
I told them to make a 3D representation of their classroom so that I can put
it on a web site.
Marc Battyani