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?