Your introduction to Lisp...
Damond Walker
it's Lisp. How about relaying how you "came to Lisp?"
For me it was in an academic setting. Last semester in college I took
an AI class. It was one of those 400 level "broad introduction" type
of classes. While the Prof. read from the book (for the most part)
during class she would assign problems every two weeks covering some
aspect of AI. These problems would typically be based on search trees
and developing heuristics to trim the tree down to an acceptable
level.
It was more fun than anything else.
As with all classes (at least that's what it seemed like to me) we had
a final independent project. About 1/2 way through the semester we
had to fill out of "project request" which basically asked for a
"class" of project. I scribled "game" and handed it back. All was
well.
Like most things in school I pushed it off until the last minute. The
class met three times a week. On one Wednesday the first student got
in front of the class to give their presentation.
"Holy crap!", I thought. I hadn't even started mine yet! I found my
number in the rotation and I had to give my presentation on Monday. I
left the class a bit shaken that day. Friday rolled around and two
more students gave their presentation.
I went home after that class and started thinking about a game. I
ended up choosing to implement a game of Broadsides by Milton Bradly
(summary: Move sailing ships on a board, sink opposing ships, person
with last ship is winner).
So, at about 2 PM, I downloaded a copy of XLisp 2.0 from an FTP site
and started working.
The version of XLisp that I downloaded didn't support graphics of any
sort (I was doing this during the Windows 3.1 days) so I started
searching for the sourcecode, found it, examined it, and started
hacking additions to XLisp to support VGA grahpics and the mouse (it
turned out to be about 300-400 lines of C to add all the things I
wanted). By 3AM I had my version of XLisp working like a peach and I
crawled into bed.
The next morning (around 9 AM) I started working on the project
proper. It was rough the 1st few hours as I meandered around xlisp
for a bit. False starts, fidgets, etc. But by around 3 PM it all
started to gell. It was my "ah ha" experience.
From 3 PM till about 1 AM it turned from programming to "expressing
ideas." It went from pure act of coding to an act of "describing the
situation" to the interpreter.
By Sunday morning I had the game playing itself. It was quite
disturbing to me to see the program play semi-intelligently against
itself. I watched it over and over again (for about an hour) but
playing games -- game would end and a new one would start.
I could of stopped here -- it was a game, it played itself according
to the rules of the original game but I proceeded to add code to allow
a human player to play as well. This took about two hours to
implement fully.
The AI aspects of the game weren't on the high-order of quality:
hacked minimax routine (four ply at first but trimmed to 2 so you
didn't have to sit for 20 minutes between moves. 2 ply was almost
instantaneous), move generation, book moves (to start the game),
choosing a "bad move" occasionally in the hopes of luring the human
player into a better situation, etc.
The computer captain could be tuned by assigning values to three
weight variables at the head of the program. You could tell the
computer captain to really push it on the map (causing damage is the
most important thing) or to be cautious (avoiding damage is most
important). You typically ended up with a computer player who threw
caution to the wind or ran from fights. Twiddling with the weight
variables could even land you in the middle of this realm (the
computer captian would cause damage if possible but avoid 1:1
exchanges if possible).
By sunday night I had the game done. It was around 2000 lines of Lisp
code, another 300-400 lines of C, and a 5 page paper which described
the algorithms I used.
I gave my presentation Monday morning and, honest to god, mouths hit
the floor. I had a few fellow students actually get mad at me. My
ego was pretty inflated at the time. I think the prof still uses the
game as an example here and there. I got a 97% on it -- she took
points off for a spelling error in one of the comments. :)
I still have the final paper at home someplace.
Anyway, that was my first *real* exposure to Lisp programming. A
panic ridden hectic weekend -- looking back on it it was great.
And to be honest it's all been downhill since. But in a good way. ;)
Damond
Espen Vestre
> How about relaying how you "came to Lisp?"
I "came to lisp" because it was the operating system of the machine I
used for Prolog programming!
(as part of my masters thesis, I was developing a question-answering
in Prolog, and the (cool!) tool I used for that was Xerox Quintus
Prolog, which ran on Xerox Lisp Machines...)
--
(espen)
Nils Goesche
> I'm always interested in how people "came to something." In this case
> it's Lisp. How about relaying how you "came to Lisp?"
Pretty uninteresting story... I figured out how to use setq for
configuring Emacs, first; the info pages mentioned something called
``Common Lisp'', but I didn't care what it was, just guessed it
would be something horribly complicated. Then I'd learn more of
Emacs Lisp and began to like it, somehow. At some point, I got
flamed in gnu.emacs.help by a certain E.N., because I made
it quite clear that I thought that everybody who didn't know that
C is the greatest of all languages, must be either a newbie or
a total moron. I was quite impressed, asked him, what /his/
favorite language was, and decided to find out more about it.
I learned a bit of Common Lisp, liked it and started to learn
a whole bunch of other languages, too. After becoming quite
disillusioned about a lot of hype languages, I returned to Common
Lisp and started studying it thoroughly. I am still busy...
Regards,
--
Nils Goesche
"Don't ask for whom the <CTRL-G> tolls."
PGP key ID 0x42B32FC9
cr88192
> it's Lisp. How about relaying how you "came to Lisp?"
>
calculus, along with some other math related stuff), then they gave a few
examples that were in scheme... little reaction (as then I had thought is
was just a mathematical representation language...).
later while looking at info I noticed a description of rep, so I decided to
look at it. what I saw was interesting.
over time (along with comments from some people) I learned more about it...
it seemed more interesting the more I saw of it. got better tools, and
learned the difference between cl and scheme.
as of yet I am still more on the scheme side of things than the cl side of
things though.
all this has been over the past few months.
all the while I have been focusing attention on other projects (currently
on my os). current objectives are to figure how to unify my os project and
my fiddling with scheme... I figure cl might be a little harder to
implement, but I am not sure...
I have at current read r5rs, but not yet the ansi spec. I have implemented
a basic scheme->assembler compiler as well, which I am using as the basis
for compilation related fiddling...
sometimes I wonder if I should come up with names for my projects, but for
now there is no need.
how about I use my initials: bgb os, bgb scheme->assembler compiler, ...
Christopher C. Stacy
I learned FORTRAN, BASIC, and survey/dabbled in COBOL, PL/I,
assemblers, and a few others. Then after a couple of years I
discovered and thought that was the greatest thing. My first
exposure to LISP was late in high school on the MIT systems
(via the ARPANET), and LISP quickly replaced APL as the language
of choice. In the meantime, of course, I've learned lots of
other languages, most recently including JAVA a few of years ago.
LISP remains "the best" (for most purposes) in my book.
Frank A. Adrian
course, we didn't move much beyond the standard "write append using only
cons" stage of Lisp development. And, of course, this was done on a CDC
Cyber 175 using (I kid you not) UT Lisp. This odd MACLisp-like
implementation actually had four fields in each cons cell, the car, the
cdr, the cxr, and a six-bit bonus field that I don't remember the name of
(It had to do with the fact that the machine had 18-bit addresses and
60-bit words - Seymour Cray had a wicked sense of humor :-). Although the
language (and recursion) made immediate sense to me, I didn't see the charm
of it.
The next time I met Lisp, it was while working in IC-Design tools. Many of
the early IC design tools used Lisp as their underlying language (mainly
tools from the MIT and CMU) - in fact a friend of mine got a job at Analog
Devices back when they were writing custom CAE tools on Lisp Machines. I
really liked the use of S-exprs as interchange formats and wanted to start
looking at Lisp again - this was during the AI boom and it seemed that
doing IC design tools in Lisp was a great way to do things. Also studying
computer architecture at the time, I noticed the work at MIT on the Scheme
chip (although Scheme is NOT Lisp) and all of that got me looking at Lisp
again.
Being a slow beginner, I took a graduate-level AI course where we used
Franz Lisp and, at that point, officially fell in love with the language.
Never being able to get the companies I worked for to try Lisp on their own
products I got my hands on implementations on a catch-as-catch-can basis -
I got a copy of InterLisp VAX from ISI while I was at Tektronix; while
working for Mentor Graphics I got a copy of Apollo's initial lisp (a
bastardized version of PSL);` got a copy of Lucid when they put themselves
on the Apollo. I also found an old Tektronix 4044 AI workstation (actually
a Smalltalk machine, but it also had a Lisp subsystem built in) that I
learned Flavors on.
When the first trial and free versions of Common Lisp were available for
download, I got them all. CLOS made immediate intuitive sense (and God
knows I didn't miss double dispatch from my Smalltalk days at ParcPlace
Systems :-).
In any case, I've been hacking around with Lisp ever since. I do all of my
own coding in Lisp when I'm not working for my day job. It's a good life.
faa
Mark Dalgarno
> I'm always interested in how people "came to something." In this case
> it's Lisp. How about relaying how you "came to Lisp?"
After I graduated in 1986 I was looking for a job which combined my
interests in AI and Computer Graphics. I spotted an ad in a national
newspaper for a small start-up company looking to recruit Lisp
programmers to develop a CBT authoring system.
I started work as a junior developer three weeks later - I had a quick
look at Cambridge (?) Lisp on the BBC Micro in those intervening weeks
but this didn't prepare me for my first day when I was shown my desk
on which sat the monitor for my Symbolics 3610 and its accompanying
manuals.
I've been lucky enough to stay with Lisp at other companies since that
time.
Mark
Jacek Generowicz
> I'm always interested in how people "came to something." In this case
> it's Lisp. How about relaying how you "came to Lisp?"
As an undergrad I had a brief brush with Lisp in a tiny course. It
mostly required me to fiddle around with lists, and, as such the
most remarkable thing about the language was probably the abundance of
parentheses.
Years later, after countless battles with C++ compilers (by this time
having discovered in Python a great tool for developing ideas) I began
thinking that, surely, it must be possible to have a language
implementation which allows you to develop interactively, while
admitting the possibility of compiling the whole lot when you are
finished. Similarly I lamented not being able to have the _option_ of
specifying variable types. While looking forward to the day when
someone somewhere develops such a language, I searched around to see
whether anyone was working on anything like what I had in mind, and
stumbled across Dylan. I didn't really get around to doing anything
with Dylan (and it didn't seem to be thriving), but when I came back
to look at it again, I noticed, to my surprise, that it was derived
from Lisp. This led me to alu.org.
What I found there made my chin drop to the floor.
Actually, around the python community there are vibes to the effect
of `this is better in Lisp' or `we got this from Lisp': I suspect they
encouraged me to have a look at Lisp too.
In a way Lisp has messed up my enjoyment of programming: on the one
hand I get almost no opportunity to use it, play with it, or try to
learn it properly; on the other it has made me hate programming in
anything else.
Michael Hudson
> In a way Lisp has messed up my enjoyment of programming: on the one
> hand I get almost no opportunity to use it, play with it, or try to
> learn it properly; on the other it has made me hate programming in
> anything else.
:)
I'm fairly sure that in the introduction to a fairly well known Lisp
book there's a paragraph along the lines of
Be careful about learning Lisp; it may make programming in lesser
languages seem painful.
I thought it was in Graham's ANSI Common Lisp, but I couldn't find it
in there.
Anybody know what I'm talking about?
Cheers,
M.
--
Counting lines is probably a good idea if you want to print it out
and are short on paper, but I fail to see the purpose otherwise.
-- Erik Naggum, comp.lang.lisp
Wade Humeniuk
news:63637457.02040...@posting.google.com...
> I'm always interested in how people "came to something." In this case
> it's Lisp. How about relaying how you "came to Lisp?"
I started programming in 1977, my first year of university. Programming was
hardly the big thing then, video terminals had just been introduced and all
people programming, me in Basic and the older computer science students were
all in one room. Just by talking with other people, being curious in what
they were doing, and showing what I was doing, I had a conversation with
someone who showed me a text book with a Lisp compiler in it. I looked at
the few pages of code and was just baffled. I could barely follow it. My
first experience with Lisp. Anyways, computer science was not my area, I
just did the first introductory course to computing and continiued on. Over
the next few years I would hear mention of it, its connection with AI, its
expressive power. But I found I had no use of programming back then.
I was not until later after working as a programmer, first Cybil (a CDC
version of Pascal), then C, and then C++ that I introduced myself to Lisp.
I joined the ACM and got the magazine that profiled Lisp's uses and
contributions. Since I am always looking for better ways to do things, the
G2 article especially got my interest since I was working on Real-time Data
Acquisition and Control software at the time. I decided to just go ahead
and learn Lisp. I had heard all the jokes about Lisp at the time, but I
really never paid them much attention, Lisp had supporters and was obviously
important in coumputer science, and I was determined to fix my first
illiterate experience with Lisp.
To my surprise Lisp solved many of the programming problems that I had to
deal with everyday. Simple things like built in list manipulation, which I
seemed to be doing over and over again in C. Then I got to like the syntax,
especially with the new indenting styles. The rest is history. I have been
pleased at how well CL has been thought out and honed by actual use. Its
lacks the clutter of many other languages and allows me to get to the
central ideas directly. I think of it a my formal description language,
allowing me to state the problem and the solution all in one language.
Wade
Chris Perkins
but it always just looked like a lot of parenthesis and I had been told that
it was just for AI. So I never gave it much thought.
However, over the years, I developed a VERY big list of things I wanted from
a programming language. I was entertaining the idea/fantasy that I would
someday make such a language, or perhaps a tool that would overlay the
aspects I wanted on top of C. Dynamic code generation was near the top of
the list, morphing classes, seamless interchangeable data types (vector,
tree, set, etc.). And so on.
Ironically, several years ago I developed a high speed graphic application
that used self modifying code to pre-calculate the ideal inner loop and then
build and run that loop. And, some of the sources that helped guide me were
different newsgroup postings, etc. from John Foderaro. I had no idea he
worked with Lisp, I just thought he was some self modifying code guru.
Anyway, last year I saw an article reference on Slashdot. Paul Grahams
"Beating the Averages". http://www.paulgraham.com/avg.html The article
resonated with me, since our company has only two programmers. Plus his
description of Lisp was fascinating. I followed much of it, but couldn't
figure out what he meant by "lexical closures".
So I bought Paul Graham's "ANSI Common Lisp" book, and was amazed. Almost
every item on my fantasy list for a programming language was in Lisp. So
now I'm in love with the language. I've written little things, and am
working on a side project. I've gotten a bunch more books. And, of course,
I read this newsgroup. It is my professional dream that one day I'll
develop and market a product written in Lisp. But to-day I return to C
(sigh).....
Chris Perkins
http://www.medialab.com
Wolfgang Mederle
> I'm always interested in how people "came to something." In this case
> it's Lisp. How about relaying how you "came to Lisp?"
It seems like a had the advantage of not coming to Lisp via an AI class
doing lots of list operations. I'm a student of Computational
Linguistics, but Lisp is not on topic here anymore. The languages taught
are Prolog (which I don't like too much, but it may be due to the fact
that I still did not comprehend it), Perl, Java, C, and C++.
My first experience with computers was a CP/M system at age 11, for
which I had no documentation other than a book about Basic
programming. I spent countless hours doing this. Then, for many years I
did not use computers at all (no one bought one for me), until I started
to study Industrial Management and used a computer for writing scripts
and explore the internet. After a few months I got fed up with Windows
and dove into the Linux world. Along with Linux came the most
fascinating application I knew so far: Emacs. And I found out how much I
was interested in working with computers. So I switched my major and
started to do something I like.
Then, one day I stumbled upon an article about a Lisp anniversary (must
have been the 40th), which basically said that Lisp was one of the
oldest programming languages still in use. That made me curious. I
started to search the web for Lisp, and then the library of our
department (full of good Lisp books, mostly from the 80s, barely read in
the last years), and what I found got me hooked. For me, a programming
language is a means to translate my thoughts into something the computer
can understand, and Lisp seems to fit better to the way I think than any
other language I know. I'm still a beginner to Lisp, but I can honestly
say that this is the first time after writing Basic as a child that I
really enjoy programming.
The people using Lisp also seem to be of a different kind than those
using the mainstream languages. This is the only newsgroup related to
programming I read for more than a few days. That has to mean something,
because I'm bored easily.
Felt good talking about it. Back to lurking now.
--
Wolfgang Mederle
$BONMOT
cr88192
seen (though if I wanted I could offer them as extensions in my system...).
>
> So I bought Paul Graham's "ANSI Common Lisp" book, and was amazed. Almost
> every item on my fantasy list for a programming language was in Lisp. So
> now I'm in love with the language. I've written little things, and am
> working on a side project. I've gotten a bunch more books. And, of
> course,
> I read this newsgroup. It is my professional dream that one day I'll
> develop and market a product written in Lisp. But to-day I return to C
> (sigh).....
>
c is one of those inescapable ones, mostly as some things needed to be done
in my type of projects aren't really as possible in lisp.
I am using for my lisp (actually scheme, but close enough) code my own
compiler which luckily I can customize for some of the lowlevel stuff in an
os (ie: assembly code). most of my os is still in c, but there are a few
scheme fragments around. my plan (beyond improving the compiler) is to make
it capable of outputing code for itself, to run in the kernel (and thus, I
will have a self modifying kernel...).
unlike other os projects I seem to have forgon most of the more "basic" os
issues, ie: I don't have processes...
currently some lisp issues have not been resolved either (my mm is wasteful
with consing, and in my compiler I lack a good idea on how to handle tail
calls).
for all that want a cl os, I don't feel up to writting cl on my own, and
scheme seems close enough.
(maybe though I should work more on my stuff than usenet postings
though...).
Shahen
>
> I thought it was in Graham's ANSI Common Lisp, but I couldn't find it
> in there.
>
> Anybody know what I'm talking about?
>
The reward for your efforts will be an equivocal one: you will feel as
suffocated programming in C++ as an experienced C++
programmer would feel programming in BASIC.
Graham, ANSI Common Lisp, p. 2
Paolo Amoroso
wrote:
> I'm always interested in how people "came to something." In this case
> it's Lisp. How about relaying how you "came to Lisp?"
I came to Lisp in a fairly typical and possibly unglamorous way.
In 1990 I attended an introductory programming class at the computer
science department of the University of Milano, Italy. At the first lesson
the instructor announced that we would have used a programming language
called Scheme, and a textbook titled "Structure and Interpretation of
Computer Programs" (the class covered the first 3 chapters).
At the time I had never heard of neither Scheme nor the book. But I did
superficially know about Lisp's stereotypes.
I immediately and instinctively liked the language for a number of reasons,
not all of which I am able to formalize. I was particularly impressed by
the equivalence between code and data, and by the typical development
environments' interactivity, integration and ability to evaluate
arbitrarily simple expressions.
Interestingly, although I was aware of the stereotypes and jokes about
parentheses, they were _never_ an issue for me. I think I was able to
correctly use them in a matter of hours, even without a computer-based
editor. Indeed, although I bought TI PC-Scheme 3.03 for MS-DOS just a few
days after the start of the class, I got my new laptop only a couple of
months later because of a delivery delay.
SICP told that Scheme was a member of a larger family of languages[*], and
I began learning more about Lisp, its history and its community. I
eventually run across Common Lisp, and liked it.
At the time of the Scheme class I shared the common view--no pun
intended--that its beauty comes from its conceptual simplicity and
cleanliness. But when I found Common Lisp, I liked it even more: its design
tradeoffs and the wisdom with which it approaches real world issues looked
beautiful to me.
Lisp was the only language with which I felt really productive, and I
decided to learn it as well as I could, and use it for all my programming
projects.
Paolo
[*] It actually made some stronger statements, but you get the picture :)
--
EncyCMUCLopedia * Extensive collection of CMU Common Lisp documentation
http://www.paoloamoroso.it/ency/README
[http://cvs2.cons.org:8000/cmucl/doc/EncyCMUCLopedia/]
Paolo Amoroso
> lisp has many of the good features I wanted, but a few ones have yet to be
> seen (though if I wanted I could offer them as extensions in my system...).
Which features are you missing?
Paolo
cr88192
>> lisp has many of the good features I wanted, but a few ones have yet to
>> be seen (though if I wanted I could offer them as extensions in my
>> system...).
>
> Which features are you missing?
>
giving/taking tags, and by which a predicate could be specified to
allow/deny access based on those tags.
I know there were others, I just can't think of them now...
(can't really write, am in a bad mood, just now after 3 hours am I stable
enough to try to write...). what exists of my life is comming apart, ever
had the experience where you hate yourself because of how you feel, you
can't leave because of it, and staying isn't really possible because of the
pain involved. part wishes they would just leave so that the pain would
stop, but at the same time you don't want them to leave because of the loss.
even when I try to be all that was wanted of me that is still not good
enough, and now I feel more like a target; I wonder if there is anything I
can do to fix things, but I don't know (she is doing all that she complains
of in others...). I feel that things are breaking down, that this is near
the end (where part of me actually hopes for that...).
maybe everything will be better later, I am probably just misinterpreting
things.
sorry about being off topic, just there is no one really to tell.
Rahul Jain
> well, a system by which access to code/data could be restricted by
> giving/taking tags, and by which a predicate could be specified to
> allow/deny access based on those tags.
If you restrict the code to not being able to create pointers from
integer values, then you'll be fine with simply passing references
where you want them to be passed. If you want to have multiple "views"
of a single object, I don't think you can in Lisp. You'll just have to
create wrapper objects and have the references in them change based on
the changing access permissions you'd like to give.
> [...]
> sorry about being off topic, just there is no one really to tell.
An unfortunate situation, but I guess you can't change others unless
they are willing. I hope things get better soon.
--
-> -/ - Rahul Jain - \- <-
-> -\ http://linux.rice.edu/~rahul -=- mailto:rj...@techie.com /- <-
-> -/ "Structure is nothing if it is all you got. Skeletons spook \- <-
-> -\ people if [they] try to walk around on their own. I really /- <-
-> -/ wonder why XML does not." -- Erik Naggum, comp.lang.lisp \- <-
|--|--------|--------------|----|-------------|------|---------|-----|-|
(c)1996-2002, All rights reserved. Disclaimer available upon request.
cr88192
> cr88192 <cr8...@hotmail.com> writes:
>
>> well, a system by which access to code/data could be restricted by
>> giving/taking tags, and by which a predicate could be specified to
>> allow/deny access based on those tags.
>
> If you restrict the code to not being able to create pointers from
> integer values, then you'll be fine with simply passing references
> where you want them to be passed. If you want to have multiple "views"
> of a single object, I don't think you can in Lisp. You'll just have to
> create wrapper objects and have the references in them change based on
> the changing access permissions you'd like to give.
>
not quite, it is not so easy to describe though.
consider:
(allow (defun foo (x) (* x x)) (and (has :system) (not (has :script)))
and elsewhere:
(progn ;can access foo
(apply :script
(foo 5))) ;error, as here foo is inaccessible here
ok, these semantics will need some work, but I hope this portrays my idea...
>> [...]
>> sorry about being off topic, just there is no one really to tell.
>
> An unfortunate situation, but I guess you can't change others unless
> they are willing. I hope things get better soon.
>
we have been together for nearly 2 years now...
about 1 year ago there was an agrument, then things were better for a few
months. that soon wore off, but things were not too bad. more recently
there have been more problems, then she was nice (for one day, probably
relating to me talking about leaving before that), and since she has been
quite a bit worse (about a month now)...
when I complain to her about it she says there is no problem. I have wanted
to leave but she has not wanted me to leave (for some reason I can't quite
figure out, if she cared about me she would probably treat me better).
anymore I am running out of options (not like I want to anyways).
I hope I am not too harsh on her.
Thomas F. Burdick
> I'm always interested in how people "came to something." In this case
> it's Lisp. How about relaying how you "came to Lisp?"
Okay, I'm avoiding doing useful work tonight, so I'll put my story in
this thread, too.
The first Lisp I used was Emacs Lisp, but never in any more of a
sophisticated manner than using my .emacs as a strangely-formatted
config file. I've been programming since I was 11 when my uncle
taught me BASIC, and I've been big on learning new languages ever
since I realized that there was more to the world than BASIC[*].
After a couple friends recommended that I read _The Little Schemer_, I
did. One recommended it as a cute book for me to read, the other as
something I could share with my friends and family to help explain
computer science[**], which is a lot harder than explaining the appeal
of, say, biology or chemistry. I tore though it in a couple days, and
decided to learn Scheme. After going through most of _Structure and
Interpretation of Computer Programs_, I tried doing some of my
programming in Scheme, instead of the C++ and Objective-C I was using
at the time. I found it difficult to get real work done in Scheme, so
I quit it. About 6 months later, when I was explaining my latest hack
to g++ to try to fix problems in the language, a friend recommended I
learn Common Lisp, and told me that it was related to Scheme, but more
of a language for engineers, and less for mathematicians with
chalkboards. I got Paul Graham's _ANSI Common Lisp_ and _On Lisp_
(both on sale), and started learning Lisp. At first I didn't like it
as much as Scheme ... except for macros. Macros solved that yearning
that actually had me hacking at the internals of g++. I worked
through the generally messy feeling I got from the rest of the
language, until I hit a point where I was usefully productive. Once I
knew enough of the language to see how it all fit together, it felt a
lot less messy, and I fell in love. Since that time about 2.5 years
ago, I've been writing 80%[***] or so of my non-work code in CL.
[*] I've heard accusations that BASIC damages the minds of budding
programmers, but for me it was vital to learning Lisp. The BASIC I
wrote was very structured, but not in the sense of Structured
Programming. It rarely used formal control structures (I almost never
used DO...WHILE), and was full of carefully crafted control using
GOTO. I wrote using flow-charts. When I later learned Pascal and C,
I thought the whole Structured Programming thing was very cool, but
absolutely did *not* think there was anything wrong with my old style
per se, just that it needed to be used judiciously (and I still write
that way on occaision because it's fun, and occasionally the best
way). When I learned Scheme and how to do *everything* with
recursion, I thought it was cool, but I did not think there was
anything wrong with my previous Structured Programming ways, just that
they were sometimes the clearest way to express a problem, and
sometimes not. So when I came to Lisp from Scheme, I had the
advantage of not having been a recursion-fanatic. I used it a lot
because it was fun, but I didn't think there was anything dirty about
DO (except the syntax). All thanks to BASIC and flow charts :)
[**] I do think this was a good recommendation, because it streaches
their brains in ways similar to how other parts of CS do mine.
[***] The other 20% are divvied up between Emacs Lisp -- which I
learned somewhere along the way --, C++, C, x86 assembly language,
SPARC assembly language, Smalltalk, and Perl.
--
/|_ .-----------------------.
,' .\ / | No to Imperialist war |
,--' _,' | Wage class war! |
/ / `-----------------------'
( -. |
| ) |
(`-. '--.)
`. )----'
Patrick W
> I'm fairly sure that in the introduction to a fairly well known Lisp
> book there's a paragraph along the lines of
>
> Be careful about learning Lisp; it may make programming in lesser
> languages seem painful.
>
> I thought it was in Graham's ANSI Common Lisp, but I couldn't find it
> in there.
>
> Anybody know what I'm talking about?
You're talking about Chapter 1 of Paul Graham's "On Lisp":
"[...] the greatest danger of Lisp is that it may spoil you. Once
you've used Lisp for a while, you become so sensitive to the fit
between language and application that you won't be able to go back to
another language without always feeling that it doesn't give you quite
the flexibility you need."
I've found this to be true, but I'm not sure the reasons for this are
technical. I enjoy Python as much as Lisp, and I don't feel frustrated
by a lack of flexibility in Python. But my enjoyment of Lisp is
qualitatively different.
I've never heard anyone mention this topic in relation to programming,
and I've wondered about it for a while. My curiosity has now got the
better of me. So here's a casual question for anyone interested.
On dreams:
Assuming you have programming-related dreams (as I do), did you notice
that your dreaming patterns changed when you started using Lisp? (Or
some other language?)
Between shallow sleep and full waking consciousness, I often grapple
clumsily with programming problems. Most of the thoughts and
situations are ludicrously illogical, which makes them difficult to
describe. Common themes are, for example, tracing "pointers" through
decrepit factories and warehouses, falling off the end of an array of
blocks or crates, navigating through complex mazes of grids, finding
elevator floors mapped to different levels of indirection, and so
on. They're usually mind-bogglingly stupid and annoying real world
metaphors mapped to logical problems or vice-versa. (Occasionally they
are beautiful and brilliant, but that's the exception to the rule).
When I'm using Lisp, I find that these dream-like thoughts became
quite different. They are still illogical on waking, but they're much
more harmonious. Themes of order and symmetry replace the usual
struggle with annoyances. Sleep is more restful and satisfying.
Obviously, for whatever reason, Lisp creates less mental friction for
me than other languages.
Whatever the cause, it is *not* the result of greater familiarity with
Lisp. I know other languages much better than I know Lisp.
I've heard many people wax lyrical about the "QWAN", but I've never
heard anyone else describe being snugly cradled between the parens at
night. Perhaps it's just an oddity of mine. Any comments?
Rahul Jain
> When I'm using Lisp, I find that these dream-like thoughts became
> quite different. They are still illogical on waking, but they're much
> more harmonious. Themes of order and symmetry replace the usual
> struggle with annoyances. Sleep is more restful and satisfying.
> Obviously, for whatever reason, Lisp creates less mental friction for
> me than other languages.
Sounds to me like you've discovered that Lisp is a language meant to
be molded into whatever you feel like having. Therefore, the only
mental friction is that of your own mind resisting doing what it wants
or understanding the base language enough to implement what it
wants. Seems rational to me that this would cause less mental
friction. :)
Rahul Jain
> not quite, it is not so easy to describe though.
> consider:
> (allow (defun foo (x) (* x x)) (and (has :system) (not (has :script)))
>
> and elsewhere:
> (progn ;can access foo
> (apply :script
> (foo 5))) ;error, as here foo is inaccessible here
>
> ok, these semantics will need some work, but I hope this portrays my idea...
Heh, you hit on the second part of the system, controlling access to
global information. Global variables and functions can be protected by
preventing access to the symbols that name them. I'm actually
developing something to do this for DefDoc (as though I'll ever
actually do it :P) which involves both a customized reader and a
package that wraps all of the CL package in security-checking code.
Michael Hudson
> Michael Hudson <m...@python.net> writes:
>
> > I'm fairly sure that in the introduction to a fairly well known Lisp
> > book there's a paragraph along the lines of
> >
> > Be careful about learning Lisp; it may make programming in lesser
> > languages seem painful.
> >
> > I thought it was in Graham's ANSI Common Lisp, but I couldn't find it
> > in there.
> >
> > Anybody know what I'm talking about?
>
> You're talking about Chapter 1 of Paul Graham's "On Lisp":
>
> "[...] the greatest danger of Lisp is that it may spoil you. Once
> you've used Lisp for a while, you become so sensitive to the fit
> between language and application that you won't be able to go back to
> another language without always feeling that it doesn't give you quite
> the flexibility you need."
Thank you, that's the one.
Cheers,
M.
--
>> REVIEW OF THE YEAR, 2000 <<
It was shit. Give us another one.
-- NTK Know, 2000-12-29, http://www.ntk.net/
D. Goel
> On dreams:
heh.. i often have dreams in which the world is written in lisp.. one
night i fixed my car (an old old old car..) .. which of course, was
written in lisp..
Paul Tarvydas
(using Siklosky's "Let's Talk Lisp"). I was baffled by it and intrigued
that I'd encountered a language that I couldn't master.
Around 1975/76 I wire-wrapped a Z80 board (schematic was the center-fold of
the first anniversary issue of Byte magazine), with 2K of static RAM and 10K
of dynamic (yes, 12K, as in "kilo" bytes total RAM) and ported various Tiny
Basics to it. Probably in Dr. Dobb's, I found out about Fritz van der
Wateren's Lisp for the 6800, purchased a copy (it came printed in a booklet
with commented 6800 assembler code) and sight-read it into the Z80 (the 6800
version was 4K in size, the Z80 transliteration was 5K).
Once running well (the final GC glitch (a sight-reading typo) was found
about 6 months later :-), I wrote a simple editor and debugger in lisp and
sent an article in to DDJ ('78, '79?). I had mono at the time, so I dropped
out of school for a term and had lots of spare time to kill. The article
was printed on an IBM Selectric typewriter with 11 solenoids, which I'd
salvaged from a Wang word processor.
I typed in the Lisp compiler from John R. Allen's "Anatomy of Lisp" (lots of
typos in the edition of the book I had) and got it running, emitting Z80
binary. I had enough of the 12K[*] left over to hold the source code for an
"iota" function (see APL), to compile it and run it.
pt
[*] My recollection is a bit hazy. At some point, I coaxed the dynamic RAM
up to 23K [sic - I was using bargain bin TMS 22-pin dynamic RAM chips for
which I had incomplete specs; it turned out that my cpu timing was marginal
for the RAM, but would work if I added entropy to the wire wrapping job]. I
might have built the Lisp compiler only after I had doubled the memory :-).
MSCHAEF.COM
Damond Walker <dwa...@syncreticsoft.com> wrote:
>I'm always interested in how people "came to something." In this case
>it's Lisp. How about relaying how you "came to Lisp?"
I took it throughout college. Sophmore year, I wanted to learn some new
programming languages, so I signed up to take the one hour introduction
courses into C++ and Lisp. The C++ class had 100 undergraduates, the Lisp
class had 10-20 upper level undergrads and graduate students. You can
imagine which was more challenging. :-)
At any rate, I was hooked, and looked for pretty much every other
opportunity to use the language. I took the symbolic processing class,
which was taught in Lisp, and subsequently took the compilers course. Our
assignment was to write a limited Java compiler in the language of choice.
I was sorely tempted to use Java for the sake of circularity, but ended up
picking Lisp. I wanted to use it in a bigger application than the toys I
had been writing up until then.
All I can say about that is that it was eye-opening. My roommate took
the course with me and struggled with implementing the compiler in C++.
We did a lot of work at the same time (no sharing) and asked each other
questions about various little implemtation details. While he was
struggling with the correct representation of symbols, I was building
parse trees. And so it went for the duration of the semester. It also
introduced me to Lisp I/O and broke me of the habit of making everything
recursive and functional. When I had first heard of the Compilers class, I
had heard of Lisp as one of two preferred choices. Apparantly that didn't
survive a change in professors. After the first phase was turned in,
another student asked a question on language selection. In his reply, the
professor mentioned that _one_ student was _actually_ using Lisp!!! Java
and C++ were the more popular selections.
Since then, working, I've been stuck using C, and lamenting that it's not
Lisp.
-Mike
cr88192
about math and my personal life...
sadly me personal life is not going like my dreams (or at least not my
newer ones). my life seems to be mirroring those of a few months ago, but
things are bent a little different.
my mind is divided, and my dreams in much the same way. code can not hurt
as much as reality, so that is probably a factor.
often my dreams consist of more tree-like representations of things
(stepping along and reorganizing a tree, or building a new one...). but
really I can't give clear examples.
sometimes it is a hybrid, the people are represented by structures that
describe their nature (?...). sometimes the interactions of the people are
represented in a code like form...
I don't know if this makes any sense...
Thomas A. Russ
wrote:
> I'm always interested in how people "came to something." In this case
> it's Lisp. How about relaying how you "came to Lisp?"
It was part of my introductory Computer Science class at MIT (1977).
(6.031 for those who care). The course was roughly divided into two
parts, the first using Algol-60 and the second using MacLisp.
The real revelation came when we had just finished the last project with
Algol: It was a simple desktop calculator, where one could type
expressions with variables using infix notation. It was a fair bit of
work, what with the required parsing, etc., and it only supported the
standard four arithmetic operations along with exponentiation.
Then we started on the Lisp part of the course. The first week we ended
up writing a symbolic algebraic differentiator, with integration
following the next week. It was much easier to program, and also solved
a much more intriguing and difficult task. That was my real revelation
about the power of using Lisp.
-Tom.
--
Thomas A. Russ, USC/Information Sciences Institute t...@isi.edu
cr88192
>>> [...]
>>> sorry about being off topic, just there is no one really to tell.
>>
>> An unfortunate situation, but I guess you can't change others unless
>> they are willing. I hope things get better soon.
>>
> we have been together for nearly 2 years now...
> about 1 year ago there was an agrument, then things were better for a few
> months. that soon wore off, but things were not too bad. more recently
> there have been more problems, then she was nice (for one day, probably
> relating to me talking about leaving before that), and since she has been
> quite a bit worse (about a month now)...
> when I complain to her about it she says there is no problem. I have
> wanted to leave but she has not wanted me to leave (for some reason I
> can't quite figure out, if she cared about me she would probably treat me
> better). anymore I am running out of options (not like I want to anyways).
> I hope I am not too harsh on her.
>
I talked to her earlier and things were a bit misinterpreted.
this is just an example of how my screwed up emotional state puts blame on
people...
I should have better self control, and I should not feel bad about things
that are not wrong. I am just a crappy person that treats everyone around
me badly.
Paolo Amoroso
wrote:
> Around 1975/76 I wire-wrapped a Z80 board (schematic was the center-fold of
> the first anniversary issue of Byte magazine), with 2K of static RAM and 10K
> of dynamic (yes, 12K, as in "kilo" bytes total RAM) and ported various Tiny
> Basics to it. Probably in Dr. Dobb's, I found out about Fritz van der
> Wateren's Lisp for the 6800, purchased a copy (it came printed in a booklet
> with commented 6800 assembler code) and sight-read it into the Z80 (the 6800
> version was 4K in size, the Z80 transliteration was 5K).
>
> Once running well (the final GC glitch (a sight-reading typo) was found
> about 6 months later :-), I wrote a simple editor and debugger in lisp and
> sent an article in to DDJ ('78, '79?). I had mono at the time, so I dropped
This is probably one of the smallest Lisp Machines ever built :)
Kent M Pitman
> On 4 Apr 2002 07:27:55 -0800, dwa...@syncreticsoft.com (Damond Walker)
> wrote:
>
> > I'm always interested in how people "came to something." In this case
> > it's Lisp. How about relaying how you "came to Lisp?"
>
> It was part of my introductory Computer Science class at MIT (1977).
> (6.031 for those who care). The course was roughly divided into two
> parts, the first using Algol-60 and the second using MacLisp.
And also a virtual assembler called 'm' that had a cute little
idealized instruction set made for teaching assembly / machine code.
I'm pretty sure you mean 'delphi lisp' which was far from a maclisp.
I took 6.031 the same year and i think it was delphi on the delphi
unix 11/45...
Delphi lisp had the interesting property that it could be invoked with
a -s or -t (for 'stack' or 'tree' semantics) which had some sort of
different effect on how closures worked, i think. (I have the class
notes still in hardcopy somewhere, and i remember one-page
descriptions of S- and T-evaluators on the tests or problem sets.)
This lisp also swapped. not paged. so when you weren't in you were
out. supporting 20 people in the room meant that sometimes one person
had an out of control process that was taking the whole processor. it
would type MEMORY WAIT on the (hardcopy) consoles of all the people in
the room while they waited for one pig to finish his computation.
angry people would get up and wander around looking for the person who
_didn't_ have MEMORY WAIT typed on their console.
If this isn't what you experienced, maybe it was not 1977? Or maybe
you took it in the fall and I took it in the spring. Even on the
transition off of the pdp11 onto the pdp10, though, I'd written a
simulator for a lisp dialect i made up (called Ulisp, since it was a
derivative of an emulator i'd written for the pdp11 unix (delphi) lisp
to run on the pdp10 ...). I think my teaching dialect was used for
one semester before the switch to scheme. it ran in maclisp but was
not maclisp.
> the real revelation came when we had just finished the last project with
> algol: it was a simple desktop calculator, where one could type
> expressions with variables using infix notation. it was a fair bit of
> work, what with the required parsing, etc., and it only supported the
> standard four arithmetic operations along with exponentiation.
>
> then we started on the lisp part of the course. the first week we
> ended up writing a symbolic algebraic differentiator, with
> integration following the next week. it was much easier to program,
> and also solved a much more intriguing and difficult task. that was
> my real revelation about the power of using lisp.
i agree with this part.
Patrick W
Heh. Lucky you. They don't make 'em like they used to.
I wish my car was written in Lisp. It wouldn't be half as bulky,
sluggish, ugly, square-built, and expensive to run.
I suspect mine's written in Java.
Marc Battyani
"Paul Tarvydas" <tarv...@attcanada.ca> wrote
> Around 1975/76 I wire-wrapped a Z80 board (schematic was the center-fold
of
> the first anniversary issue of Byte magazine), with 2K of static RAM and
10K
> of dynamic (yes, 12K, as in "kilo" bytes total RAM) ...
It' funny, I also wire-wrapped a Z80 board with a 2K static RAM. No DRAM but
a 2K EPROM, a PIO and an extension connector for an 8+4bit A/D and a
photodiode amplifier for astronomy uses. (A 1024 point FFT took 20 minutes
vs 600 ns in an FPGA!)
Now I write in VHDL and use a $40K PCB CAD software instead of wrapping ;-)
No Lisp on this one though. Just a forth compiler I wrote.
My first Lisp was Le-Lisp on a TRS80 model I (16K RAM that I extended to 48K
by soldering DRAM chips over the existing ones except for the chip selects
which got decoded by some TTL chips)
Le-Lisp was my first high level language after hexadecimal, Z80 assembly,
forth and the TRS 80 basic.
You can imagine the cultural shock! I was really impressed. A few years
later, I used Lisp on a TI Explorer while in my engineering school (Supélec
France) and in the universities (Paris and Montreal). Today, I use Common
Lisp for all my software, mostly industrial stuff and web applications,
using C only for low level stuff like device drivers and VHDL for the
hardware.
Marc
Marc Battyani
"Marc Battyani" <Marc.B...@fractalconcept.com> wrote
>
> "Paul Tarvydas" <tarv...@attcanada.ca> wrote
>
>> Around 1975/76 I wire-wrapped a Z80 board (schematic was the center-fold
of
>> the first anniversary issue of Byte magazine), with 2K of static RAM and
10K
>> of dynamic (yes, 12K, as in "kilo" bytes total RAM) ...
>
> It' funny, I also wire-wrapped a Z80 board with a 2K static RAM. No DRAM
but
> a 2K EPROM, a PIO and an extension connector for an 8+4bit A/D and a
> photodiode amplifier for astronomy uses. (A 1024 point FFT took 20 minutes
> vs 600 ns in an FPGA!)
BTW I found it in the lab. For those interested in microcomputers archeology
here are 2 pictures of it:
The components side:
http://www.fractalconcept.com/Z80-front.jpg
The wire-wrap side:
http://www.fractalconcept.com/Z80-back.jpg
The funny thing is that the current Intel architecture is still almost the
same ;-)
Marc
Fred Gilham
I bought a copy of Lisp from Software Toolworks. It ran on my
Heathkit H8, which started as an 8k machine with a 2mhz 8080 but
eventually grew to a 4mhz Z-80 with bank-selected 256k memory. I had
64k when I tried the Software Toolworks Lisp.
I couldn't make heads or tails of it.
I had programmed in assembly and BASIC before that, so I was pretty
`linear' in my thinking....I'd also tried forth but that was another
one I couldn't wrap my mind around.
I also tried logo but I couldn't really get recursion. I could use it
but I was never quite sure of myself.
I kept trying Lisp whenever I could, and I bought Winston & Horn's
LISP, first edition, and would read it from time to time with
virtually complete lack of comprehension. I got xlisp to run on my
Amiga, and my brother in law told me about a major project he did in
xlisp, a decision analysis tool for use in analyzing safety factors in
disposing of nuclear waste. He did it in his spare time and got a
paper out of it at least.
Anyway I eventually went to Stanford to get a masters in Computer
Science, and I took the only programming language course I'd ever
taken, namely Lisp. I read the lambda papers and got really excited.
I also started writing programs in Lisp for some of my coursework.
(I also read Brian Harvey's COMPUTER SCIENCE LOGO STYLE which is when
I finally got recursion. Yes, I think I'm a slow learner....)
After I got my current job, we got a Sparcstation 1 with 16M for home.
I still played with Lisp from time to time. I was interested in
graphics stuff (the logo influence I guess) but Lisp was too slow for
that. I remember trying to run CLIO compiled under AKCL or some such
on the Sparcstation, clicking on a button, hearing the disk start
swapping, and literally 5 minutes later seeing the menu pop up.
However, I kept trying it every so often, and lo and behold, one day I
decided that it was actually fast enough to use. I think this was
about at the time of the Pentium 100 but it may have been sooner.
Eventually during the startup mania I got a job offer at another
company and used it to leverage my boss into letting me get into a
project that was using Lisp. I spent a couple years working on Lisp
stuff until the funding on that project ran out. I gave a
presentation on some of the stuff I did at the LUG in 1999.
Unfortunately I'm now programming in Java, and the ideas they stole
from Lisp and implemented poorly only make the pain worse. :-)
But there's a good chance I'll be working in Lisp again soon.
--
Fred Gilham gil...@csl.sri.com
During the sixteenth and seventeenth centuries, when Spanish
sovereignty extended from Italy to most of Latin America, on average
less than three persons a year were executed by the Inquisition, which
was formally constituted in all those places as well as at home.
-- Marvin R. O'Connell, professor emeritus of history at the
University of Notre Dame and priest of the Archdiocese of St. Paul.
Reini Urban
I knew prolog and forth before, so it was not too weird.
--
Reini Urban
http://xarch.tu-graz.ac.at/autocad/news/faq/autolisp.html
Tim Moore
Penthouse Forum. "My first time with Lisp happened late one night in
the lab..."
I got my introduction to Lisp as a student at MIT. I knew Fortran
reasonably well and had a programming job in the Ocean Engineering
deptartment, but I had heard of Lisp before. Copies of SICP were laying
around the frat house; once in I while I'd crack it open, but it
seemed completely alien to my Fortran brain. Maybe the ambience had
something to do with that.
In my senior year I took 6.001 and was blown away. I decided I really
wanted to study computer science instead of ocean engineering. I went
off to grad school at the U of Utah intending to study computer
graphics, but the group building a Common Lisp system was far cooler,
and the rest is history.
In this context, the periodic assertions that "Scheme is not Lisp,"
"Scheme ruins you for Common Lisp," "The Scheme community is hostile
to the Common Lisp community" etc. always seem bizzare to me. In 1986
it was clear that Scheme was the teaching language, Common Lisp was
the language in which you'd write real programs, and most of the
concepts were the same. So many of the Lisp concepts taught in SICP
-- functional abstraction, higher order functions, lexical scoping,
data driven programming, little languges, message passing to name a
few -- were so different from what one encountered in other
programming languages that it would have been silly to make a huge
distinction between Scheme and CL. Of course there were adjustments
to make in moving between the two, but they were pretty minor compared
to learning Scheme in the first place.
Tim
Lorance Stinson
> Assuming you have programming-related dreams (as I do), did you notice
> that your dreaming patterns changed when you started using Lisp? (Or
> some other language?)
I would actually sit up in the middle of the night and see Perl code on and
describing my bedroom and my wife. It was a rather troubling experience
until I realized I was sleeping. I then fell back into the bed and went to
sleep.
Since I have started working with Lisp I never have troubling dreams about
Perl. I have beautiful dreams with Lisp describing the dream. I actually
see the Lisp code that describes the contents of the dream. Often when I
get tired I will see Lisp code on top of the things I see.
I also see Lisp code describing events. Like when my cat jumps across the
room I actually see the Lisp code to describe her jump and landing.
I personally like dreaming in Lisp. I never remember the details when I
wake up. I just remember that I had a good time. And I often sleep better
when I dream in Lisp.
--
Lorance Stinson <lor...@worldpbx.com> http://www.worldpbx.com/
Codito, Ergo Sum (I Code, therefore I am)
Erik Naggum
| In this context, the periodic assertions that "Scheme is not Lisp,"
| "Scheme ruins you for Common Lisp," "The Scheme community is hostile
| to the Common Lisp community" etc. always seem bizzare to me. In 1986
| it was clear that Scheme was the teaching language, Common Lisp was
| the language in which you'd write real programs, and most of the
| concepts were the same.
But this is only true when you look at Common Lisp from Scheme. If you
look at Scheme from Common Lisp, it is most of the concepts are missing,
if not different. It is actually very important to realize this. What
does rot the brain is that those who actually think that "most of the
concepts are the same" are damaged for life, because they never go beyond
what they have already learned. Essentially, they write Scheme in Common
Lisp for the rest of their lives, just like some people write Pascal in
any language, or Fortran in any language. This is precisely why _not_
exposing a malleable young mind to Scheme is so important if they are
ever going to use Common Lisp for production programming.
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Post with compassion: http://home.chello.no/~xyzzy/kitten.jpg
Arjun Ray
| If you look at Scheme from Common Lisp, it is most of the concepts are
| missing, if not different. [...] What does rot the brain is that those
| who actually think that "most of the concepts are the same" are damaged
| for life, because they never go beyond what they have already learned.
I am not young, my mind is likely not very malleable, and I have read
SICP. Are there any specific Scheme-ish ideas that you would suggest I,
as a rank beginner in CL, should make it a priority to unlearn?
Erik Naggum
| I am not young, my mind is likely not very malleable, and I have read
| SICP. Are there any specific Scheme-ish ideas that you would suggest I,
| as a rank beginner in CL, should make it a priority to unlearn?
Primarily that Scheme has done it the right or only way.
Scheme is actually a hard language to learn. It forces you into a
mindset that is very artificial. Common Lisp is much less artificial.
At some point in your learning about some artificial reality, accepting a
it as if it were real sets in. Scheme is actually the only programming
language I have seen this happen with -- it affects people in subtle ways
that reorient their value system and begin to accept what they hear and
not what they see. The same happens to young minds who meet Scientology
or Objectivism or even Communism unprepared for the multiplicity of what
might be true, and they start to confuse the fact that something is true
with everything else being false. Theories that are so attractive that
they become _more_ attractive than reality are probably wrong from the
outset, in some fundamental way. This notion of "purity", for instance,
and its associated "elegance", tend to make reality look "dirty" and
drives people into a weird state of mind. This is hard to detect from
the inside, but very easy to detect from the outside.
If you need a particular example: recursion is not a _generally_ good
idea, you need to understand how and when Scheme really is iterating, and
to find iterative expressions of the same forms they use recursions for..
Calling functions that return functions only to call the return value
right away is _generally_ not a clear and perspicuous coding style --
consider binding it to a variable. An one namespace is simply wrong,
both in conflating function and variable value and in lacking packages.
MSCHAEF.COM
Fred Gilham <gil...@snapdragon.csl.sri.com> wrote:
>
>I also tried logo but I couldn't really get recursion. I could use it
>but I was never quite sure of myself.
I had the good fortune to be involved in a Logo pilot program in my school
district. When I was in 3rd grade (1983), our school got a lab full of 20
Commodore 64's running the Commodore Logo. We were introduced to
functional decomposition, iteration, and recursion pretty early on. It
made an impression, as I was never truly happy with BASIC.
-Mike
--
http://www.mschaef.com
Christopher C. Stacy
Erik> This is precisely why _not_ exposing a malleable young mind
Erik> to Scheme is so important if they are ever going to use
Erik> Common Lisp for production programming.
Exposing the student to a variety of things is what is important,
and I think Scheme is a good addition to the package.
At MIT, the standard set of courses included both Scheme
and CLU (a strong-typing module oriented language) for starters.
But that's just the introductory material.
I'm not sure which course of study there generally includes
learning Lisp other than the AI course, and there it's incidental.
Maybe there's some problem if all the students walk away from the
courses thinking that all Lisps are like Scheme, or a warped idea
of what constitutes a "Lisp". On the other hand, as we have seen
in this discussion many times, people who are experts in Scheme
and Lisp and more, are unable to define "Lisp".
I was shocked in recent years when talking with some smart kids
who had recently graduated telling me how much they hated "Lisp"
(by which they meant Scheme).
The fact of the matter is that most kids -- even MIT hot shots --
simply want to learn enough to be able to make money programming
in the most popular language of the day. Unless they are the
very few who are on the post-graduate academic track, they are
not interested in learning any more than that. So, what they
want to know for the last 15 years or so is only: how to become
a C++ or JAVA programmer. They don't want to learn very much
about computer sofware beyond that, and they certainly don't
want to learn any languages that are not plastered all over
the Employment pages of the Boston Globe. Scheme is learned
grudgingly as an abstract mathematical treatment of largely
arcane ideas, to expand their thinking, but not because one
would ever actually develop software in that language.
Common Lisp is a marginal language of no interest at all.
Of course, that sucks, but 90% of everything in the world is shit,
so what do you expect? Shit sucking, that's what!
You got it.
MSCHAEF.COM
saw your self-response. As penance for my off-topicness, I might point
out that the newsgroup 'alt.love' is the more appropriate venue for such
matters.
In article <ub4pnb5...@corp.supernews.com>,
cr88192 <cr8...@hotmail.com> wrote:
>
>sorry to everyone, I portrayed her badly...
>I talked to her earlier and things were a bit misinterpreted.
>this is just an example of how my screwed up emotional state puts blame on
>people...
>I should have better self control, and I should not feel bad about things
>that are not wrong. I am just a crappy person that treats everyone around
>me badly.
You really need to stop convincing yourself that you are somehow a crappy
person and the way you feel is somehow incorrect. In a very real sense,
your relationship with your SO (g/f, wife, fiancee, etc.) is what you make
of it. Part of the reason communication is so important is that your
partner is very likely not to know what you think is obvious from your
point of view. As a result, it is important to stand up and advocate your
point of view. If all you do is justify the way she treats you, think
it's shitty, and that all you have to do is persevere, then you'll get
treated according to those expectations you set. Worse, it doesn't do
you or her any favors to have that kind of ill will build up.
Of course, the risk of all this is that if you're both honest with what
you want, the relationship will fall apart because you can't meet each
other's expectations. If that's the case, than it _should_ fall apart
and you both _should_ move on to a relationship that can meet your
expectations. That risk can pretty easily paralyze people into inaction
and coping, rather than action and solcing. You shouldn't need to put up
with that kind of relationship. After all, you're smart enough to want to
know more about Lisp. :-)
In a way, it's like debugging in general. There's the easy patch fix that
makes the problem look gone. Then there's the hard, difficult fix that
actually fixes the underlying issues. If there's any area of life in
which it's worth the effort to make the real fix, this is it.
-Mike
Arjun Ray
| If you need a particular example:
You've provided three, thanks! :-)
| recursion is not a _generally_ good idea, you need to understand how
| and when Scheme really is iterating, and to find iterative expressions
| of the same forms they use recursions for..
Well, yes, recursion did come across as a big deal in SICP. Iteration
amounting to a special case (thanks to tail call optimization) didn't
impress me, however. It struck me as a "since we *can* do it this way,
we really don't *need* anything else" rejection of potentially useful
idioms directly in the language, especially when, a lot of the time, the
real idiom is using extra accumulator arguments to jigger the recursion
into tail call position. Wow, all that for this? Finger exercises are
great, but at some point one simply wants to play the piano...
| Calling functions that return functions only to call the return value
| right away is _generally_ not a clear and perspicuous coding style --
| consider binding it to a variable.
And using funcall appropriately, or have I misunderstood?
| [And] one namespace is simply wrong, both in conflating function and
| variable value and in lacking packages.
I'm still having trouble grasping whether CL has two namespaces or many.
Function versus variable is pretty clear, but what about special forms,
macros, keywords, filler (syntactic sugar), and the like? In my limited
understanding, one would exploit syntax to differentiate namespaces, so
I guess I'm really asking, how many syntactically distinguishing markers
does CL have and does/should it need more?
Marco Antoniotti
Arjun Ray <ar...@nmds.com.invalid> writes:
...
> | [And] one namespace is simply wrong, both in conflating function and
> | variable value and in lacking packages.
>
> I'm still having trouble grasping whether CL has two namespaces or many.
> Function versus variable is pretty clear, but what about special forms,
> macros, keywords, filler (syntactic sugar), and the like? In my limited
> understanding, one would exploit syntax to differentiate namespaces, so
> I guess I'm really asking, how many syntactically distinguishing markers
> does CL have and does/should it need more?
The way I like to look at things is that CL has a sort of
multidimensional set of namespaces (the metaphor is really an
overkill, but it serves the purpose).
First of all you have the PACKAGE system, which partitions the "set of
symbols" into (semi)overlapping subsets. The set of symbols is the
domain of all the functions (named themselves by symbols) that
retrieve elements in their range, i.e. in a "namespace".
On a totally different dimension, there are 2 main namespaces for
"values" and "functions", plus a select namespace for "special
operators" (like IF, COND, etc. etc.) Then you have a namespace for
"types" which includes a namespace for "classes".
When you write a language extension in CL, you can add a new
dimension. E.g. all the DEFSYSTEM utilities out there introduce the
"systems' namespace" which you can access (more or less) with the
function named "FIND-SYSTEM". This goes further of course.
As per your question, well, it depends. syntax of CL is extremely
simple yet immensely general. CL has very few special operators and a
very consistent use of the so called "keyword" arguments to express
different things. E.g.
(sort (vector '(1 2) '(3 5) '(-3 8) '(33 0)) #'> :key 'first)
or
(find -3 (vector '(1 2) '(3 5) '(-3 8) '(33 0)) :key 'first :from-end t)
Where the keywords :key and :from-end are specified for each
"sequence" operation.
The lack of keywords is one of the things most sorely missing in
Scheme.
So. You do not need anything more in CL. Just use what you have and
if you do not have enough, extend the language, like you cannot do in
many other ones.
Cheers
--
Marco Antoniotti ========================================================
NYU Courant Bioinformatics Group tel. +1 - 212 - 998 3488
719 Broadway 12th Floor fax +1 - 212 - 995 4122
New York, NY 10003, USA http://bioinformatics.cat.nyu.edu
"Hello New York! We'll do what we can!"
Bill Murray in `Ghostbusters'.
cr88192
> * Arjun Ray <ar...@nmds.com.invalid>
> | I am not young, my mind is likely not very malleable, and I have read
> | SICP. Are there any specific Scheme-ish ideas that you would suggest I,
> | as a rank beginner in CL, should make it a priority to unlearn?
>
> Primarily that Scheme has done it the right or only way.
>
one thing I have not really believed to begin with, not like r5rs claims
that anyways (or at least not that I have seen).
> Scheme is actually a hard language to learn. It forces you into a
> mindset that is very artificial. Common Lisp is much less artificial.
> At some point in your learning about some artificial reality, accepting
> a
> it as if it were real sets in. Scheme is actually the only programming
> language I have seen this happen with -- it affects people in subtle
> ways that reorient their value system and begin to accept what they hear
> and
> not what they see. The same happens to young minds who meet Scientology
> or Objectivism or even Communism unprepared for the multiplicity of what
> might be true, and they start to confuse the fact that something is true
> with everything else being false. Theories that are so attractive that
> they become _more_ attractive than reality are probably wrong from the
> outset, in some fundamental way. This notion of "purity", for instance,
> and its associated "elegance", tend to make reality look "dirty" and
> drives people into a weird state of mind. This is hard to detect from
> the inside, but very easy to detect from the outside.
>
I once felt this way about the relational model, but that broke down...
> If you need a particular example: recursion is not a _generally_ good
> idea, you need to understand how and when Scheme really is iterating,
> and to find iterative expressions of the same forms they use recursions
> for.. Calling functions that return functions only to call the return
> value right away is _generally_ not a clear and perspicuous coding style
my "scheme" system generally has used iteration functions (coded in
assembly), mostly as I have not really bothered with coding tail
recursion...
> consider binding it to a variable. An one namespace is simply wrong,
> both in conflating function and variable value and in lacking packages.
>
I understand the need for packages allready. I am starting to understand
why multiple namespaces are needed (mostly I would just use the functional
namespace to store compiled versions of the functions, and the data to
point to the s-structures).
from my point of view my implementation was: scheme kludged into kernel
programming... so I have much of the same mess (some parts borrowing what I
*do* like from c). the main thing is that I am trying to keep r5rs
conformance as well, though it is not like r5rs does not allow one to make
extensions.
really this here does make it sound more like cl is what I am aiming at, so
I am more definatly thinking of looking into it...
the main thing I am hoping is that it is not a massive implementation task.
hopefully people don't think I am ms-ing the specs, just in my oppinion a
*pure* scheme would be ineffective for system coding.
in any case I know far less about either than I know about os coding, but
even that is stressed as my designs are coming out unusual.
hopefully I don't sound ignorant.
cr88192
> I was debating whether or not to respond to this off topic post, and then
> saw your self-response. As penance for my off-topicness, I might point
> out that the newsgroup 'alt.love' is the more appropriate venue for such
> matters.
>
I will check it out, searching for "appropriate" places to discuss
emotional issues is an interesting idea...
>>
>>sorry to everyone, I portrayed her badly...
>>I talked to her earlier and things were a bit misinterpreted.
>>this is just an example of how my screwed up emotional state puts blame on
>>people...
>>I should have better self control, and I should not feel bad about things
>>that are not wrong. I am just a crappy person that treats everyone around
>>me badly.
>
> You really need to stop convincing yourself that you are somehow a crappy
> person and the way you feel is somehow incorrect. In a very real sense,
> your relationship with your SO (g/f, wife, fiancee, etc.) is what you make
> of it. Part of the reason communication is so important is that your
> partner is very likely not to know what you think is obvious from your
> point of view. As a result, it is important to stand up and advocate your
> point of view. If all you do is justify the way she treats you, think
> it's shitty, and that all you have to do is persevere, then you'll get
> treated according to those expectations you set. Worse, it doesn't do
> you or her any favors to have that kind of ill will build up.
>
communication is difficult sometimes.
she is my girlfriend...
> Of course, the risk of all this is that if you're both honest with what
> you want, the relationship will fall apart because you can't meet each
> other's expectations. If that's the case, than it _should_ fall apart
> and you both _should_ move on to a relationship that can meet your
> expectations. That risk can pretty easily paralyze people into inaction
> and coping, rather than action and solcing. You shouldn't need to put up
> with that kind of relationship. After all, you're smart enough to want to
> know more about Lisp. :-)
>
I don't really know what she wants, she has never said.
part of what I want I am not sure even really exists for me.
computers and math seem to be the only things in life which really seem
consistent to me.
> In a way, it's like debugging in general. There's the easy patch fix that
> makes the problem look gone. Then there's the hard, difficult fix that
> actually fixes the underlying issues. If there's any area of life in
> which it's worth the effort to make the real fix, this is it.
>
for me the problems and their existance is unclear. the problem is that my
reality changes based on when I am asked. there happines, sadness, and
fear; all are very distinct "realities". at some times I bounce between
them in a rather erratic manner.
I should have the self control to be consistent in this respect, but I do
not. those posts were made somewhere around "sadness".
really in life it is very difficult to be productive or carry on a social
life. it is not easy to describe how it is effected.
Donald Fisk
> I'm always interested in how people "came to something." In this case
> it's Lisp. How about relaying how you "came to Lisp?"
This was in late 1981. I had run out of my grant, but still had access
to college facilities, including a mainframe account on an ICL 2980.
I had no job and no job experience. Then I heard on the BBC World
Service some computer-composed music, and it sounded awful. I was
sure I could do better myself. The first thing I had to decide was
which language to write it in, and the supported languages were Fortran
and Basic, both of which I had learned, and COBOL and Pascal. I choose
Basic because it had the best string handling, and was interactive.
(There were other languages on the machine, but they were unsupported,
so I didn't consider them. Snobol4 was one (no Lisp), and would have
been a better choice, but there was no documentation.) So I wrote my
music composition program in Basic. Then one of my colleagues
recognized
that what I was doing was Artificial Intelligence, and told me about
Lisp. He had an account on a machine in Cambridge (England, not MA),
to which a connexion could me made via an acoustic coupler, which did
run Lisp but in batch mode, so you would type
(CDR '(A B C))
and submit it as a job. You could query the system and watch the
job move to the front of the queue, when it would return
(B C)
He also had a copy of Kernighan and Richie, and another colleague
had Winston and Horn. I compared them and remember deciding that C
looked terribly old-fashioned, and so bough my own copy of W&H.
I still have it. (I now get paid to write C. It insults my
intelligence less than Java, so I don't mind.)
The music composition program helped me get my first job and access
to a Burroughs 6800, and I heard rumours that someone once put a Lisp
on it but it had been archived. I tracked this down and had it put
back on the machine. It was Portable Standard Lisp.
After that, I had access to Poplog, but the Lisp for that was little
more than a toy at the time, and so programming was done in Pop11 and
Prolog instead. I also had very occasional access to Franz Lisp, and
later implemented my own Redlisp interpreter, based loosely on Maclisp,
in Turbo Pascal. Shortly after that I was using PC Scheme (cue: Is
Scheme a Lisp?) before finally using Allegro Common Lisp in 1992.
A bit of a saga I know, but it's what you asked for.
> Damond
--
Le Hibou
You know you've been hacking too long if, when someone
asks you if you have a son, you reply, "No, but I've
got a Symbolics 3630".
MSCHAEF.COM
>emotional issues is an interesting idea...
There are all sorts of groups for relationship/emotional issues, mainly in
the alt.* and soc.* hierarchies. Also, various webforums too.
>I should have the self control to be consistent in this respect, but I do
>not.
Don't beat yourself up too badly.
-Mike
--
http://www.mschaef.com
Thomas A. Russ
> I'm pretty sure you mean 'delphi lisp' which was far from a maclisp.
> I took 6.031 the same year and i think it was delphi on the delphi
> unix 11/45...
It very likely wasn't Maclisp, then.
> Delphi lisp had the interesting property that it could be invoked with
> a -s or -t (for 'stack' or 'tree' semantics) which had some sort of
> different effect on how closures worked, i think. (I have the class
> notes still in hardcopy somewhere, and i remember one-page
> descriptions of S- and T-evaluators on the tests or problem sets.)
Initially this sounded quite bizarre, but the longer I think about it,
them more some hazy memories are returning to me. It seems so long and
so many parentheses ago...
> If this isn't what you experienced, maybe it was not 1977? Or maybe
> you took it in the fall and I took it in the spring.
I'm pretty sure it was in Spring 1977. There was a 1-week, somewhat
optional machine language segment, but otherwise it was just Lisp and
Algol.
Larry Clapp
> I'm always interested in how people "came to something." In this case
> it's Lisp. How about relaying how you "came to Lisp?"
First of all, I like your story of how you came to Lisp. Very cool.
I came to Lisp rather differently than the folks that've posted so far. I
read Douglas Hofstadter's book _Metamagical Themas_ (in, I guess, the late
1980's) which has three chapters on Lisp, and it seemed very cool. I took
Hofstadter's "spec" of Lisp and wrote a tiny Lisp interpreter in Turbo Pascal.
It didn't do much, but it could do the fundamental stuff: take a list and run
it as code. I think writing that interpreter gave me a fundamental
understanding of linked lists and pointers that many of my peers in college
lacked. Or maybe not. :) I never wrote any substantial code in my tiny
dialect, but I had a good time implementing it.
Oddly, I never encountered Lisp in college (University of South Florida BS in
Computer Science, 1991), aside from one half-remembered discussion with a
friend of a friend who said (somewhat tongue-in-cheek) that "in Lisp you can
say 'take the car of the cdr of the cdr of the car of some data structure' and
it'll wake you up and make you coffee in the morning". (USF taught Intro to
Computer Science using Modula-2.) More oddly, I took a graduate level Intro
to Neural Networks class, which also never mentioned Lisp (that I can recall
11 years later, anyway).
Anyway, I didn't do much else with Lisp for many years, though the language
continued to hold a remembered fascination for me. I bought Winston & Horn's
_Lisp_, 3rd edition, a couple years ago, and read a good bit of it, but still
didn't do much else.
Most recently, sometime in January I stumbled on Kent Pitman's interview on
Slashdot, and it wouldn't overstate the case to say I was dazzled.
These paragraphs, in particular, caught my eye and sparked my imagination:
Kent:
Lisp is dynamic. The world is ever changing and it's useful to allow
programs to change dynamically with it. I can load new or changed
functions, classes, and method definitions into a running image that I'm
debugging, or even in a deployed production application. When I do, the
code that was running will immediately start using the new definitions.
Classes can be redefined even if the new class has different slots, and,
if I care to, I can control how the update is done from old to new slot
arrangements for already-created instances. This kind of thing supports
programs that must be continually running yet must be responsive to
changes or even just bug fixes.
A /. poster named kfogel:
For myself and a number of friends, Lisp/Scheme programming has for too
long been a kind of mystical Eden, fading in our memories, from which we
have been mostly banished in our professional lives. But we can still
recall how it felt to work in a language able to shape itself to any
pattern our minds might ask: coding was more interesting and more
expressive, and the rate of increasing returns over time was tremendous,
because fine-grained -- almost continuous -- abstraction was in the nature
of the language. Life was just more fun, frankly.
I haven't *had fun* programming for quite a while. I've enjoyed it, and I've
occasionally gotten to tackle interesting problems, but I've rarely had fun.
:-\
Since then, I've read Graham's _On Lisp_ and _ANSI Common Lisp_, and I've
developed a (not-very-full-featured, but it gets the job done) facility for
sending Lisp code from Vim to CMUCL. I've read some of Graham's other papers,
including the one where he describes his work at Viaweb in some detail. I've
pondered the idea of starting an ASP of some kind (like Viaweb), or of trying
to create a neural net that would predict a series of numbers (e.g. stock
prices :), both in Lisp. But you have to walk before you can run, as they
say, so for now I read c.l.l and do exercises out of ACL.
My $0.02.
-- Larry
Patrick W
> I'm always interested in how people "came to something." In this case
> it's Lisp. How about relaying how you "came to Lisp?"
Accidentally, via the road less travelled. (Very different from the
typical hard-core engineering / math background).
I started programming relatively late in life after spending most of
my youth travelling, writing, making music and learning about people,
their lifestyles, beliefs, histories, and cultures. I always had a
peripheral interest in science, but very little interest in
technology.
That began to change when a short series of LSD experiments
unexpectedly re-opened my eyes to the beauty of mathematics and
geometry.
It occurred to me that a computer would be an excellent tool for
experimenting with the peculiar fractal-like ideas and images that
characterise the LSD state. I wanted to experiment with the generation
of complexity by applying simple feedback functions to simple motifs.
I also had a vague intuition that the principles behind fractal
geometry might also be applicable in non-graphical domains: so-called
Chaos Theory, other branches of science, and maybe even neurology.
(Hell, maybe all of nature. I was still young enough to think I'd
discovered something new).
The vision splendid faded, but the PC hung around. I dabbled a bit
with QBasic, fiddled about briefly with VB and Delphi, then moved on
to C and C++. (I spent an enormous amount of time on C++, and to my
deep regret I feel it was almost all wasted time). Eventually I became
quite interested in the process of programming itself, and began to
look for better ways of doing it. Eiffel was my first step along that
route.
My discovery of Lisp was a lucky accident. Given my late introduction
to computer science (c. 1995), I'd managed to get most of the way
through a part-time university degree without ever hearing about Lisp.
(And in hindsight I think that is a sad and disgraceful state of
affairs, akin to teaching English literature without mentioning
Shakespeare).
One day I was browsing idly in the university bookshop and found some
copies of Peter Norvig's PAIP. Nearby I found copies of Winston &
Horn's "Lisp". Bought both. Read some the first night. Soon realised
that Lisp was way ahead of its time. Was very surprised to find so
many "modern" ideas in such an ancient language. I knew straight away
that this would be an interesting language to learn.
But, given my unusual interest in computers, I found Lisp to be
something more than just an interesting language for getting things
done. In a way, I admire Lisp as a *product* as much as I appreciate
it as a tool. Lisp is itself a good example of how complexity can
flower out and proliferate from a simple motif without losing elegance
and symmetry. Whenever I see something with those qualities, I can't
help feeling it offers a glimpse of something transcendent.
Unfortunately, my daily workaday world has little place for such
mystical crap, so for now it's back down to earth and out to C ...
Alberto Riva
> I'm always interested in how people "came to something." In this
> case it's Lisp. How about relaying how you "came to Lisp?"
It all started back in high school, in 1985 or so. At the time I'd been
programming in Basic and Z80 assembler only on my home computer. I might
have heard the name Lisp, but I had no idea what it was until one day
our mathematics teacher (who was giving an informal "introduction to
programming" course to some of us who were interested in computers)
handed me a floppy disk saying "You might find this interesting." It
turned out the floppy contained a copy of muLISP. It took me a while to
figure out how to use it, given the unusual environment and the almost
total lack of documentation, but I remember being able to run the
classical "Guess the animal" example.
Around the same time, a special issue of Scientific American on software
appeared; one of the articles, on artificial intelligence, showed some
Lisp code and described Lenat's Eurisko. I was hooked immediately. My
next step was to get a copy of Golden Common Lisp and to read P.H.
Winston's book. I kept playing with Lisp during my university years,
until I found out that the AI in Medicine lab owned a TI Explorer Lisp
machine. I managed to get accepted into that lab for my final
undergraduate project, and I was the last student to use the Lisp
machine before it was discarded in favor of a Sun workstation.
After graduation, I started using Lisp for my research work: my PhD
project was a distributed monitoring system for diabetic patients
written almost entirely in CL. For that project I wrote what I believe
is one of the very first CL Web servers (this was back in '94, as far as
I know only CL-HTTP is older). Since then I've used Lisp almost
exclusively, both for work and for personal pleasure :)
I currently write web-based bioinformatics applications for Harvard
Medical School. I am lucky enough to be able to do all my work in CL,
and I hope it stays this way for a very long time :)
--
Alberto Riva
Children's Hospital
Informatics Program
Erik Naggum
| And using funcall appropriately, or have I misunderstood?
Well, funcall or apply, as appropriate.
| I'm still having trouble grasping whether CL has two namespaces or many.
Well, there is a crucial difference between Scheme and Common Lisp here
that I think many people miss. We have talked about symbolic programming
and how it relates to packages in this newsgroup a while, but the obvious
point that "everything" in Common Lisp is named by symbols is somehow
lost on people. When a class is named by a symbol, it may or may not be
a separate "namespace" for classes, but the fact that a symbol may be a
designator for the class so named may be an indicator. In Scheme, they
are still so fascinated by this "first-class" idea that they think they
have to pass the values around instead of names. This makes for a _very_
different mode of thinking.
| Function versus variable is pretty clear, but what about special forms,
| macros, keywords, filler (syntactic sugar), and the like?
Actually, it is operator vs variable -- the first position of a form
names an operator. (The function slot of a symbol may also hold more
than functions.) That an variable may be named the same as a operator
means that you have two namespaces, not just "one valuespace", which I
think is a better name for Scheme and that whole branch of programming
languages starting with Algol which Scheme tried to merge with Lisp.
| In my limited understanding, one would exploit syntax to differentiate
| namespaces, so I guess I'm really asking, how many syntactically
| distinguishing markers does CL have and does/should it need more?
No, syntax is not the issue. The issue is that a symbol names various
forms of things. Whether they are "in" the symbol, like the functional
and the regular values, or are keys for lookups elsewhere is immaterial.
What find-class does is not specified, except to take a symbol as a value
and return the class so named. There is no syntax for block names, throw
tags, go labels, etc, but these are all established and used in special
forms, which I guess _some_ would call "syntax", but it is not really
visually different from other forms. I therefore think it is not very
productive to call them namespaces. It is more like operator-specific
mappings of symbols that name their specific things.
But in general, using symbols to name things is the (Common) Lisp way,
and using the values directly is the Scheme way.
Julian Stecklina
[...]
> BTW I found it in the lab. For those interested in microcomputers archeology
> here are 2 pictures of it:
> The components side:
> http://www.fractalconcept.com/Z80-front.jpg
>
> The wire-wrap side:
> http://www.fractalconcept.com/Z80-back.jpg
>
> The funny thing is that the current Intel architecture is still almost the
> same ;-)
Look at an seventy years old car and then at a new. I think you get
the point. :)
Regards,
Julian
--
Meine Hompage: http://julian.re6.de
Ich suche eine PCMCIA v1.x type I/II/III Netzwerkkarte.
Ich biete als Tauschobjekt eine v2 100MBit Karte in OVP.
Kent M Pitman
> I'm still having trouble grasping whether CL has two namespaces or many.
It depends a little on how you count.
At the level of 'pure syntax' there are four:
- variables
- functions
- go tags (established by TAGBODY and transferred to by GO)
- return tags (established by BLOCK and transferred to by RETURN-FROM)
These are the only namespaces that are specially understood by the langauge,
and it is possible to independently bind these without interfering with the
others.
The names of catch tags, class names, and so on are symbol data, not program
data (even though the program data would be symbols, we're talking the
difference between symbols visible at compile time and symbols not always
visible until runtime). Some people might count these as namespaces;
certainly in some languages these have special notational syntax and even
in some cases are not allowed to be variable at runtime.
> Function versus variable is pretty clear, but what about special forms,
> macros, keywords, filler (syntactic sugar), and the like?
As Erik noted, you're confusing naming with semantics. The simple
test of whether there are two namespaces is whether if you bound one,
you'd interfere with another. You can't define a function FOO without
replacing any macro FOO. You can't define a function LAMBDA because
it's reserved (being a special operator). So functions, macros, and
special operators are all in the same space.
> In my limited understanding, one would exploit syntax to
> differentiate namespaces, so I guess I'm really asking, how many
> syntactically distinguishing markers does CL have and does/should it
> need more?
I think it has "enough" to do the set of things it was designed for.
Therefore, I think it does not require more. Do you have a specific
suggestion to make?
- Variables are referenced as atomic forms.
- Functions are invoked as the car of a form,
or referenced through FUNCTION.
- Go tags are invoked through use of GO.
- Return tags are invoked through use of RETURN-FROM.
Coby Beck
"Damond Walker" <dwa...@syncreticsoft.com> wrote in message
news:63637457.02040...@posting.google.com...
> I'm always interested in how people "came to something." In this case
> it's Lisp. How about relaying how you "came to Lisp?"
In the Before Time, when human's lived in caves and Woolly Mammoths walked
the hills, there were no computers and debugging was very difficult and very
dangerous.
Later, I took AI courses and learned Lisp.
--
Coby Beck
(remove #\Space "coby 101 @ bigpond . com")
=:-B
(sorry, I wanted to add my story, but it just didn't seem interesting
enough..)
Pierpaolo BERNARDI
"Donald Fisk" <hibou000...@enterprise.net> ha scritto nel messaggio news:3CB08CFE...@enterprise.net...
> Shortly after that I was using PC Scheme (cue: Is
> Scheme a Lisp?)
Well, the front cover of the manual says:
"PC Scheme
a simple, modern Lisp"
P.
Thomas A. Russ
> As Erik noted, you're confusing naming with semantics. The simple
> test of whether there are two namespaces is whether if you bound one,
> you'd interfere with another. You can't define a function FOO without
> replacing any macro FOO. You can't define a function LAMBDA because
> it's reserved (being a special operator). So functions, macros, and
> special operators are all in the same space.
It would seem that this argument supports the notion that class
definitions have their own namespace, perhaps shared with types.
Erik Naggum
| Well, the front cover of the manual says:
|
| "PC Scheme
| a simple, modern Lisp"
Why are the Scheme people authoritative on whether Scheme is a Lisp?
If you ask almost any person if they are honest, they will answer "yes",
the dishonest probably more often than the honest. If you want a correct
and useful answer, you have to find out what they mean: Do they simply
answer the question honestly, or do they give an answer that they think
will cause you to act in a particularly beneficial way towards them? All
these jokes about used car salesmen who call themselves "Honest Joe" and
_still_ people buy it when someone who clearly has something to gain from
being a Lisp says they are?
So why is nobody _else_ authoritative on whether Scheme is a Lisp?
I think "Your introductoin to Scheme" should go in comp.lang.scheme.
Kent M Pitman
> Kent M Pitman <pit...@world.std.com> writes:
>
>
> > As Erik noted, you're confusing naming with semantics. The simple
> > test of whether there are two namespaces is whether if you bound one,
> > you'd interfere with another. You can't define a function FOO without
> > replacing any macro FOO. You can't define a function LAMBDA because
> > it's reserved (being a special operator). So functions, macros, and
> > special operators are all in the same space.
>
> It would seem that this argument supports the notion that class
> definitions have their own namespace, perhaps shared with types.
Yes, certainly, although you could also claim that neither was a
namespace because there is no syntax-level operation that treats
types or classes. Things like TYPEP and DEFMETHOD and :ELEMENT-TYPE
to OPEN and MAKE-ARRAY arguably operate on objects, not on primitive
language glue. Further, although you can perhaps say that type
declarations are glue, they don't have any semantic effect that is
testable by a conforming program. At least as far as I can remember.
Anyone who wants to make a counter-argument is welcome to.
It is for reasons like this, incidentally, that I conspicuously steered
clear of enumerating the namespaces ANSI CL. It wasn't necessary, and
it seemed a source of gratuitous controversy at the specification level.
The language does what it does, and we're merely discussing the terminology
for most coherently describing that effect.
One could "clean up" some of these language aspects, as ISLISP did,
for example. But you get a language that is probably both "more
compilable" and "less expressive"... depending on what you mean by those
terms, I suppose (since CL does fully compile and ISLISP is fully Turing
powerful).
Kent M Pitman
> * "Pierpaolo BERNARDI" <pierpaolo...@hotmail.com>
> | Well, the front cover of the manual says:
> |
> | "PC Scheme
> | a simple, modern Lisp"
>
> Why are the Scheme people authoritative on whether Scheme is a Lisp?
>
> If you ask almost any person if they are honest, they will answer "yes",
> the dishonest probably more often than the honest. If you want a correct
> and useful answer, you have to find out what they mean: Do they simply
> answer the question honestly, or do they give an answer that they think
> will cause you to act in a particularly beneficial way towards them? All
> these jokes about used car salesmen who call themselves "Honest Joe" and
> _still_ people buy it when someone who clearly has something to gain from
> being a Lisp says they are?
>
> So why is nobody _else_ authoritative on whether Scheme is a Lisp?
>
> I think "Your introductoin to Scheme" should go in comp.lang.scheme.
I probably disagree.
If Pierpaolo is saying that he came to CL by way of Scheme, then the
discussion belongs here, regardless of whether Scheme is a Lisp or not.
(If, by contrast, he is using Scheme only, then I'm agnostic about the
issue. I don't think it's horrible if some Scheme people comment on
this thread... It's perhaps even useful for us to see whether there
are different patterns of how Scheme and Lisp people find out about
these respective areas.)
Also, since no one is doing advocacy in this thread, and people are
merely describing their personal experience, I think we should be
maximally tolerant in this thread in order to encourage people to jump
in without fear they will have their personal experience challenged.
It might really be that the Scheme data is "bad data" to some of us
for some purposes, but I'm not so sure it's "bad data" for all
participating in this forum. Even if you think those of us saying
"Scheme is not a Lisp" "won" the recent debate on that [and I don't
personally think these debates tend to have such definitive results],
there are still people in this community who stand on the "losing"
side. Those people aren't compelled by some mysterious force of law
or enforced shame to change their opinion to go with the majority.
Consequently, some of them may want the Scheme data even if others
don't. And I don't see major harm to any of us if we allow that,
especially since [as so often noted here] we can't prevent speech we
don't like anyway. [Surely you don't want to change that rule? :-)]
It is easier after-the-fact for those of us doing analysis to ignore a
few remarks by a few people if that in context of some subsequent
discussion seems appropriate than it is after-the-fact for us to get
people to contribute who might have been stifled by being unsure about
whether their experience was relevant.
This is what I usually call "brainstorming rules", where you basically
just let everyone speak in a fashion that monotonically increases the
set of information offered and you don't do any filtering, sifting, or
contradicting until later.
(Hopefully Thomas Russ doesn't think my response to him was contradicting
him... I just wanted to make sure we had his data correct...)
Erann Gat
> But in general, using symbols to name things is the (Common) Lisp way,
> and using the values directly is the Scheme way.
It should be noted that it's quite possible to do things the Scheme Way
(on this definition) in Common Lisp. It turns out I've been writing
Scheme code in Common Lisp for years without even realizing that's what I
was doing. For many applications this is not necessarily a bad approach
IMO.
E.
Marco Antoniotti
g...@jpl.nasa.gov (Erann Gat) writes:
Of course it is not.
It is the other way around that does not work. You cannot write
(make-array (2 2) :initial-contents '((1 0) (0 1)))
in Scheme (lest being bitten badly when you port your code to Scheme
implementation 1 godzillion + 42).
Erann Gat
<mar...@cs.nyu.edu> wrote:
> g...@jpl.nasa.gov (Erann Gat) writes:
>
> > In article <32274199...@naggum.net>, Erik Naggum
<er...@naggum.net> wrote:
> >
> > > But in general, using symbols to name things is the (Common) Lisp way,
> > > and using the values directly is the Scheme way.
> >
> > It should be noted that it's quite possible to do things the Scheme Way
> > (on this definition) in Common Lisp. It turns out I've been writing
> > Scheme code in Common Lisp for years without even realizing that's what I
> > was doing. For many applications this is not necessarily a bad approach
> > IMO.
>
> Of course it is not.
>
> It is the other way around that does not work.
Right. That's one reason I don't use Scheme even though I'm often writing
Scheme-style code.
Now that I think of it, I've written assembler, Forth, and Scheme code,
all in Common Lisp, and all to good effect. In fact, just about the only
thing I haven't used Lisp for is writing Lisp code. :-)
E.
Pierpaolo BERNARDI
"Erik Naggum" <er...@naggum.net> ha scritto nel messaggio news:32274553...@naggum.net...
> I think "Your introductoin to Scheme" should go in comp.lang.scheme.
What are you talking about? What introduction to Scheme?
P.
Pierpaolo BERNARDI
"Kent M Pitman" <pit...@world.std.com> ha scritto nel messaggio news:sfw662z...@shell01.TheWorld.com...
> If Pierpaolo is saying that he came to CL by way of Scheme, then the
> discussion belongs here, regardless of whether Scheme is a Lisp or not.
I have said nothing about where I came from.
> (If, by contrast, he is using Scheme only, then I'm agnostic about the
> issue. I don't think it's horrible if some Scheme people comment on
> this thread... It's perhaps even useful for us to see whether there
> are different patterns of how Scheme and Lisp people find out about
> these respective areas.)
I use CL only, thank you very much.
> Also, since no one is doing advocacy in this thread, and people are
> merely describing their personal experience, I think we should be
> maximally tolerant in this thread in order to encourage people to jump
> in without fear they will have their personal experience challenged.
How depressing that you have to write this.
P.
Arjun Ray
<pit...@world.std.com> wrote:
| Arjun Ray <ar...@nmds.com.invalid> writes:
| These [four] are the only namespaces that are specially understood by
| the langauge, and it is possible to independently bind these without
| interfering with the others.
This is what I understand principally by "namespace", and the sense in
which I found Scheme to be worrisome - if "meanings", i.e. referents, of
names can be clobbered, some syntactic means to distinguish them would
have been useful, at least to me, as opposed to an imposed discipline of
watching out for clobbering. (That is, instead of always having to
invent distinct names lest bad things happen, the ability to use syntax
to indicate intended meaning seems more conducive to productivity.)
|> Function versus variable is pretty clear, but what about special forms,
|> macros, keywords, filler (syntactic sugar), and the like?
|
| As Erik noted, you're confusing naming with semantics.
As a beginner in CL but no stranger to languages, I find comprehension
impeded by prior exposure to apparently similar terminology which has
been used elsewhere! I was trying to say what I meant, but failed:-(
My concern was with how many different kinds of things can be bound to a
name without interference, where the grammatical context would suffice
to disambiguate the correct binding. Perl, for instance, has typeglobs,
which is what all names (except "lexicals") immediately refer to; the
typeglob in turn is a tuple of pointers to different types of values
("scalar", array, hash table, function, etc); and the correct value
referent is determined by syntax. So an expression like
$foo -> foo ( @foo{ @foo } )
has determinate meaning in that an object, a method, a hash table and an
array can all concurrently be named 'foo' at the point of evaluation.
| You can't define a function FOO without replacing any macro FOO. You
| can't define a function LAMBDA because it's reserved (being a special
| operator). So functions, macros, and special operators are all in the
| same space.
Since their incidence is in the car of a form - the first or operator
position - I can see why this is so. My understanding is that operands
are variables unless indicated otherwise. If so, I was trying to refine
my understanding of the "otherwises".
My thanks to Erik, Marco and you. You've been very helpful. Back to
the books and the Hyperspec for me:-)
Brian Palmer
> issue. I don't think it's horrible if some Scheme people comment on
> this thread... It's perhaps even useful for us to see whether there
> are different patterns of how Scheme and Lisp people find out about
> these respective areas.)
>
> Also, since no one is doing advocacy in this thread, and people are
> merely describing their personal experience, I think we should be
> maximally tolerant in this thread in order to encourage people to jump
> in without fear they will have their personal experience challenged.
As a note, I don't agree with your statement that no one is doing
advocacy in this thread. I'll phrase this as, I for one would like
advocacy to be not in this thread, as I'm interested in people's
stories.
> It might really be that the Scheme data is "bad data" to some of us
> for some purposes, but I'm not so sure it's "bad data" for all
> participating in this forum.
Here's one voice agreeing to that last -- I am interested in Scheme in
the context of the various lisps (I am not a CL programmer; most of my
lisp programming is actually elisp for personal use).
In fact,that's pretty much my story as it is coming so far to lisp, so
it's even marginally on-topic to the thread. I bought a used book on
Franz lisp in high school and read the book multiple times but had no
access to a software environment, so it was all theoretical; lent the
book to someone at work and never since regained it =)
At school, the class at Stanford which is devoted to teaching Lisp
hasn't been taught in many years, so it's covered for a week or two in
the basic programming course, and lisp1.5 (I believe it's called that;
basically map,append,cons,car,cdr, and maybe one or two other
functions) is used for a comparative concepts in programming languages
class. Since then, I've begun doing more and more customization and
scripting of emacs.
--
If nature has made any one thing less susceptible than all others of
exclusive property, it is the action of the thinking power called an
idea, which an individual may exclusively possess [only] as long as he
keeps it to himself.... -- Thomas Jefferson
Kent M Pitman
> | You can't define a function FOO without replacing any macro FOO. You
> | can't define a function LAMBDA because it's reserved (being a special
> | operator). So functions, macros, and special operators are all in the
> | same space.
>
> Since their incidence is in the car of a form - the first or operator
> position - I can see why this is so. My understanding is that operands
> are variables unless indicated otherwise. If so, I was trying to refine
> my understanding of the "otherwises".
Yes, "evaluation" normally occurs in the variable namespace. Go tags
and return tags are irrelevant here. #' is the way you "promote"
something in the function namespace to the place where normal
evaluation occurs, and in a sense, funcall is a vague kind of inverse,
taking a variable and causing it to be invoked as if it had occurred
in the functional position... So the rule is not terribly complicated.
It perhaps becomes more complicated because the Scheme community has a
completely different rule and we've added some compatibility syntax for
mindshare with them, but the rule actually makes our rules more complicated.
To think about it right in lisp, think of (lambda (x) x) as a "name" of
a function. So (f 1) has the function name F in the car of the form, and
((lambda (x) x) 1) has the function name (lambda (x) x) in the car of the
form; that is, lambda is an "anonymous" name, just like in English when
you can say "that man over there" in place of "Fred" if you either don't
know Fred's name or don't choose to name him, but prefer to work by
describing the effect you want. Likewise, you can say #'f or
#'(lambda (x) x) and it's pretty consistent. But we added the ability
to say (lambda (x) x) for compatibility with Scheme and that might be
confusing to a non-schemer. LAMBDA is just a macro that translates
(lambda (x) x) into #'(lambda (x) x), which is the primitive notation.
[I'm assuming you understand the #'foo == (function foo) relation.]
> My thanks to Erik, Marco and you. You've been very helpful. Back to
> the books and the Hyperspec for me:-)
Ok. Have fun / good luck.
Jacek Generowicz
> It perhaps becomes more complicated because the Scheme community has a
> completely different rule and we've added some compatibility syntax for
> mindshare with them, but the rule actually makes our rules more complicated.
>
> To think about it right in lisp, think of (lambda (x) x) as a "name" of
> a function. So (f 1) has the function name F in the car of the form, and
> ((lambda (x) x) 1) has the function name (lambda (x) x) in the car of the
> form; that is, lambda is an "anonymous" name, just like in English when
> you can say "that man over there" in place of "Fred" if you either don't
> know Fred's name or don't choose to name him, but prefer to work by
> describing the effect you want. Likewise, you can say #'f or
> #'(lambda (x) x) and it's pretty consistent. But we added the ability
> to say (lambda (x) x) for compatibility with Scheme
By this, do you mean having (lambda (x) x) evaluate to a function
[thereby breaking the consistency with f, where simply evaluating f
does not (necessarily) give you a function, but whatever is bound to f
in the value namespace] ?
Bruce Lewis
it opened up my eyes to what a great language Scheme is. I use Scheme
almost exclusively now, but still check in on c.l.l to see what's going
on with CL.
Just kidding!
Kent M Pitman <pit...@world.std.com> writes:
> It's perhaps even useful for us to see whether there are different
> patterns of how Scheme and Lisp people find out about these respective
> areas.
One pattern I notice is that nobody finds Scheme by being introduced to
CL first (as in my joke above), while a lot of people find CL by being
introduced to Scheme first.
There's a useful conclusion to draw from this. If you throw up your
hands and say it's hopeless for someone who learns Scheme first to then
learn CL, you're closing a door through which many people enter the CL
community.
--
<brlewis@[(if (brl-related? message) ; Bruce R. Lewis
"users.sourceforge.net" ; http://brl.sourceforge.net/
"alum.mit.edu")]>
Dorai Sitaram
Bruce Lewis <brl...@users.sourceforge.net> wrote:
>I was introduced to CL in a college course. I liked it, and eventually
>it opened up my eyes to what a great language Scheme is. I use Scheme
>almost exclusively now, but still check in on c.l.l to see what's going
>on with CL.
>
>Just kidding!
>
>Kent M Pitman <pit...@world.std.com> writes:
>
>> It's perhaps even useful for us to see whether there are different
>> patterns of how Scheme and Lisp people find out about these respective
>> areas.
>
>One pattern I notice is that nobody finds Scheme by being introduced to
>CL first (as in my joke above), while a lot of people find CL by being
>introduced to Scheme first.
Strange as it may seem, I was aware of Common Lisp --
CLtL1 anyway -- before I was of Scheme. However
I didn't have much programming experience in either at
the time so it would be wrong to imply I "left" either
language for the other.
I am still evaluating them. :-)
Jon Allen Boone
> I'm always interested in how people "came to something." In this
> case it's Lisp. How about relaying how you "came to Lisp?"
I first heard of Lisp while I was in high school in the
mid-1980s - probably from reading Steven Levy's _Hackers_, but
possibly from another book I read around the same time. At the
time, my computer was an Apple IIc and Assembler/Basic were mostly
what I worked with, though I never mastered assembler. At this
time, I also worked with Pascal [mostly used Borland Turbo Pascal on
PCs] and Logo for the Apple II [loved those turtle graphics...],
while getting exposure to Prolog, Fortran and HyperCard Scripting...
Between 1988 and 1990, I learned C and Scheme, as well as
participating in an experiment conducted by the CMU Psychology
Department related to teaching Lisp [probably Common Lisp, although
I'm not sure since it was a very small subset]. Scheme came easiest
to me, as it "just made sense." I was also impressed at how easily
we could switch to a "object oriented" [via message passing] style
in Scheme...
Between 1990 and 1997, I worked in C and various scripting
languages including Perl and Awk.
Between 1997 and 2002, I added some C++, Java, ML, as well as
revisiting Scheme. Since I prefer more abstraction in my programs,
I find writing C code to be tedious - these OO-oriented and
functional-oriented languages were more enjoyable to me than plain,
old, vanilla C.
During all this time, I was an avid Emacs user, so I hacked [in
the sense of chopping roughly with no real skill] at ELisp.
Finally, in 2002, I bit the bullet and decided to learn Common
Lisp. I *love* Common Lisp and am enthusiastically "building up"
the language to support coding the solution to my current problem in
"the native language" of the problem domain.
-jon
--
------------------
Jon Allen Boone
ipmo...@delamancha.org
Kent M Pitman
It's not a question of what it evaluates to. #'f can only evaluate to
a function because the function namespace is thus restricted, but f
can also evaluate to a function.
I mean (lambda (x) x) evaluating _as_ a function, that is, going
through a process some call feval (pronounced "eff eval") is what's at
issue, that is, what the processing of a name or lambda expression in
the functional namespace--if it's a name, grabbing its function
binding, and if it's a lambda creating its closure, ... at least
conceptually ... In the case of lambda combinations like ((lambda (x)
x) 'a) this is probably done specially by most implementations,
without obtaining a function object, but that's an
implementation/efficiency issue, not really a definitional issue.
In CL, lambda expressions were originally things that were fevaled,
not evaled. It is arguably confusing and overcomplex that they are
now both. (I daresay CL programmers are able to handle this
complexity. I'm merely observing that it's there.) But it's only an
issue while macro forms are present, and lots of things in macro land
can be potentially syntactically confusing. Once macro expansion is
done, things are simple again and there is only #'(lambda (x) x) as a
form; no more apparent references to unguarded lambdas going into the
eval half of things.
Marco Antoniotti
Arjun Ray <ar...@nmds.com.invalid> writes:
...
> My concern was with how many different kinds of things can be bound to a
> name without interference, where the grammatical context would suffice
> to disambiguate the correct binding. Perl, for instance, has typeglobs,
> which is what all names (except "lexicals") immediately refer to; the
> typeglob in turn is a tuple of pointers to different types of values
> ("scalar", array, hash table, function, etc); and the correct value
> referent is determined by syntax. So an expression like
>
> $foo -> foo ( @foo{ @foo } )
>
> has determinate meaning in that an object, a method, a hash table and an
> array can all concurrently be named 'foo' at the point of
> evaluation.
Now I understand. You show very grave signs of Perlite. :)
In theory (and practice), in CL, you can write womething like
(funcall (find-method-named 'foo)
(gethash (find-hash-table-named 'foo)
(find-string-named 'foo)))
(lots of details missing).
Note that FUNCALL and GETSHASH are already part of the language.
FIND-METHOD is as well. To support FIND-HASH-TABLE-NAMED and
FIND-STRING-NAMED you need to add a few things. You can do do that in
Scheme as well (of course, you are missing GETHASH, but that is just
one of the problems with Scheme).
So, in general, in CL you can set up as many "namespaces" as you want,
and then use the language and the macro systems (i.e. macro characters
included) to access the underlying namespace.
E.g. you could have the macro characher @ (Perlite is getting to me)
set up some checks, like
@foo
==>
(let ((v foo))
(check-type v 'hash-table) v)
But then, why would you like to do that, just to separate things that
are already checked for?
> My thanks to Erik, Marco and you. You've been very helpful. Back to
> the books and the Hyperspec for me:-)
You are welcome.
Erik Naggum
| There's a useful conclusion to draw from this. If you throw up your
| hands and say it's hopeless for someone who learns Scheme first to then
| learn CL, you're closing a door through which many people enter the CL
| community.
Sure, they "discover" Common Lisp, but keep writing Scheme in it. Some
"think Scheme" even though they are actually learning and using Common
Lisp. It is important to inform those who discover Common Lisp that it
is not just "a better Scheme". Those who are not challenged in their
belief that they can just keep writing Scheme may spread their "take" on
Common Lisp faster than those who have figured it out, especially to
other Scheme freaks. Scheme is a like a mind-altering drug or some cult
that warps people's ability to think straight, and the resistance to it
is well-deserved, but precisely for that reason, people need to discover
that knowing Scheme is not beneficial to learning a real Lisp.
For instance, the following quote from O'Reilly's Write for Us pageน
relates to deservedly bad experience with Scheme, not to Common Lisp,
which is largely if not completely unknown.
However, we're NOT looking for: Any books on LISP, LaTeX, or Web-based training.
It is good that Scheme victims discover Common Lisp, just as with users
of any other programming language, but most of the others discover that
Common Lisp is a _different_ language from what they are used to, adjust
accordingly, and proceed to _learn_ it. Scheme victims seem to lack the
appriciation that Common Lisp is an entirely a new language, and just
think they know it, without ever getting the point. Just like Java and C
have very little in common besides the superficial syntactic similarity,
Scheme and Common Lisp have very little in common besides the superficial
syntactic similarity. This is just like the racial slur "you people all
look the same to me", where a group of people look "similarly different".
In some people's minds, there is no need distinguish between them as long
as you are not among them. Common Lisp suffers greatly from being
similarly different from "normal" languages as the villainous Scheme.
-------
น http://www.oreilly.com/oreilly/author/writeforus_1101.html
Kent M Pitman
> * Bruce Lewis <brl...@yahoo.com>
> | There's a useful conclusion to draw from this. If you throw up your
> | hands and say it's hopeless for someone who learns Scheme first to then
> | learn CL, you're closing a door through which many people enter the CL
> | community.
>
> Sure, they "discover" Common Lisp, but keep writing Scheme in it.
This seems to me a simple matter of proper education. I doubt it's a
fundamental property of the universe.
> Scheme is a like a mind-altering drug or some cult
> that warps people's ability to think straight, and the resistance to it
> is well-deserved,
My bet is that the same is said for Lisp. Education is itself a
mind-altering drug and it warps people's ability to think in the way
they would have thought absent it. If it warrants resistance, it is
not for the per se reason that it alters minds.
> but precisely for that reason, people need to discover
> that knowing Scheme is not beneficial to learning a real Lisp.
Well, Scheme intuitions are likely to mislead you in Lisp. But
right-handed driving intuitions may mislead one in driving in the UK.
I'm not sure that's the same as saying "learning to drive in the UK is
without value". I think the important thing is to make sure that
people visiting from the UK know that they are not still in the UK.
(Heck, I have to make sure people visiting from California know they
are not still in California when they try to navigate Boston
traffic...)
> For instance, the following quote from O'Reilly's Write for Us pageน
> relates to deservedly bad experience with Scheme, not to Common Lisp,
> which is largely if not completely unknown.
>
> However, we're NOT looking for: Any books on LISP, LaTeX, or
> Web-based training.
Could this just mean one is in the pipe? Does anyone know why this would
be there? If it is a bad experience, can we find out what?
There presumably have been successful books in this subject area. Perhaps
they are worried that all that needs to be known about this area is already
available in print. Perhaps we could see if the "ostrich with its head in
the sand" or the "hear no evil, see no evil, speak no evil" monkeys are
still available for a cover...
> It is good that Scheme victims discover Common Lisp, just as with users
> of any other programming language, but most of the others discover that
> Common Lisp is a _different_ language from what they are used to, adjust
> accordingly, and proceed to _learn_ it. Scheme victims seem to lack the
> appriciation that Common Lisp is an entirely a new language, and just
> think they know it, without ever getting the point.
(All the more reason there should be a book.)
> Just like Java and C
> have very little in common besides the superficial syntactic similarity,
> Scheme and Common Lisp have very little in common besides the superficial
> syntactic similarity. This is just like the racial slur "you people all
> look the same to me",
But as with racial situations like this, there's an inverse problem
that occurs when people accuse people of making this slur without
checking. Both sides are often guilty of this. People of color green
often accuse people of color blue of being 'all alike' and it invites
people of color blue to assume all people of color green are out to
get them. The solution is to stop going on the basis of the name, and
to do the much harder thing of working (from _both_ sides) with people
as individuals. I think there is a parallel to your remark here.
> where a group of people look "similarly different".
> In some people's minds, there is no need distinguish between them as long
> as you are not among them.
Yes, this is so. But it cannot be the case that this set of people is named
by the name "Scheme programmers", nor even "people who prefer to program
in Scheme", since I can point to counterexamples.
> Common Lisp suffers greatly from being
> similarly different from "normal" languages as the villainous Scheme.
>
> -------
> น http://www.oreilly.com/oreilly/author/writeforus_1101.html
Thanks for the page reference.
I'll see if I can follow up with O'Reilly to find out what the issue
is here. If I can get a contact address. I got a 404 when I clicked
on the "O'Reilly Contacts" item at the bottom of that page. Maybe
they don't want a book on web training because it would challenge the
job security of their webmaster. ;)
Thomas F. Burdick
> Erik Naggum <er...@naggum.net> writes:
>
> > For instance, the following quote from O'Reilly's Write for Us pageน
> > relates to deservedly bad experience with Scheme, not to Common Lisp,
> > which is largely if not completely unknown.
> >
> > However, we're NOT looking for: Any books on LISP, LaTeX, or
> > Web-based training.
>
> Could this just mean one is in the pipe? Does anyone know why this would
> be there? If it is a bad experience, can we find out what?
>
> There presumably have been successful books in this subject area. Perhaps
> they are worried that all that needs to be known about this area is already
> available in print. Perhaps we could see if the "ostrich with its head in
> the sand" or the "hear no evil, see no evil, speak no evil" monkeys are
> still available for a cover...
I think it might be the fear of a saturated market. I'm guessing
that's the case with LaTeX -- both because I personally think that
subject is covered quite well in the English language, and because of
this book: "LaTeX par la pratique",
<http://www.oreilly.fr/catalogue/latex.html>.
--
/|_ .-----------------------.
,' .\ / | No to Imperialist war |
,--' _,' | Wage class war! |
/ / `-----------------------'
( -. |
| ) |
(`-. '--.)
`. )----'
Dr. Edmund Weitz
> > น http://www.oreilly.com/oreilly/author/writeforus_1101.html
>
> Thanks for the page reference.
>
> I'll see if I can follow up with O'Reilly to find out what the issue
> is here. If I can get a contact address. I got a 404 when I
> clicked on the "O'Reilly Contacts" item at the bottom of that page.
> Maybe they don't want a book on web training because it would
> challenge the job security of their webmaster. ;)
Hehe, maybe he himself has added 'web training' to the list of
'not-wanted' subjects... :)
Anyway, the page you were looking for seems to be this one:
<http://www.oreilly.com/oreilly/contact.html>
It would be nice to hear what they answer to your questions.
Edi.
--
Dr. Edmund Weitz
Hamburg
Germany
The Common Lisp Cookbook
<http://cl-cookbook.sourceforge.net/>
Erann Gat
<pit...@world.std.com> wrote:
> Erik Naggum <er...@naggum.net> writes:
>
> > * Bruce Lewis <brl...@yahoo.com>
> > | There's a useful conclusion to draw from this. If you throw up your
> > | hands and say it's hopeless for someone who learns Scheme first to then
> > | learn CL, you're closing a door through which many people enter the CL
> > | community.
> >
> > Sure, they "discover" Common Lisp, but keep writing Scheme in it.
>
> This seems to me a simple matter of proper education. I doubt it's a
> fundamental property of the universe.
That's a pretty arrogant thing to say. As someone who writes Scheme code
in Common Lisp (apparently) I take umbrage at your claim that 1) this is
self-evidently the wrong thing to do and 2) that I do so because I haven't
had a "proper education". Tell me, what do you consider a "proper
education"? I've read the hyperspec, CLTL1&2, Norvig, both Graham books,
Quiennec, and about ten years worth of c.l.l., not to mention every paper
of yours that I could lay my hands on. What would you have me do instead?
E.
Erik Naggum
| This seems to me a simple matter of proper education. I doubt it's a
| fundamental property of the universe.
It seems to me that Scheme victims are far less aware of the need for
re-education that users of any other language. This is a level of
language-design arrogance that comes with most Scheme texts and material
that rubs off on students who think they have found the One True Design.
| My bet is that the same is said for Lisp.
Well, if "Lisp" here means Common Lisp, I have never seen it.
| Education is itself a mind-altering drug and it warps people's ability to
| think in the way they would have thought absent it.
True, but I said thinking straight, not keep thinking crooked.
| If it warrants resistance, it is not for the per se reason that it alters
| minds.
No, but any "education" that causes people to become unable to cope with
the world the live in, when they could cope just fine previously, has
good reason to be met with resistance and the association with brain-
washing cults is normally not welcome.
> However, we're NOT looking for: Any books on LISP, LaTeX, or Web-based
> training.
| Could this just mean one is in the pipe?
Nope. This is policy.
| Does anyone know why this would be there? If it is a bad experience, can
| we find out what?
I have tried, but I have only off-the-record comments and reasoning. If
you have more success, that would be great. However, what I have heard
is the old "Scheme frightens people", which is true, and then "Scheme is
a Lisp", which is not, so "Lisp frightens people" follows, which it
_should_ not even if the second premise were true. For a long time, my
conclusion has been that Scheme really is harmful to people's ability to
think properly and results in a perspective on programming and on problem
solving in general that requires the equivalent of psychotherapy to find
out what horrible "childhood" you had and how it affects your adult life.
In general, I have found Scheme to be an extraordinarily _limiting_
language, not the least in the warped idea that all code must be elegant
and all solutions minimalistic, that "dirty tricks" must be avoided at
all cost, etc. This fear of getting dirt under their nails is perhaps
the most damaging effect of working with an over-elegant language that
places so much focus on doing The Right Thing. The fact that the Scheme
language is so incredibly _tiny_ is a testament to how _little_ you can
do in real life that qualify as The Right Thing. If more One-Right-Thing
Maximally-Elegant Final Solutions were possible, they would have gotten
into Scheme, right? So _everything_ else just has to be dirtier than
Scheme, but this never dawns on some people. Some people react with
hostility to the expressed notion that "we're clean, you're not" that
comes with languages that have excluded everything that was not "clean"
enough. (Any similarity to dissing the unwashed masses is intentional.)
I think Scheme _deserves_ its really bad reputation and should not be
taught or used. I would rather teach people Java and rescue them later
than even tell them about Scheme. At least they will have gotten some
exposure to that dirty old Real World and Common Lisp will be seen as an
improvement. Too many Scheme victims regard anything after Scheme to be
inferior and uglier and this simply does not help them to learn anything.
Will Hartung
"Erik Naggum" <er...@naggum.net> wrote in message
news:32275453...@naggum.net...
> * Kent M Pitman <pit...@world.std.com>
> | This seems to me a simple matter of proper education. I doubt it's a
> | fundamental property of the universe.
>
> It seems to me that Scheme victims are far less aware of the need for
> re-education that users of any other language. This is a level of
> language-design arrogance that comes with most Scheme texts and material
> that rubs off on students who think they have found the One True Design.
I somewhate agree with the perception of the "One True Design" arrogance.
There is a beauty in the simplicity of Scheme, but that beauty is all there
is to it. It's nice thing to gander and gawk and perhaps admire from afar,
thats about it. Once the realities of the programming world appear, and
Stuff starts getting bolted on to the system, you lose that beauty and
elegance. Once at that stage, the question then becomes "Why Scheme?". Why
indeed.
> > However, we're NOT looking for: Any books on LISP, LaTeX, or Web-based
> > training.
>
> | Could this just mean one is in the pipe?
>
> Nope. This is policy.
>
> | Does anyone know why this would be there? If it is a bad experience,
can
> | we find out what?
>
[ no books because Scheme, ergo Lisp, is Scary...*snipped* ]
I would have simply thought that the market for Lisp books in general was
simply too mature. Pretty much any CL book in the past 10 years is
completely relevant and up to date today.
They only common CL book that CL itself has actually "passed by" is CLTL2.
I think that a good book on CLIM (something beyond an API reference, more
like "The CLIM Way"), or a more focused book on Lisp Programming Techniques
and Optimization (going beyond PAIP and On Lisp) would be nice. But, I can
see those being fairly niche books, and perhaps too vendor dependant.
> I think Scheme _deserves_ its really bad reputation and should not be
> taught or used. I would rather teach people Java and rescue them later
> than even tell them about Scheme. At least they will have gotten some
> exposure to that dirty old Real World and Common Lisp will be seen as an
> improvement. Too many Scheme victims regard anything after Scheme to be
> inferior and uglier and this simply does not help them to learn
anything.
The only thing that Java really lacks as a good First Language, I think, is
an interactive environment to play around in. The only good thing Scheme
would do is put the silly fear of S-Expressions and first-class functions
out of peoples minds. They were my biggest hurdles getting into this
environment.
Will Hartung
(wi...@msoft.com)
Nils Goesche
>
> "Erik Naggum" <er...@naggum.net> wrote in message
> news:32275453...@naggum.net...
>> * Kent M Pitman <pit...@world.std.com>
>> | This seems to me a simple matter of proper education. I doubt it's a
>> | fundamental property of the universe.
>>
>> It seems to me that Scheme victims are far less aware of the need for
>> re-education that users of any other language. This is a level of
>> language-design arrogance that comes with most Scheme texts and material
>> that rubs off on students who think they have found the One True Design.
>
> I somewhate agree with the perception of the "One True Design" arrogance.
> There is a beauty in the simplicity of Scheme, but that beauty is all there
> is to it. It's nice thing to gander and gawk and perhaps admire from afar,
> thats about it. Once the realities of the programming world appear, and
> Stuff starts getting bolted on to the system, you lose that beauty and
> elegance. Once at that stage, the question then becomes "Why Scheme?". Why
> indeed.
I wonder if it still has beauty in your eyes when you come to that
conclusion. How can something that turns out to be bad have beauty
at all? Maybe it first appears to be beautiful, then your taste
ripes, and it isn't beautiful anymore. Is Scheme Kitsch? :-)
Regards,
--
Nils Goesche
"Don't ask for whom the <CTRL-G> tolls."
PGP key ID 0x42B32FC9
Kent M Pitman
> In article <sfwk7re...@shell01.TheWorld.com>, Kent M Pitman
> <pit...@world.std.com> wrote:
>
> > Erik Naggum <er...@naggum.net> writes:
> > ...
> > > Sure, they "discover" Common Lisp, but keep writing Scheme in it.
> >
> > This seems to me a simple matter of proper education. I doubt it's a
> > fundamental property of the universe.
>
> That's a pretty arrogant thing to say. As someone who writes Scheme code
> in Common Lisp (apparently) I take umbrage at your claim that 1) this is
> self-evidently the wrong thing to do and 2) that I do so because I haven't
> had a "proper education".
I think we're talking about different things.
I was taking the remark more literally. People really do things like:
(defun f (x)
(defun g (x) ...)
... use g ...)
This kind of thing works in Scheme but doesn't mean what Scheme people
think in CL.
Certainly there are compatible styles one can adopt, but one can also try
to pretend CL has Scheme semantics and get in trouble.
Even just relying on tail calling when you've been told it's not reliably
there in CL is an example.
Erann Gat
<pit...@world.std.com> wrote:
> g...@jpl.nasa.gov (Erann Gat) writes:
>
> > In article <sfwk7re...@shell01.TheWorld.com>, Kent M Pitman
> > <pit...@world.std.com> wrote:
> >
> > > Erik Naggum <er...@naggum.net> writes:
> > > ...
> > > > Sure, they "discover" Common Lisp, but keep writing Scheme in it.
> > >
> > > This seems to me a simple matter of proper education. I doubt it's a
> > > fundamental property of the universe.
> >
> > That's a pretty arrogant thing to say. As someone who writes Scheme code
> > in Common Lisp (apparently) I take umbrage at your claim that 1) this is
> > self-evidently the wrong thing to do and 2) that I do so because I haven't
> > had a "proper education".
>
> I think we're talking about different things.
That's possible. I'm just going on what I've been told here, to wit: that
using symbols for everything is the (Common) Lisp way, and using values
directly is the Scheme way. I thought that "doing things the Scheme way"
and "writing Scheme in [Common Lisp]" meant the same thing.
E.
Will Hartung
"Nils Goesche" <car...@cartan.de> wrote in message
news:a94urs$dqgs$1...@ID-125440.news.dfncis.de...
As they say, Beauty is in the eye, etc.
If the beauty of Scheme is its simplicity, then that beauty is pervasive and
can't be clouded.
If the beauty is that it provides a nice "start from scratch" foundation to
build upon, then no matter what you clump on to it, that original foundation
is still there.
But if a programmer sees that simplicity and thinks that it will translate
into their real world application, that beauty then becomes a lot of work
and loses its luster.
If you have to bolt on all of this extra functionality to the base package
to get your work done, then the question is do you really still have Scheme,
and not something else.
As a completely non sequitor analogy from the world of motorcycles (yes, I
agree this is basically off topic for c.l.l, but at least I'm not bitching
about Erik...). In some circles of the motorcycling world, one may encounter
"a trike conversion", essentially having two wheels in the back rather than
one. When someone does this, do they still have a motorcycle? If someone
converts a Honda Gold Wing thusly, why not spring for something like a Miata
instead?
Certainly the owner wants to keep some bond with motorcyles that a Miata
doesn't offer, but he's not riding a motorcycle, IMHO. For me, the beauty of
the motorcycle is gone, the dynamics of the riding experience. But for the
owner, it apparently is not. Perhaps they value the more open feeling one
would get riding a trike, or the comraderie he gets by associating with the
other Gold Wing folks who will welcome him with open arms, trike or no.
So, for me, bolting a Common Lisp compatability package onto Scheme gets me
neither. Lumping a bunch of "non-standard" and incompatible stuff together
removes the "scheme-ness" of Scheme. You end up coding in those frameworks,
not necessarily Scheme. People using VC++ for Windows apps are more writing
MFC than C++, for example.
Therefor, the luster goes away because with the added cruft, the simplicity
get occluded. I was blinded by Schemes simplicity, the novelty of its
idioms. But then I found that they're a lot extra work, and soon those
idioms became barriers, or were written away and "simplified". Soon after,
you're not using Scheme at all, rather some bastard son that no one else is
using.
But, hey, that's just me.
Will Hartung
(wi...@msoft.com)
Nels Tomlinson
these back when they were new, or one of the little Epson notebooks that
competed with them, but they were WAY to high-priced for me back then.
Yesterday, I got the Tandy for $5.
I'm comtemplating kludging together a little lisp to fit in it. It has
about 24k RAM and an 8085. I've gone looking for info on implementing
lisp, and haven't found a lot so far. If you have any of your old
stuff, such as z80 code or a version of that old DDJ article, I'd admire
to see it.
Just to keep this on topic, I think that my first introduction to lisp
was when I tried to use an old symbolic math program called mumath,
which was written in a lisp (can't remember which, or what happened to
mumath). In order to adjust mumath's parameters, one had to set various
variables. I found it painful to deal with those parentheses in edit on
a pc. Eventually I found a shareware (or public domain?) lisp in a
download directory on the University of Alaska's Honeywell mainframe,
and started playing with that, using Wordstar for an editor. I wrote
some little programs, but I stuck to Fortran for serious work. I was
doing everything on University pc's (Fujitsu and IBM), since they were
reluctant to give undergrads an account on the engineering Vax, and
Honeywell's Fortran IV was painfully buggy.
I got interested in lisp again a couple years ago when I got started
playing with Maxima, which is another symbolic math program written in
lisp. This time, I'm taking it a little more seriously, and want to
learn to use it effectively. Maybe one of these days I'll get there.
Paul Tarvydas wrote:
> My first exposure to Lisp was in a programming languages course circa 1974
> (using Siklosky's "Let's Talk Lisp"). I was baffled by it and intrigued
> that I'd encountered a language that I couldn't master.
>
> Around 1975/76 I wire-wrapped a Z80 board (schematic was the center-fold of
> the first anniversary issue of Byte magazine), with 2K of static RAM and 10K
> of dynamic (yes, 12K, as in "kilo" bytes total RAM) and ported various Tiny
> Basics to it. Probably in Dr. Dobb's, I found out about Fritz van der
> Wateren's Lisp for the 6800, purchased a copy (it came printed in a booklet
> with commented 6800 assembler code) and sight-read it into the Z80 (the 6800
> version was 4K in size, the Z80 transliteration was 5K).
>
> Once running well (the final GC glitch (a sight-reading typo) was found
> about 6 months later :-), I wrote a simple editor and debugger in lisp and
> sent an article in to DDJ ('78, '79?). I had mono at the time, so I dropped
> out of school for a term and had lots of spare time to kill. The article
> was printed on an IBM Selectric typewriter with 11 solenoids, which I'd
> salvaged from a Wang word processor.
>
> I typed in the Lisp compiler from John R. Allen's "Anatomy of Lisp" (lots of
> typos in the edition of the book I had) and got it running, emitting Z80
> binary. I had enough of the 12K[*] left over to hold the source code for an
> "iota" function (see APL), to compile it and run it.
>
> pt
>
> [*] My recollection is a bit hazy. At some point, I coaxed the dynamic RAM
> up to 23K [sic - I was using bargain bin TMS 22-pin dynamic RAM chips for
> which I had incomplete specs; it turned out that my cpu timing was marginal
> for the RAM, but would work if I added entropy to the wire wrapping job]. I
> might have built the Lisp compiler only after I had doubled the memory :-).
>
>
Patrick W
> * Kent M Pitman <pit...@world.std.com>
> | This seems to me a simple matter of proper education. I doubt it's a
> | fundamental property of the universe.
>
> It seems to me that Scheme victims are far less aware of the need for
> re-education that users of any other language. This is a level of
> language-design arrogance that comes with most Scheme texts and material
> that rubs off on students who think they have found the One True Design.
It seems that getting over Scheme can be a difficult task. However,
it's clear that getting over the getting over of Scheme can take even
longer ...
Pierpaolo BERNARDI
"Nels Tomlinson" <nelsto...@gci.net> ha scritto nel messaggio news:3CB67181...@gci.net...
> Just to keep this on topic, I think that my first introduction to lisp
> was when I tried to use an old symbolic math program called mumath,
> which was written in a lisp (can't remember which,
Mumath was a language built on top of mulisp, basically it was
mulisp with infix syntax. Mumath was used to implement the
computer algebra system musimp.
> or what happened to mumath).
Musimp has been rewritten in mulisp, and now is called
Derive. It lives as a cheap computer algebra system for
windows and as the engine of some TI calculators.
P.
Pekka P. Pirinen
> case it's Lisp. How about relaying how you "came to Lisp?"
Good idea. These stories are interesting!
At the school computer club, me and two other guys were interested in
computer languages. This was a problem, since the only language we
had was BASIC (on the TRS-80, mostly). So we learned assembly
language, and read books on various languages, and designed our own
language, mostly based on APL, which we thought was really powerful -
but we never got started on implementing it.
One day, another kid, Orri Erling, comes in, and he's written a Lisp
interpreter in Z80 assembly. That was quite impressive, even though
not practical to use, as he never quite finished the system, having
found something more interesting to do. So grade 10 (3rd-to-last) was
when I got the idea that Lisp was the coolest language to play with.
I must've read some book on it at this time, but I don't remember
which.
Later, we went to various Universities, but kept in touch with Orri
who was a couple of years younger than us. He developed this plan for
"taking over the world" by writing a better database management system
- in Lisp, naturally - and wanted to start a company. When he asked
the three of us to join, we were excited and said "Sure!" This was
before Oracle, so it made some sense.
By this time, Orri's Lisp interpreter had been ported to 8086 assembly
and Pascal, so I started hacking that, and really learned Lisp.
Eventually, we'd port it to 80186, 80286, 386 and 486, rewrite the
whole thing to make to make it CL-compliant (and to Do It Right), and
build a compiler, and never get to market with the DBMS. So we sold
the Lisp instead (mostly in Finland, as Mikko Lisp and ES-Lisp and the
new implementation as ECL). Not succesfully, I might add.
So, I basically learned Lisp by hacking Lisp implementations. I don't
think I ever took a class in Lisp. Taught a couple, though: for the
computer club at the old school and filling in at a vocational school.
--
Pekka P. Pirinen
"Truth is stranger than fiction because fiction has to make sense."
- Steve Smith <sgs_grebyn.com>
Dorai Sitaram
We are talking about a real novice here, who should be
given _some_ learning time before being tested.
It is quite easy for a person, even a Schemer, to learn
that DEFUN doesn't act like an "internal DEFINE"
(indeed, quite a few Schemers such as me abjure the use
of internal DEFINEs in their own language, preferring
to use a more explicitly lexicalizing operator like LET
or LETREC); or that tail-call elimination is not
guaranteed in CL. A Schemer would in fact be very
alive to this, and make sure that he got his lexicals
and loops right in the CL environment. All novice
problems should be so easily self-correctable.
I think a much more pervasive and uncorrectable malaise
is intended when the bad influence of Scheme is cited.
*
To those who do want to write Scheme in CL, may I
suggest that if the reason is to simply have your code
run in CL, you are better off writing Scheme in Scheme
and then using something like
http://www.ccs.neu.edu/~dorai/scmxlate/scmxlate.html --
less stylistic nerves (your own and your
CL-knowing critic's) may be frayed that way.
Erik Naggum
| All novice problems should be so easily self-correctable.
Would that that were true. The problem is that they are not.
| I think a much more pervasive and uncorrectable malaise is intended when
| the bad influence of Scheme is cited.
Somehow, a Scheme freak believes that Scheme is "right" and whatever else
he has to do to make things work is "wrong", and therefore never learns
what is right in any other language that does not very forcefully prove
him fundamentally wrong. It is much harder to make someone believe they
are wrong when they are right some of the time than none of the time.
Erann Gat
> To those who do want to write Scheme in CL, may I
> suggest that if the reason is to simply have your code
> run in CL, you are better off writing Scheme in Scheme
> and then using something like
> http://www.ccs.neu.edu/~dorai/scmxlate/scmxlate.html --
> less stylistic nerves (your own and your
> CL-knowing critic's) may be frayed that way.
FWIW, my reason for writing Scheme in CL (if indeed that is what I'm
doing) is that IMO it is much easier to write Scheme in CL than it is in
Scheme.
E.
ozan s yigit
> It seems that getting over Scheme can be a difficult task.
i am sceptical. it is only a programming language, and in a very large
majority of young programmers, not even close to being the first language;
that it itself may lessen its (claimed) impact. moreover, what is it that
is so important, so sticky and hard to relearn? what is the real claim
about learning? what is the claim about cognition? is the claim supportable?
is this sapir/worf rearing its head again? it is so much fun to bash basic,
perl, scheme or whatever we hate today, but the actual cognitive effects
of learning these languages are not properly studied, so far as i know.
one may as well claim that those who learn french or turkish are
forever damaged to ever do good lisp programming... :-/
this stuff is all very muddled.
oz
--
it seems so long and so many parentheses ago... -- thomas a. russ
Erik Naggum
| FWIW, my reason for writing Scheme in CL (if indeed that is what I'm
| doing) is that IMO it is much easier to write Scheme in CL than it is in
| Scheme.
If true, this explains why Scheme freaks so seldom learn Common Lisp
well. Common Lisp would just be a "better Scheme" to them, and just like
C programmers keep programming in C forever because all the "modern"
languages all have a basic C-like syntax. Perhaps a significant change
in the syntax is _necessary_ to make people change their habits, as they
would no longer be visually tempted to think it is the same as they know.
Bijan Parsia
[snip]
> FWIW, my reason for writing Scheme in CL (if indeed that is what I'm
> doing) is that IMO it is much easier to write Scheme in CL than it is in
> Scheme.
Perhaps you are using only that subset of Scheme which is not painful to
write in CL...You Outcast :)
It be interesting to know if you were using a kind of Scheme + CL
extensions that was langauge focused or "just" library focused. I.e.,
whether it was Scheme subset + CLOS (in which case, a Scheme + GOOPS might
work for you) or Scheme subset + format. Etc.
Cheers,
Bijan Parsia.
Dorai Sitaram
It's clear you are not one who'd use internal DEFUN or
assume tail-call elimination or commit any of the other
boo-boos alleged of those who have learned Scheme
before CL. So if all you are saying is that you
like to use values directly instead of always
indirecting through symbols bound to them, I don't
think that marks you as someone who "writes Scheme in
CL".
I am sure CL usage is quite accepting and encouraging
even of the direct manipulation of values. I'd be
surprised if there were even a tacit stylistic
admonition against it.