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
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
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
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. ;)
> 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...)
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...
"Don't ask for whom the <CTRL-G> tolls."
PGP key ID 0x42B32FC9
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
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, ...
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
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
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.
> 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
I've been lucky enough to stay with Lisp at other companies since that
> 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
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
> 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
Anybody know what I'm talking about?
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
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.
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
> 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.
> 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
> 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
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
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
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
> 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
[*] It actually made some stronger statements, but you get the picture :)
EncyCMUCLopedia * Extensive collection of CMU Common Lisp documentation
> 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?
(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
sorry about being off topic, just there is no one really to tell.
> 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 <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.
(allow (defun foo (x) (* x x)) (and (has :system) (not (has :script)))
(progn ;can access foo
(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.
> 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! |
/ / `-----------------------'
( -. |
| ) |
> 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
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.
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?
> 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
> not quite, it is not so easy to describe though.
> (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 <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.
>> REVIEW OF THE YEAR, 2000 <<
It was shit. Give us another one.
-- NTK Know, 2000-12-29, http://www.ntk.net/
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..
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.
[*] 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 :-).
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
I don't know if this makes any sense...
> 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.
Thomas A. Russ, USC/Information Sciences Institute t...@isi.edu
> 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 :)
> On 4 Apr 2002 07:27:55 -0800, dwa...@syncreticsoft.com (Damond Walker)
> > 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
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
> 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.
> Around 1975/76 I wire-wrapped a Z80 board (schematic was the center-fold
> the first anniversary issue of Byte magazine), with 2K of static RAM and
> 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
BTW I found it in the lab. For those interested in microcomputers archeology
here are 2 pictures of it:
The components side:
The wire-wrap side:
The funny thing is that the current Intel architecture is still almost the
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.
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.
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.
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
| 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?
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.
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.
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.
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
>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
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.
| 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?
> | [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)
(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
The lack of keywords is one of the things most sorely missing in
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.
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'.
> * 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
> 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
> 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
> 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
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.
> 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
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
>>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
> 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.
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
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
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.
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".
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
Don't beat yourself up too badly.
> 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
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:
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.
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
That began to change when a short series of LSD experiments
unexpectedly re-opened my eyes to the beauty of mathematics and
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
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
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 ...
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 :)
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.
> BTW I found it in the lab. For those interested in microcomputers archeology
> here are 2 pictures of it:
> The components side:
> The wire-wrap side:
> 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. :)
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.
> 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:
- 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
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.