L
Lars Brinkhoff
Many sources say TRON were made using the one and only Foonly F1,
which was a PDP-10 clone.
Many sources say TRON were made using the one and only Foonly F1,
which was a PDP-10 clone.
K
Kenny Tilton
A. Lloyd Flanagan said:
Whoa, that is a rather unpleasant addition to the archives.
What part of the subject line do you not understand? Just ignore us.
Python shares a lot of DNA with Lisp; maybe some Pythonistas would be
interested in knowing their Roots.
Especially if they really like Python and want to enjoy many of its
qualities while undertaking something requiring a full-blown
general-purpose language, they might benefit from knowing that the AI
winter and Lisp's loss of mindshare were accidents of history, not signs
of some flaw in the language.
People don't like Lisp because of misconceptions, and threads like that
help dispel those. That has to be a Good Thing, because NGs like this
are where Early Adopters like Pythonistas learn new things to explore,
even when those things were first conceived in 1956.
kenny
S
Stephen Horne
No offence was taken.
I could be tempted to claim that people with Aspergers would be more
flexible than other people, *if* they didn't have to deal with a world
full of normal people.
I suspect that this would be just as wrong, though.
The tendency is that less innateness = more flexibility, but only in
healthy individuals. People with Asperger syndrome have lost a subset
of innate social abilities - but not all of them, and we haven't all
lost the same ones. We have less innate abilities, but we are not
adapted to have less innate abilities. When neurological development
processes break down, there is no order to the abilities that remain
and no guarentee that they will work together.
Learning helps fill the gaps, but it isn't magic.
S
Stephen Horne
Actually, getting back to being serious...
There is a common misconception that Asperger syndrome is 'mild
autism'. In a sense this is correct, but in terms of causes it is
fairer to say that there are two types of neurological damage. One
damages social intelligence and is present in autism and asperger
syndrome. The other damages general intelligence and is present in
mental retardation and the certain types of autism. High functioning
autism and asperger syndrome are much the same thing, and some people
with asperger syndrome should be considered low functioning - low
general intelligence isn't the only way to become low functioning
('executive function' deficit - another prefrontal cortex issue -
seems to be a major cause of the 'low functioning' label).
Basically, the original Kanner autism is in fact a combination of two
disorders - mental retardation plus a disorder which includes all the
autism features that are not mental retardation. Because the parts of
the brain involved are close together, there is a significant
statistical link.
MR has a cutoff point at an IQ of 'around' 70 (there is room for
judgement, and additional symptoms are required beyond the low IQ),
but the IQ scale is continuous.
What I am getting at is that if you were to read that people with
mental retardation 'find academic study difficult', you might well
decide that you were retarded - after all, we all find academic study
difficult at some point, after all. But you may believe that even if
your IQ were actually 130.
There have been attempts to create a scale of autistic symptoms. You
might like to take the AQ (autistic quotient) here, for instance...
http://www.wired.com/wired/archive/9.12/aqtest.html
This test was one of those used in screening prior to my diagnosis. My
score then was 38. I just took it again and got 42. I guess I'm
feeling a bit more pessimistic these days.
What would it look like to have asperger syndrome, but milder?
http://www.udel.edu/bkirby/asperger/putnampaper.html
So basically, yes, some of the autistic symptoms seem an aweful lot
like things that are common in normal people. Women will probably tend
to think that all men have asperger syndrome. And nerds will have more
autistic tendencies than other men. And many autistic symptoms can
arise through other causes.
But that doesn't mean Asperger syndrome doesn't exist. You can see the
effects of the neural damage on a PET or MRI scanner, so it is very
hard to claim it doesn't exist.
BTW - the criteria used for my diagnosis are the CLASS criteria, which
are stricter than the DSM IV criteria. They were very interested, for
instance, in symptoms such as my headbanging when I was 3 years old.
I don't think that is particularly typical of programmers.
Neither is the fact that almost everyone with Asperger syndrome
reaches adulthood with severe trauma related disorders due to the
stress in their childhood.
D
dan
Google ate my long post, so I'll make it simple.
Lisp failed (yes, it did) because of the parentheses. Normal people
can't parse 13 close-parens easily. Functional notation is
non-intuitive and hard to read.
The world is moving in the direction of languages like Python, that
fit naturally with how we speak and write.
Lisp failed (yes, it did) because of the parentheses. Normal people
can't parse 13 close-parens easily. Functional notation is
non-intuitive and hard to read.
The world is moving in the direction of languages like Python, that
fit naturally with how we speak and write.
D
dan
Google ate my long post, so I'll make it simple.
Lisp failed (yes, it did) because of the parentheses. Normal people
can't parse 13 close-parens easily. Functional notation is
non-intuitive and hard to read.
The world is moving in the direction of languages like Python, that
fit naturally with how we speak and write.
Lisp failed (yes, it did) because of the parentheses. Normal people
can't parse 13 close-parens easily. Functional notation is
non-intuitive and hard to read.
The world is moving in the direction of languages like Python, that
fit naturally with how we speak and write.
L
Lulu of the Lotus-Eaters
|People don't like Lisp because of misconceptions, and threads like that
|help dispel those.
In my own mind, the biggest impediment to really liking Lisp is not the
annoying parentheses and awful syntax... it's many Lispers (especially
those like Tilton).
As soon as I try to learn more by reading discussions, I am bombarded
with weirdly fanatical (and very long) posts that are overwrought with
many misrepresentations (e.g. Python has "Lisp DNA", when pointedly it
does not by GvR's indication). Not that different Lispers even bother
with the same misrepresentations--just so long as they are clear that
programmers of all other languages are ignorant and stupid.
Or tortured threads about things that are only possible in Lisp... but
as soon as any example is presented, it is obvious that the same thing
is not only possible, but much easier and more direct, in (some) other
languages. Then special pleading accompanies the weaknesses of doing
something in Lisp: you have to use some other distribution (maybe a
really expensive commercial one); if only you wrote these difficult and
huge macros it would be easy; you don't -have- to use the syntax since
the semantics is abstract; you shouldn't want to do -that-, but rather
this other thing; etc.
Yours, Lulu...
|help dispel those.
In my own mind, the biggest impediment to really liking Lisp is not the
annoying parentheses and awful syntax... it's many Lispers (especially
those like Tilton).
As soon as I try to learn more by reading discussions, I am bombarded
with weirdly fanatical (and very long) posts that are overwrought with
many misrepresentations (e.g. Python has "Lisp DNA", when pointedly it
does not by GvR's indication). Not that different Lispers even bother
with the same misrepresentations--just so long as they are clear that
programmers of all other languages are ignorant and stupid.
Or tortured threads about things that are only possible in Lisp... but
as soon as any example is presented, it is obvious that the same thing
is not only possible, but much easier and more direct, in (some) other
languages. Then special pleading accompanies the weaknesses of doing
something in Lisp: you have to use some other distribution (maybe a
really expensive commercial one); if only you wrote these difficult and
huge macros it would be easy; you don't -have- to use the syntax since
the semantics is abstract; you shouldn't want to do -that-, but rather
this other thing; etc.
Yours, Lulu...
K
Kenny Tilton
dan said:
Aaaaannnnnndddd they're off! (for another four hundred messages)
Nobody looks at or counts parentheses, except in languages other than
Lisp. We have editors that not only help keep them straight, but also
let us move chunks of code in the meaningful semantic chunks defined by
parentheses. So editing with parentheses is actually the best possible
way to edit code.
I do not think you know much about Lisp. Lisp does imperative as well as
functional. It is a multi-paradigm language. I prefer functional,
because it exposes the structure of my algorithm. YMMD.
All code is non-intuitive and hard to read.
And Python is moving in the direction of Lisp, tho I do not know if
Python has abandoned its original modest intentions and now wants to go
all the way and be a full-blown HLL. Already seems perty close, just not
sure if the Mission Statement has been changed.
You only /think/ you speak and write that way because you have written
step-wise code for so long. If you are a real old fart this started with
Fortran and Basic, maybe Assembler.
From the above it is clear you know nothing about Lisp, so of course it
seems strange to you. But don't you think a language an order of
magnitude better than anything else will have to be different enough to
seem strange?
The good news is how fast you will adjust and your old language seems
strange.
kenny
P
Pascal Costanza
Lulu said:
You don't like Lisp because you don't like some other guy who is using it?!?
That's just your interpretation of what they say. I think both "sides"
have their fair share of beliefs that they cannot back by argument
and/or empirical assessments. Every language has features that people
have learned to appreciate because of hands-on experience. It's in fact
an esoteric experience in the truest sense of the word: one that cannot
be described in words.
I haven't actually ever used Python in practice, so I can't really tell
whether the syntax or some other features of Python will make me go
eureka when I use them. And I don't care because I already have made
that experience wrt s-expressions and macros, and I hope that I will
never have to go back to a language without macros. All the counter
arguments I have heard so far seem to be made on the basis that people
haven't made that experience yet that I am talking about. Yes, every
language feature has its dangers. What matters is whether the advantages
outweigh the dangers or not. In the case of macros, IMHO you shouldn't
guess, you should just try.
If you are really interested to find out whether macros work in practice
or not, it is extremely easy to do so. Pick one of the free commercial
or non-commercial implementations of Common Lisp, download the free book
"On Lisp" by Paul Graham from his website, try to understand what he is
saying about macros, try to write your own. Maybe you will get it, maybe
not.
These are just my opinions, they are not proven facts. Actually, I don't
really care whether you try it or not. I have made up my mind, and if
someone asks whether macros are useful or not - and this was the start
of this thread - I am going to try to share my experience.
For every discussion, you can concentrate on what are seemingly the most
extreme statements and counter them on the basis that they are too
extreme, or you can try to find out by yourself what actually hides
beneath those statements. (Or you can just ignore a topic if you're not
interested.)
Pascal
P
Paul F. Dietz
Lulu said:
Do you often let the behavior of others control how you think
about technical topics?
Paul
P
Pascal Costanza
dan said:
Yes, and that's a good thing.
It's a good thing because it means that static approaches are replaced
by dynamic approaches.
Pascal
K
Kenny Tilton
Lulu said:
So you would charge right out and use Lisp, except you do not like me?
Hmmmm....
I phrased that with a vague metaphor precisely to avoid saying anything
about Python's history and motivation, about which I am largely
ignorant. I have no idea where the ideas for garbage collection,
first-class functions, and a MOP came from, but Peter Norvig, a Python
fan, writes:
"Basically, Python can be seen as a dialect of Lisp with "traditional"
syntax (what Lisp people call "infix" or "m-lisp" syntax). One message
on comp.lang.python said "I never understood why LISP was a good idea
until I started playing with python." Python supports all of Lisp's
essential features except macros, and you don't miss macros all that
much because it does have eval, and operator overloading, and regular
expression parsing, so you can create custom languages that way."
That's at: http://www.norvig.com/python-lisp.html
Note that Norvig is not saying how Python ended up so close to Lisp,
just that it has. Me neither/too.
Nonsense. We actually hope a few Pythonistas will come help us build up
some free libraries for Lisp to solve a weak point for us. We recognize
Pythonistas as (a) Early Adopters who (b) groove on interactive,
dynamic, powerful languages.
We are recruiting, not flaming.
It's funny this never occurred to me, but my own Cells hack uses macros
big time. Here is a before/after in which I manually macroexpanded the
code and spliced the output back into where it would have expanded:
Before:
(make-instance 'boiler1
:temp (cv 20)
:status (c? (if (< (temp self) 100)
n ff)):vent (c? (ecase (^status)
on pen)off :closed))))After:
(make-instance 'boiler1
:temp (make-c-variable :value 20)
:status (make-c-dependent
:rule (lambda (c &aux (self (c-model c))
(.cache (c-value c)))
(if (< (temp self) 100)
n ff))):vent (make-c-dependent
:rule (lambda (c &aux (self (c-model c))
(.cache (c-value c)))
(ecase (let ((*synapse-factory* nil))
(status self))
on pen) off :closed)))))Some observations:
(1) This is an extreme case, because Cells is an ambitious hack. But the
principles are the same for simpler applications
(2) If I did not have macros, I could compress the above 20%, but no more
(3) Expanding the macros exposes implementation details. I use Cells a
lot, and I refactor a lot. Exposing internals is not just a theoretical
no-no, I'd be dead.
(4) So as not to overstate my case, I snipped this clause from the
actual expansion:
:code '((ecase (let ((*synapse-factory* nil))
(status self))
on pen) off :closed)))That is just plain scary. What I am doing is not only expanding the user
code into a lambda form, but also generating /this/ code to dynamically
(at run-time) stuff the code's source (in symbolic form, what the macro
gets its hands on at compile-time) into a slot in the cell data
structure to help with debugging at crash-time. (ie, the source level
debugging on my particular implementation could be a lot better (I just
learned they are working on it) but I have anyway worked around that
with macros.
(5) Leaving aside exposed implementation (a fatal problem, mind you) "I
can do that in Python without macros" is /not/ an objection, unless the
code comes out as terse as the "before". One thing we Lispniks should
have emphasized early on is that one thing macros do is compress and
prettify the code. Surely Pythonistas will acknowledge the value of that.
(6) Paul Graham says it better: http://www.paulgraham.com/onlisp.html
kenny
S
Simon András
Thank you.
Yes, you're right, lisp failed, it's dead, and has been for about two
decades now. (Search google for posts like yours from the last century
to confirm this.) But somehow this doesn't stop it thriving, so it's
probably one of the the healthiest dead languages in the history of
IT.
And of course the culprit is the parantheses. (Thank you for telling
us about it! Dylan people will be especially delighted about the
news.) Although ten years ago it was GC, and before that it was that
it needed special hardware to run at acceptable speed.
It's also true that normal people can't parse 13 close parens. Most
Lispers probably can't either, and they definitely don't. Do
pythonistas count whitespace?
I'm grateful for your concise critique of "functional notation". I
assume you mean prefix notation, and considering that algoloid
languages also use this for functions, you should probably switch to
Forth (too bad you probably think it's dead, too). Silly me, I thought
that the charm of infix notation disappears at functions of arity 3 or
more.
This is _so_ true, I wonder why it reminds me of the following:
"A French politician once wrote that it was a peculiarity of the
French language that in it words occur in the order in which one
thinks them."
Wittgenstein, PI 336
Bye,
Andras
V
Ville Vainio
Lisp hasn't failed as long as emacs is around, and uses Lisp.
Actually, one of the problems with Lisp might be the steep learning
curve. Lisp does not offer the instant appeal of Python. The most
common initial impression of Lisp is "yuck" (parens), while w/ Python
it's mostly "wow, I didn't know code could be so readable and
powerful" (though the whitespace is sometimes an issue, the shock
might last for several minutes).
Now that neither Lisp not Python has the idustry-dominating status
(unlike Java, C++), instant appeal matters a lot. If people are
expected to hop in as a hobby, Python wins hands down. It takes just
3-4 toilet sessions (if you have the habit of reading in toilet) to
master Python, whereas w/ Lisp you have to hack the code for a
while. And still, you can't read the code fast enough; it's fast
enough to write, but reading can be painful initially (unlike perl,
where the pain lasts indefinitely).
Lisp offers a bit more power than Python (macros), but after a while
with Python, one notices that none of the power that is missing is
actually even needed. Python has just the right
features. Period. There are one or two warts (dangling variable after
list comprehensions comes to mind), but the language as a whole feels
natural. Lisp feels natural if you are writing a compiler or want to
be as orthogonal as possible, Python feels natural for most (all
except drivers/applications with extreme performance requirements) of
the real world applications.
Yes it is; that doesn't mean that Lisp would be dead after a while. At
least not until emacs supports Python natively
. Seriously though,Lisp is one of the more programmer centric (== least evil) languages
around, loved by programmers and shunned by the managers. If Python
(and ruby, which I view mostly as a Python with different syntax)
weren't around, Lisp would be the language of choice for most
pythoneers.
Hmm, I guess I should leave usenet alone on saturday nights, but what
the heck
.
L
Lulu of the Lotus-Eaters
|> In my own mind, the biggest impediment to really liking Lisp is not the
|> annoying parentheses and awful syntax... it's many Lispers (especially
|> those like Tilton).
|You don't like Lisp because you don't like some other guy who is using
|it?!?
Absolutely! One of the things that is greatest about Python is its
programming community, and its newsgroup. Quite apart from any matters
of syntax or semantics, or OOP vs. FP, or any of that stuff, it's a
heck of a lot nicer working in a language where you can get friendly,
helpful, informative answers to questions... and ones that lack scorn
and contempt.
ways. Perl, PHP, C++, and Java would probably be ranked in descending
order here, but still mostly positive.
The only languages I've seen with truly vindictive and nasty user
communities are Lisp... and VB. It's a strange closeness of the two.
All the more so because VB has a lot of poorly educated, not
particularly bright, user who are merely boastfully defensive about the
only thing they know. To the contrary, I clearly recognize that
Lispers--even most of the most over-the-top rude ones--are startlingly
intelligent. I'm not sure which is worse though... someone like Tilton
is easily smart enough to avoid sophistry, and yet he engages in it.
All that said, I also know that you cannot choose a language ONLY on its
user community. Obviously issues like static/dynamic typing, available
libraries, platform ports, and lots of issues cannot be brushed off.
Even speed of execution occassionally matters.
Yours, Lulu...
|> annoying parentheses and awful syntax... it's many Lispers (especially
|> those like Tilton).
|You don't like Lisp because you don't like some other guy who is using
|it?!?
Absolutely! One of the things that is greatest about Python is its
programming community, and its newsgroup. Quite apart from any matters
of syntax or semantics, or OOP vs. FP, or any of that stuff, it's a
heck of a lot nicer working in a language where you can get friendly,
helpful, informative answers to questions... and ones that lack scorn
and contempt.
Python is good, but so are, e.g., Ruby or Haskell in slightly different
ways. Perl, PHP, C++, and Java would probably be ranked in descending
order here, but still mostly positive.
The only languages I've seen with truly vindictive and nasty user
communities are Lisp... and VB. It's a strange closeness of the two.
All the more so because VB has a lot of poorly educated, not
particularly bright, user who are merely boastfully defensive about the
only thing they know. To the contrary, I clearly recognize that
Lispers--even most of the most over-the-top rude ones--are startlingly
intelligent. I'm not sure which is worse though... someone like Tilton
is easily smart enough to avoid sophistry, and yet he engages in it.
All that said, I also know that you cannot choose a language ONLY on its
user community. Obviously issues like static/dynamic typing, available
libraries, platform ports, and lots of issues cannot be brushed off.
Even speed of execution occassionally matters.
Yours, Lulu...
K
Kenny Tilton
Pascal said:
FWIW, I have used Python in anger, and the textual clarity of my code
was indeed remarkable.
P
Paul Rubin
Ville Vainio said:
No language feels more natural than Lisp. There's a real sense that
while Python was invented by a brilliant programmer, Lisp is built
into of the structure of the Universe. Bob Kanefsky's song "The
Eternal Flame" is a humor piece for sure, but it expresses that
sentiment beautifully. I can't imagine it being written about Python
or any other language than Lisp.
http://www.songworm.com/lyrics/songworm-parody/EternalFlame.html
K
Kenny Tilton
Lulu said:
what is sophistry?
kenny
E
Espen Vestre
Lulu of the Lotus-Eaters said:
We are a wicked gang indeed. Actually we were thrown out of the hotel
at the ILC this week because we were harrasing the other guests with
nasty lamda expressions in the elevators!
F
Frode Vatvedt Fjeld
Kenny Tilton said:
The story goes that in ancient Greece the sophists were recognized
experts on public speaking, who took pride in being able to sway their
audience into any point of view they liked, or got paid for. (Much
like todays "spin doctors", I believe.) This in contrast to the
philosophers, who were the experts on what is True, regardless of
popularity or any pragmatics.
So sophistry usually means something like a lot of fancy talk that
isn't very helpful in establishing what is true, or important, or
right, or bestest of parens and white-space.