| In article <pcod6yxf9vf....@thoth.math.ntnu.no>, Harald Hanche-Olsen wrote: | > (Hmmm... It just occured to me that one possible way to limit the | > precision of rationals might be to simply chop of the same number | > of bits at the right end of enumerator and denominator. But that | > would still not be good enough for very small numbers, which would | > have a moderate enumerator and a giant denominator.) | | If you | > plan to chop'em off you should use floats right away, I reckon.
My thought exactly. But what we're discussing here is the situation when you want more precision than the built-in flots can provide, like a hundred decimal digits or more. Kent's post could almost be taken to suggest the use of rationals for this purpose, which is why I asked. (Yeah, I know Kent is always very precise in his choice of words. He did not outright suggest it, which is why I wrote those weasely words "could almost be taken to". No intention to put words into Kent's mouth.)
And Bradley J Lucier writes: - - >No, because when you iterate with integers, there is no surprise - >if you skip over your loop end; that is simply a bug. - - Yes, *and it's simply a bug to expect .1 added 10 times to equal 1.* - How do bugs/not bugs depend on your level of surprise? Does that - mean that newbies never write buggy programs because they're always - surprised? What nonsense.
You know this, but I'll repeat it anyways:
When you start by assuming that floating-point arithmetic is somehow strange or untrustworthy, lots of things are no longer your fault, so they can't be bugs.
The bugginess isn't the nonsense. It's the assumption that's incorrect. In this case, the assumption is buoyed by the difference between program text (0.1 in decimal) and reality (a rounded binary representation).
- So you claim that nonsense, if it comes up first in a Google - search, == truth.
The current Fortran draft codifies that rule. I think it may have been codified in Fortran 90 or 95, but I'm not sure. So yes, it is truth. ;)
- Gee, one might think from your comments that if you repeat a computation - on IA32, you'll get different results.
With some dynamic compilers, you may. It has happened to various Java implementations in the past, and it may well have happened to Lisps and MLs... I'm not sure if Franz Lisp gathers stats and recompiles, but I'd imagine they've investigated it at some point.
- I find it hilarious the way you translate "extended double precision" - to "too many bits".
You have to admit that it's a very common translation, especially when compilers pretend that double extended is the same as double sometimes. You've seen the bug reports for gcc (and flames).
When a programmer has requested double precision and expects strict evaluation, it _is_ too many bits. Most languages don't give a programmer any way to control the expression evaluation, so...
For Lisp and other mostly dynamically typed languages, the only reasonable evaluation discipline is strict evaluation (as far as I can see). So sneaking in extra bits can be painful. (If anyone has ideas on how to support widest-needed evaluation in a dynamically typed language, _please_ contact me.)
- Yet, in practice, people do this *every day*! Conspiracy? Voodoo?
Just poor definitions. Accuracy needs a context. Given a format, IEEE754-style floating point numbers _do_ accurately represent reals. Is it the most accurate possible in the given number of bits? I don't know.
Some people would argue that it isn't as accurate as a decimal arithmetic from the context of everyday usage. I generally agree. If we had fast decimal floating-point, I doubt if people would consider FP really unusual.
We may get it someday, but in the mean time we should describe _why_ people still receive accurate results. The reason is partly that the majority of computations appear to need far less precision than is available.
It's also because there is no fuzziness. IEEE754 floating-point arithmetic is a strict system with relatively simple rules. The numeric values have an exact mapping to extended reals. Although the results of operations may not be exactly the same as if the operations had occured in real arithmetic, the result still has an exact mapping to the extended reals.
(Yes, you know this, but I'm trying to drive that point into common consciousness. ;) )
> In article <41yfc9mlr....@beta.franz.com>, > Duane Rettig <du...@franz.com> wrote: > >e...@cs.berkeley.edu (Edward Jason Riedy) writes:
> Pitman says he knows almost nothing about FP, and decides to stop > talking about it.
> You say you know almost nothing about FP, and seem to take it as > an incentive to post nonsense.
Excuse me? Please show me where I said anything about knowing almost nothing about FP.
-- Duane Rettig Franz Inc. http://www.franz.com/ (www) 1995 University Ave Suite 275 Berkeley, CA 94704 Phone: (510) 548-3600; FAX: (510) 548-8253 du...@Franz.COM (internet)
> We must have some fundamental miscommunication here. I did > re-read your paragraph. Here it is again: > - Again, precisely what I said. But your definition of "exact" is > - circular, because it deals with a mapping of floats onto floats, > - rather than the one-to-many mapping of floats onto reals (which > - includes rationals not representable with the given precision, as > - well as the irrationals). Given any two adjacent floats, there are > - an infinite number of reals between them, both rational and irrational, > - which can't be represented.
> Note "the one-to-many mapping of floats onto reals". That means > there is a mapping of one float to many reals, and that each real > is mapped to from some float.
> My assertion is that such a mapping is nonsense. Each numerical > floating-point value maps to exactly one extended real. Period.
Can you _really_ read that statement and conclude that I _believe_ that there is a one-to-many mapping of floats to reals? On the contrary, my statement was worded so that one would draw the conclusion that such a mapping _is_ nonsense.
-- Duane Rettig Franz Inc. http://www.franz.com/ (www) 1995 University Ave Suite 275 Berkeley, CA 94704 Phone: (510) 548-3600; FAX: (510) 548-8253 du...@Franz.COM (internet)
In article <3223400598719...@naggum.net>, Erik Naggum <e...@naggum.net> wrote: > Ignore the likes of Erann Gat whose job it seems to be to make people > stop using Common Lisp unless it is somehow magically "enhanced" to his > satisfaction.
Sigh. I was really hoping to end this, but I cannot allow this libel to go unchallenged.
It is not my "job" nor is it my intention to dissuade anyone from using Lisp. The more people use Lisp the better. It is my intention to point out that from where I sit it appears that not many people are using Lisp, and some people who would like to can't. It is my intention to engage in some speculation about why this might be and what might be done about it. And it is my intention to try to find like-minded people who would also see this as a problem and who are interested in working together to do something about it. (It is becoming increasingly clear that I won't find them here.)
* Erann Gat | Sigh. I was really hoping to end this, but I cannot allow this libel to | go unchallenged.
It was a fair summary of your position. That you do not like it when you see what you do with other people's eyes does not make it "libel".
| (It is becoming increasingly clear that I won't find them here.)
Let me get this straight. You think that Common Lisp needs to improve before it can be used for certain tasks, so you go use Python. However, _other_ people should listen to your whining about how you had to choose Python for those tasks and spend the energy to improve Common Lisp -- instead of just using Python like you did?
The premises that would need to be added to this mess to make it appear to make sense are unfit for print.
/// -- 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.
> It is not my "job" nor is it my intention to dissuade anyone from using > Lisp. The more people use Lisp the better. It is my intention to point > out that from where I sit it appears that not many people are using Lisp, > and some people who would like to can't.
I thought there was the more subtle point that Lisp isn't merely a non-mainstream choice, but an anti-mainstream choice, at least in the sense that one faces nigh uniform HUGE resistence to using it in a *lot* of contexts, even one's where it's pretty obvious that it would do a lot of good.
FWIW, you can still get that for Python. I have. But it's much easier, when encountering such blockage to say, "But, Python *is* a mainstream, standard, sensible, safe choice."
> It is my intention to engage in > some speculation about why this might be and what might be done about it.
Now *this* is a minefield, and rightly so. I don't know if you recognize *how fraught* such speculation is, especially in fora where folks come in regularly saying "If only Lisp had Foo like C++, Visual Basic, wha wha wha." If you mean to be an effective political leader (and surely, your intentions translate in an intention to be a political leader), it would be good, IMHO, if you handled that a bit better (on c.l.lisp, at least).
> And it is my intention to try to find like-minded people who would also > see this as a problem and who are interested in working together to do > something about it.
Is the "like-minded"ness more that those who see lisp being anti-mainstream as a problem and would like to do something about it? Or must they also share your temperment, and feel relaxed about the way you put things, etc.?
> (It is becoming increasingly clear that I won't find > them here.)
If the latter, then yes, it seems so. At least, not as many as you may have hoped and not without those who are anti-minded (in the latter sense).
------
Also, FWIW, I don't think adding functionality or convenience is the either necessary or sufficient to getting past the anti-mainstreamness. Java started with almost no-functionality and little convenience. There are plenty of people who find Python seriously lacking in its libraries and some who reject it for those reasons and some who embrace it in spite of those.
It seems to me that given the supposed Lispiness of Python, that Python folks would be as natural a consituacy for becoming Lispers/promoting Lisp as the reverse. One way to win them over is to have a fast, complete, powerful, portable implementation of Python in Lisp (like Jython is for Java). Some of these second implementations have failed in the Python community (e.g., Vyper in O'Caml, but I think that was due to the ambitious of the implementer and his failure to get a practical, everyday-code working version out), so it's not a promise.
The other "tractor app" I standardly wave around is XML processing, in particular XSLT. XSLT processors are regularly evaluated in the trade press (like XML.com, with the implementation languages discussed). The really nice thing about a Lisp based processor is the potential smoothness of integration between XML and sexpr (see SXML for examples).
I often wonder if it's not simple lack of *exposure*. There will always be folks who won't like Common Lisp. But if you can expose more folks, in lights that let them get a small grip quickly (e.g., modifying something in a domain they understand well), I suspect you'll pull in more people. (SK8 being implemented in MCL *certainly* helped dispell my Scheme scorn.)
In article <3223527657283...@naggum.net>, Erik Naggum <e...@naggum.net> wrote: > * Erann Gat > | Sigh. I was really hoping to end this, but I cannot allow this libel to > | go unchallenged.
> It was a fair summary of your position.
No, it was not. It was a gross distortion of my position. And it's not the first time you have engaged in such distortion. It is a tactic you commonly employ when you cannot defend your position on its merits.
> | (It is becoming increasingly clear that I won't find them here.)
> Let me get this straight. You think that Common Lisp needs to improve > before it can be used for certain tasks, so you go use Python.
No. I have said this time and time again. How many more times will you make me repeat it? Just because I have chosen to use Python (for one class of tasks) does not mean that I want to convince other people to use Python. Ironically, the Python people say exactly the same thing that you do, but in reverse. They think I'm trying to dissuade people from using Python in favor of Lisp. You're both wrong.
> However, > _other_ people should listen to your whining about how you had to choose > Python for those tasks and spend the energy to improve Common Lisp -- > instead of just using Python like you did?
I did not "have" to choose Python, I chose Python (for a very specific task) of my own free will. No one held a gun to my head. It's not a difficult concept to comprehend: just because I make a choice it does not mean I advocate that choice for others.
Parsia <bpar...@email.unc.edu> wrote: > On Sat, 23 Feb 2002, Erann Gat wrote: > [snip]
> > It is not my "job" nor is it my intention to dissuade anyone from using > > Lisp. The more people use Lisp the better. It is my intention to point > > out that from where I sit it appears that not many people are using Lisp, > > and some people who would like to can't.
> I thought there was the more subtle point that Lisp isn't merely a > non-mainstream choice, but an anti-mainstream choice, at least in the > sense that one faces nigh uniform HUGE resistence to using it in a *lot* > of contexts, even one's where it's pretty obvious that it would do a lot > of good.
> FWIW, you can still get that for Python. I have. But it's much easier, > when encountering such blockage to say, "But, Python *is* a mainstream, > standard, sensible, safe choice."
Yes, I think I agree with that (though I'm not sure I fully understand your distinction between non-mainstream and anti-mainstream). Ironically, I think Python is actually a much less "safe" language (in the technical sense) than Lisp because of its syntactically significant white space. (This position has made me a pariah in the Python community. I just can't seem to help but piss some people off. Oh well, tough.)
> > It is my intention to engage in > > some speculation about why this might be and what might be done about it.
> Now *this* is a minefield, and rightly so. I don't know if you recognize > *how fraught* such speculation is, especially in fora where folks come in > regularly saying "If only Lisp had Foo like C++, Visual Basic, wha wha > wha." If you mean to be an effective political leader (and surely, your > intentions translate in an intention to be a political leader), it would > be good, IMHO, if you handled that a bit better (on c.l.lisp, at least).
All else being equal I'd rather not be a political leader. I would much rather be doing technical work and leave the politics to others. I don't really enjoy politics, and I'm not particularly good at it. However, I'm not so naive that I think politics can be made to just go away. My most optimistic hope is that I will find people who *do* enjoy politics and who are good at it to do that work for me. I've actually had a fair amount of success over the years because JPL has a lot of good politicians whom I have "hired" to be my supervisors. :-)
I really wish that the *real* leaders of the Lisp community, like Kent and Duane and Paul Graham and Peter Norvig and Dick Gabriel, and even Erik, would lead this community in what I perceived to be a productive direction that I could both contribute to and benefit from. Alas, what I perceive is that this is not happening. Paul and Peter are off doing their own thing, Kent is taking a lassez-faire approach, and Erik seems intent on transforming Lisp from a programming language into a religion.
I believe in the maxim that one should lead, follow, or get out of the way. I tried following, that worked for a long time, but it doesn't today, at least not for me, and apparently not for a lot of people. So I'm going to try leading for a while. If that doesn't work, I'll get out of the way.
> > And it is my intention to try to find like-minded people who would also > > see this as a problem and who are interested in working together to do > > something about it.
> Is the "like-minded"ness more that those who see lisp being > anti-mainstream as a problem and would like to do something about it? Or > must they also share your temperment, and feel relaxed about the way you > put things, etc.?
Yes to the first question, no to the second.
> > (It is becoming increasingly clear that I won't find > > them here.)
> If the latter, then yes, it seems so. At least, not as many as you may > have hoped and not without those who are anti-minded (in the latter > sense).
Hm, I didn't quite follow that.
> Also, FWIW, I don't think adding functionality or convenience is the > either necessary or sufficient to getting past the > anti-mainstreamness. Java started with almost no-functionality and little > convenience. There are plenty of people who find Python seriously lacking > in its libraries and some who reject it for those reasons and some who > embrace it in spite of those.
Yes, I agree. That's why one of the things I think needs to be done is to hide Common Lisp (or something like it) under the guise of a new name and surface syntax with a simple mapping to S-expressions underneath. BTW, I state this as a proposed solution to a problem, not as gospel that has to be taken as axiomatic. If someone has a better idea of how to solve the problem (described in some more detail below) I'm listening.
[snip]
> I often wonder if it's not simple lack of *exposure*. There will always be > folks who won't like Common Lisp. But if you can expose more folks, in > lights that let them get a small grip quickly (e.g., modifying something > in a domain they understand well), I suspect you'll pull in more > people. (SK8 being implemented in MCL *certainly* helped dispell my Scheme > scorn.)
Yes. Here's a theory I've developed over the years: the digital world has become so complicated that it's impossible for any one person to keep up. People therefore rely on the opinions of others at least as guides to where they should focus their attention and often as guides to actual decisions. In such a climate there is a positive-feedback effect where ideas get accepted as truth completely irrespective of actual facts. One influential "consultant" says something, enough people embody that opinion into their worldview, and suddenly "everybody just knows" that X is true. This has happened to languages like Lisp and Dylan and Eiffel: everybody just knows that no one uses them, they aren't good for anything (except that Lisp is good for AI), and so the vast majority of people don't even bother to learn about them. Interestingly, the Lisp community is a little island of this same phenomenon happening, but anchored to a different "local maximum". In the Lisp community, Lisp is the ultimate language, all language innovations that can possibly happen have already happened, and Lisp incorporates them all, so there is no point in learning any language other than Lisp. I am caricaturing, of course, and most people don't take these extreme position in their pure form. But (putting on my scientist hat for a moment) this theory actually makes a testable prediction: that most people who like Lisp don't know much about other langauges, and most people who like other langauges don't know much about Lisp. (Here's a data point: when Paul Graham started designing Arc he didn't know Python.)
* Erann Gat wrote: > In the Lisp community, Lisp is the ultimate language, > all language innovations that can possibly happen have already happened, > and Lisp incorporates them all, so there is no point in learning any > language other than Lisp. I am caricaturing, of course, and most people > don't take these extreme position in their pure form. But (putting on my > scientist hat for a moment) this theory actually makes a testable > prediction: that most people who like Lisp don't know much about other > langauges, and most people who like other langauges don't know much about > Lisp. (Here's a data point: when Paul Graham started designing Arc he > didn't know Python.)
This is something that could actually be tested (modulo enormous self-selection /sampling bias) and although I'm not sure of the usefulness of the result I'd bet (small) money that the opposite is true to your caricature: Lisp people know *more* languages well than other people.
For me, I'd be comfortable in CL, scheme (but frustrated) other Lisps, perl, C (somewhat rusty now), python (haven't written significant systems in it), some C++ (very rusty, gave up (went back to C) when it became obviously insane), prolog, fortran (rusty), smalltalk (very rusty) many Unixoid scripting languages (the usual bag of sh, awk, sed &c &c). Read manuals but not used significantly: Java (could use language, not familiar with 98% of library), TCL (actually gave this up in disgust). Really a long time ago: BCPL, Basic (several), assembler (several, not big-machine), Forth. I must have missed some stuff here.
I have no idea how that compares with most people.
> bother to learn about them. Interestingly, the Lisp community is a little > island of this same phenomenon happening, but anchored to a different > "local maximum". In the Lisp community, Lisp is the ultimate language, > all language innovations that can possibly happen have already happened, > and Lisp incorporates them all, so there is no point in learning any > language other than Lisp. I am caricaturing, of course, and most people > don't take these extreme position in their pure form. But (putting on my > scientist hat for a moment) this theory actually makes a testable > prediction: that most people who like Lisp don't know much about other > langauges, and most people who like other langauges don't know much about > Lisp. (Here's a data point: when Paul Graham started designing Arc he > didn't know Python.)
We accept that innovations and technologies in other areas reach plateaus. Examples from aviation include the B-52 and the Boeing 747. At the beginning of aviation there were lots of innovations, now all commericial airlines look approximately the same. This pattern is holding for programming languages. Lots of innovation in the 50s, 60s and 70s. Then a plateauing. Programming languages seemed governed by physical laws just like other things. How old is computer programming now? I think the advances ahead now will be able to build upon what exists, not through innovation.
The best example of how the programming community has not advanced is the efforts to replace the US air traffic control system. With all the new programming languages and technological advances they have dismally failed to replace the systems, systems done long ago, with more archaic tools and understanding, BUT, with great intelligence. The techniques developed in the past, including the AI boom are well documented but many programmers think they can ignore them and move on. If Lisp did not exist someone would invent it. Lisp was created by an insight into the nature of programming languages by its creators. There is something very fundamental about its structure.
Yes Lisp incorparates most programming styles. That is why I chose it. It also has history, which means it has been shaped by actual use. How many times did I have to write List libraries in C? Had to do resource management (reference counting) in C++? It was a waste of time.
Knowing a programming language does not make you a good programmer.
>>>>> "TimB" == Tim Bradshaw <t...@cley.com> writes:
TimB> [...] I'd bet (small) money TimB> that the opposite is true to your caricature: Lisp people TimB> know *more* languages well than other people.
I'd bet the same way. I only claim to know CL (- CLOS/MOP expertise) and C (ok tcl/tk too). But I have gotten paid (by employers who are still happy to have employed me) to do 4GL's, COBOL, sh, basic, pascal etc. also. I have also produced substantial amounts of code in scheme, Fortran, Modula-II, SR (some experimental Algol/Pascal variant for parallel stuff), MIPS and Z80 assembler, AMD 2900 bit-slice code, C++ and probably a gazillion other things I have forgotten. I have read the Java manuals much like Tim, and decided its strength was mostly marketing. I actually looked into Python, and yeah I'd prefer it over Java but I have found no use for it just yet. I don't program full time so unless somebody hires me (despite my claims of ignorance) to fix a broken Python project I prefer to be just aware of it (ie it didn't excite me). I think you'll find that credible people who claim to know and like lisp either have academic CS backgrounds or are very disciplined and gifted self-learners (I am the former). It would therefore stand to reason that those folks usually are not from the "I read the learn XX in 21 days, therefore I know XX now" crowd and have had non-trivial exposure to other languages.
I claim ingorance (an rightly so) of a lot of stuff that I know more about than most people who claim to be experts in them. I know I am not the only lisper who is like that (KMP and yourself come to my mind). This is just one more instance of worse is better: you don't need optimality for success nor do you need expertise to be productive. No news there, then.
>>>>> "EG" == Erann Gat <g...@jpl.nasa.gov> writes:
[...] EG> I really wish that the *real* leaders of the Lisp community, EG> like Kent and Duane and Paul Graham and Peter Norvig and Dick EG> Gabriel, and even Erik, would lead this community in what I EG> perceived to be a productive direction that I could both EG> contribute to and benefit from. [...]
OK, I have read most of your postings and still do not understand what you would percieve to be a productive direction. In the parts of this particular posting I have deleted you seem to indicate 'hiding' s-exps would be beneficial. I also know that lack of solid DB connectivity libraries in MCL was a factor in your choosing Python. What else?
[...] EG> Yes. Here's a theory I've developed over the years: the EG> digital world has become so complicated that it's impossible EG> for any one person to keep up.
OK, I doubt this happened recently though.
EG> People therefore rely on the EG> opinions of others at least as guides to where they should EG> focus their attention and often as guides to actual decisions.
Sure, this is no different than other fields.
EG> In such a climate there is a positive-feedback effect where EG> ideas get accepted as truth completely irrespective of actual EG> facts. One influential "consultant" says something, enough EG> people embody that opinion into their worldview, and suddenly EG> "everybody just knows" that X is true. [...]
I think it takes more than one influential consultant. I have been that influential consultant occasionally in the past. The influence usually does not stick. What does happen is that people get into a senseless mindset that entails fear of looking stupid in front of someone they percieve as 'very smart' and carefully parrot stuff you uttered back to you. I think magazines, ill-informed[ing] web pages, slashdot or even TV is more influential than any single person. I think Erik's cognitive dissonance explanations are on target here with a slight twist: people seem to read variants of 'learn XXX in 21 days while acting like a dummy' and then think that they actually have learned something. This conviction about 'knowing' something is tough to challenge especially when livelihoods are based on this misrepresentation. One sees this at all levels, people 'know' how to set up network services when in fact they know how to monkey with files until something just happens to limp along, they 'know' how to write database backed programs because they have got 10 instances of the same buggy program to work under a load that doesn't show the corruption bug, they know how use C except they couldn't explain pointers to you or themselves etc. etc. You correctly point out that getting Lisp accepted is a social/political problem. You'll find the same problem wrt. C vs. C++ (VC++ monkeys will resist C even for Unix networking code), anything vs. Java either because management sent their mokeys to Java classes and they think they have Java experts or that marketing thinks a server based on Java stuff is better than anything else (both the new-defunct Ars Digita and Vignette did this in the web/app server market. google should be able to dig up public whinings from their engineers).
No doubt CL is not flawless, but social/political/cultural problems masquerading as technical ones should not be in that list if we'll get anywhere in this thread (reals? what reals?).
On Sun, 24 Feb 2002, Erann Gat wrote: > In article > <Pine.A41.4.21L1.0202240926530.74368-100...@login5.isis.unc.edu>, Bijan > Parsia <bpar...@email.unc.edu> wrote:
> > On Sat, 23 Feb 2002, Erann Gat wrote: [snip] > Yes, I think I agree with that (though I'm not sure I fully understand > your distinction between non-mainstream and anti-mainstream).
Bad terms, but reasonable concepts, I think. One can be non-mainstream simply by being obscure or specialized. The *only* "social stigma" of making a non-mainstream choice is that it is out of the mainstream. And anit-mainstream choice (ugh, need a better term) is one that the "mainstream" actively condemns. The social stigma includes (supposedly) having made a *bad*, non-conventional choice (or rather, a *clearly* stupid one). People think you especially perverse, rather than just a bit eccentric.
> Ironically, > I think Python is actually a much less "safe" language (in the technical > sense) than Lisp because of its syntactically significant white space.
Never been a problem for me; I doubt Python folks agree.
> (This position has made me a pariah in the Python community. I just can't > seem to help but piss some people off. Oh well, tough.)
See? :)
I don't want to argue the Python whitespace thing but that's *exactly* the kind of battle that is, imho, both futile and counterproductive. And for, perhaps, good reason. I would *worry* about your "tough" reaction, that is, it seems to me a sign of missing something important about that community.
Since the whitespace issue *hasn't* discernably damaged Python or its community, that seems an *especially* bad place to start improving it :) Since, significant whitespace is a *enjoyed feature* for many in that community, who've had to fight this battle a billion times, it's would take *extraordinary* measures to keep raising it from being a total waste of time for all involved.
[snip]
> All else being equal I'd rather not be a political leader. I would much > rather be doing technical work and leave the politics to others. I don't > really enjoy politics, and I'm not particularly good at it.
Yes, I'd agree with that :) (The Python example sorta shows.)
> However, I'm > not so naive that I think politics can be made to just go away. My most > optimistic hope is that I will find people who *do* enjoy politics and who > are good at it to do that work for me. I've actually had a fair amount of > success over the years because JPL has a lot of good politicians whom I > have "hired" to be my supervisors. :-)
But this suggests that unless you can *find* such to rally behind, you may want to brush up your own political leadership skills. Otherwise, you may end up in a pretty frustrating situtation.
I notice that in debates you tend to externalize the difficulties of those debates, i.e., people misreading you, double standards, folks resistent to change or uninterested in helping, Erik's tactics or personality, etc. Even if these externalizations are largely correct, it doesn't seem that confronting them head on has made much headway. Perhaps there are other ways to deal?
> I really wish that the *real* leaders of the Lisp community, like Kent and > Duane and Paul Graham and Peter Norvig and Dick Gabriel, and even Erik,
Actually, while these are all significant personages in the community, I don't think any are leaders, *per se*. Graham seems to be trying to be, a bit. I don't know if there *are* "general" leaders (many people take the inititive for specific projects).
> would lead this community in what I perceived to be a productive direction > that I could both contribute to and benefit from. Alas, what I perceive > is that this is not happening. Paul and Peter are off doing their own > thing, Kent is taking a lassez-faire approach, and Erik seems intent on > transforming Lisp from a programming language into a religion.
I don't share your perception of the latter two. At all.
> > > And it is my intention to try to find like-minded people who would also > > > see this as a problem and who are interested in working together to do > > > something about it.
> > Is the "like-minded"ness more that those who see lisp being > > anti-mainstream as a problem and would like to do something about it? Or > > must they also share your temperment, and feel relaxed about the way you > > put things, etc.?
> Yes to the first question, no to the second.
Then I think there are many such (though I may be wrong about it). OTOH, there are vested interests in Lisp as it is that can comfortably be satisfied with some varient of the *status quo*. I suspect that people with such interests may well prefer Lisp to become more mainstream *but* not at the sacrifice of their vested interests.
Take Arc. Let's suppose, for a moment, that Arc (in it's finished form) is all the proper blend of Lisp and Python you, personally, could desire (not just technically, but politically). It seems pretty clear that Arc won't help people using a *large* number of Common Lisp's features (start with CLOS :)). Arc doesn't seem to be as close to CL as Dylan. (What's wrong with Dylan as your "popular" Lisp, btw?) Thus, people who want to use something substantially like *Common* Lisp are not going to be remotely helped by Arc. Indeed, they might be hurt by it.
> > > (It is becoming increasingly clear that I won't find > > > them here.)
> > If the latter, then yes, it seems so. At least, not as many as you may > > have hoped and not without those who are anti-minded (in the latter > > sense).
> Hm, I didn't quite follow that.
Hm. Maybe I don't either :)
I think you *will* find people who are interested in Lisp becoming more mainstream, but many of them are also interested in Lisp being Lisp. So they want to be careful in their tradeoffs.
> > Also, FWIW, I don't think adding functionality or convenience is the > > either necessary or sufficient to getting past the > > anti-mainstreamness. Java started with almost no-functionality and little > > convenience. There are plenty of people who find Python seriously lacking > > in its libraries and some who reject it for those reasons and some who > > embrace it in spite of those.
> Yes, I agree. That's why one of the things I think needs to be done is to > hide Common Lisp (or something like it) under the guise of a new name and > surface syntax with a simple mapping to S-expressions underneath.
Er..Hmm. Ok, I guess I see how you got here from what I wrote :)
Personally, I don't think that a new name and surface syntax are necessary or sufficent. See Dylan.
> BTW, I > state this as a proposed solution to a problem,
Which problem? Parenthephobia? Anti-lisp bias?
> not as gospel that has to > be taken as axiomatic. If someone has a better idea of how to solve the > problem (described in some more detail below) I'm listening.
I think simple applications, that fill an important niche well, that are easy to understand while demonstrating nifty CL features, that may be *used* without hacking, but are easy to get into for hacking, can bring people in. If someone's using an CL based XSLT processer everyday and it beats out the others in convenience, features, and/or performance, then that person is going to be inclined to think well of Common Lisp. If adding a bit of functionality is as easy as (or easier than) tweaking settings in Emacs, then they'll be inclined to explore more programming in Common Lisp.
AllegroServe and mod_lisp strike me as such apps, at least in principle.
[snip]
> bother to learn about them. Interestingly, the Lisp community is a little > island of this same phenomenon happening, but anchored to a different > "local maximum". In the Lisp community, Lisp is the ultimate language, > all language innovations that can possibly happen have already happened, > and Lisp incorporates them all, so there is no point in learning any > language other than Lisp.
I don't see that *at all*. That seems to be something an "expert" said was true :) Worse, you're saying may have that effect on others!
Aside from the people posting about their language experience, I see Kent and Erik (to take two) both discussing Java and what it got right. People seem reasonably open to my interjections of Smalltalk :) (Indeed, I recognized several Smalltalkers 'round here.)
> I am caricaturing, of course, and most people > don't take these extreme position in their pure form. But (putting on my > scientist hat for a moment) this theory actually makes a testable > prediction: that most people who like Lisp don't know much about other > langauges, and most people who like other langauges don't know much about > Lisp.
I agree it's testable, but I don't think it's true ;)
> (Here's a data point: when Paul Graham started designing Arc he > didn't know Python.)
He didn't know Python *at all*? Wow, that seems a bit odd. Especially if you're going to sit down to design a language. Indeed, I kinda hope that before *I* sat down to design a language (that I intended to catch on) I'd survey the current state of things, just to make sure it wasn't easier to fix something up (or just adopt it).
In article <ey3r8naoaqn....@cley.com>, Tim Bradshaw <t...@cley.com> wrote: > * Erann Gat wrote: > > In the Lisp community, Lisp is the ultimate language, > > all language innovations that can possibly happen have already happened, > > and Lisp incorporates them all, so there is no point in learning any > > language other than Lisp. I am caricaturing, of course, and most people > > don't take these extreme position in their pure form. But (putting on my > > scientist hat for a moment) this theory actually makes a testable > > prediction: that most people who like Lisp don't know much about other > > langauges, and most people who like other langauges don't know much about > > Lisp. (Here's a data point: when Paul Graham started designing Arc he > > didn't know Python.)
> This is something that could actually be tested (modulo enormous > self-selection /sampling bias) and although I'm not sure of the > usefulness of the result I'd bet (small) money that the opposite is > true to your caricature: Lisp people know *more* languages well than > other people.
Yeah, I'd want to keep my wager on this small as well (which is to say that you may very well be right -- I don't know).
> For me, I'd be comfortable in CL, scheme (but frustrated) other Lisps, > perl, C (somewhat rusty now), python (haven't written significant > systems in it), some C++ (very rusty, gave up (went back to C) when it > became obviously insane), prolog, fortran (rusty), smalltalk (very > rusty) many Unixoid scripting languages (the usual bag of sh, awk, sed > &c &c). Read manuals but not used significantly: Java (could use > language, not familiar with 98% of library), TCL (actually gave this > up in disgust). Really a long time ago: BCPL, Basic (several), > assembler (several, not big-machine), Forth. I must have missed some > stuff here.
> I have no idea how that compares with most people.
Part of the problem obivously is that it's hard to say when someone "knows" a language. At one point in my life I wrote maybe 100 lines of Forth that actually did something useful. Does that mean I know Forth? Another problem is that languages change over time. I thought I knew C++, but the language that was C++ when I thought I knew it is different in significant ways from the language that is C++ today. The same is true for Lisp and Python too. I thought I knew Lisp pretty well, but I keep learning new things about it even after twenty years.
But what people actually know is not nearly as important as what they think they know (I think) :-)
g...@jpl.nasa.gov (Erann Gat) wrote in message <news:gat-2402021146300001@192.168.1.50>... > Yes, I agree. That's why one of the things I think needs to be done is to > hide Common Lisp (or something like it) under the guise of a new name and > surface syntax with a simple mapping to S-expressions underneath. BTW, I > state this as a proposed solution to a problem, not as gospel that has to
"Needs to be done" is such a common phrase. You can hear it in any bar, any day. But those who say it, sit there, relaxing, all agreeing with each other, or fighting with each other when the mood strikes, with no real care for actually doing what needs to be done. In Common Lisp there is no need for such common language as "needs to be done". The Common Lisp way is to say "here is my trial-balloon implementation of what I think would make things so much better, and here is why I think it would make them so much better."
In Common Lisp its almost as easy to implement something as to think of it. The process of implementing it consists mostly of clarifying your thoughts, till they eventually reach the point where people might take them seriously. That point is when you have something interesting to show them for discussion.
* Wade Humeniuk wrote: > Knowing a programming language does not make you a good programmer.
But I think that having practical[1] exposure to a fair number helps a lot, which is why I think the question Erann asked is interesting (if hard to get any real data about).
--tim
Footnotes: [1] In other words not some 10-minute presentation in a CS degree.
> [...] Here's a theory I've developed over the years: the digital world has > become so complicated that it's impossible for any one person to keep up. > People therefore rely on the opinions of others at least as guides to > where they should focus their attention and often as guides to actual > decisions. In such a climate there is a positive-feedback effect [...]
People collude to keep stay happy about the choices they've made, even at the expense of dismissing what may be better choices.
That's an unfortunate but understandable aspect of the mainstream of IT. As Java and .NET become more comprehensive and stable, I think this attitude is likely to become more entrenched. As you point out, no programmer can know everything about everything. We face a choice of being "jack of all trades, master of none", or carefully selecting a few of the best languages and striving for genuine expertise over many years.
Learning languages is easy. Learning a "platform" these days is not. Anybody who commits to fully mastering one or two mainstream programming "platforms" these days is undertaking a task that's large enough to be considered a form of specialisation.
There is a huge psychological investment in specialisation because being committed to something requires turning a temporarily blind eye to alternatives; otherwise there can be no focus. You should not be too surprised when you encounter this blind eye in your travels. It's inevitable.
The real question (IMO) is: what is this _worth_ to you? Is it worth your time, money and energy to try to change the perceptions of those who have a strong psychological and financial interest in maintaining them? Or should you take advantage of what you know, through your own investigation and experience, to be superior (and trust other intelligent individuals to do likewise, as they most certainly will - albeit in small numbers)?
Erann, you seem to have been pretty successful (and happy) doing the latter for most of your life. Your choice of Lisp might have resulted in a few wrangles over the years, but I think the energy you've wasted there is _nothing_ compared to the energy you'll waste in trying to make Lisp desirable to the mainstream.
Of course, this is only one man's idle speculation -- and I hate to be negative. If you really want to continue your crusade, and really believe it can succeed, and really believe that this kind of "success" is actually what you want, I humbly suggest that you start with a proof of concept rather than with politics.
Maybe you could join Paul Graham's effort to make a Lisp that's optimised for the stuff you're currently doing in Python? (I, for one, wish him all the best with this project. I think it will result in a mutually beneficial relationship with the more stable and conservative CL community). Or maybe you could devote some time to figuring out how Lisp (preferably Common Lisp) could leverage Java and/or .NET's facilities for mainstream tasks, and thus level the playing field. If you help to remove the mainstream technical objections _first_, then you'll have a better insight into the reasons why most programmers don't use Lisp.
* Erann Gat wrote: > Part of the problem obivously is that it's hard to say when someone > "knows" a language. At one point in my life I wrote maybe 100 lines of > Forth that actually did something useful. Does that mean I know Forth?
I think that's hard, and lots of people will claim to know things they don't really, or not claim to know things they do really depending on how much they want the job.
One could have some simple criteria like `been paid to program in' but this is obviously bad - people are paid to program in all sorts of languages which they can't program in, should people like Linus Torvalds be disqualified since he didn't get paid for writing Linux (well maybe he did, but you know what I mean).
> But what people actually know is not nearly as important as what they > think they know (I think) :-)
Ah, I think that's dangerous. Because one way your contention could be true is if Lisp people *think* they know that all these other languages are no good but actually are wrong. So they'd falsely report that they know all about lots of other languages when in fact they have missed all the interesting stuff. Actually, your contention kind of has to be something like that, because I think rather few people would say `I don't know about any of that stuff, and I don't care if it's better than Lisp'[1]. For instance I look at XML with horror as a kind of hugely bloated but somehow less functional version of s-expressions (and I just read an article on web services this morning and now I'm really depressed), and I think I have some knowledge of the area which might justify my feelings about it (used to work for an SGML company before the web hype), but maybe I'm just missing the point.
--tim
Footnotes: [1] Actually, *I* might. However my reasoning is perhaps a bit more complex: I'm sure there are good things I don't know about, but I'm also sure that I need to earn my living and sleep and eat and have some spare time to read, make photographs, playq the guitar and so on, and I'm happy to trade missing these possible good things for being able to have a life.
* Erann Gat | I really wish that the *real* leaders of the Lisp community, like Kent | and Duane and Paul Graham and Peter Norvig and Dick Gabriel, and even | Erik, would lead this community in what I perceived to be a productive | direction that I could both contribute to and benefit from.
The obnoxious follower is in other words looking for the right leaders to follow ...
| Alas, what I perceive is that this is not happening.
... and faults his leaders for not being "followable".
| Erik seems intent on transforming Lisp from a programming language into a | religion.
What was that gripe about gross distortions of your views, again? Are you _really_ so goddamn unintelligent as you prefer to portray yourself?
You are longer on insult than I am, Erann Gat, and _way_ shorter on contents. Your thinking here is just as vacuous as that insult is.
| I believe in the maxim that one should lead, follow, or get out of the | way. I tried following, that worked for a long time, but it doesn't | today, at least not for me, and apparently not for a lot of people. So | I'm going to try leading for a while. If that doesn't work, I'll get out | of the way.
I honestly believe you are in the way and should get the hell out of it.
Popularity contests are not fought in newsgroups. The only people who voice their opinions are those who have a contrary view to yours, and when that happens, you go bananas and think "religion" and what-not and claim that it is somebody else's fault that you cannot get what you want.
The argument made by Patrick that you externalize your own problems seems right on target.
| Yes, I agree. That's why one of the things I think needs to be done is | to hide Common Lisp (or something like it) under the guise of a new name | and surface syntax with a simple mapping to S-expressions underneath.
And the DYLAN experience was not enough to discourage this nonsense?
It is _not_ the s-expression syntax that ticks people off, it is the total lack of familiarity with the _words_, the very unusual way that the words have meaning while the syntax has (almost) none, and the fact that you have to know _each_ word to grasp the meaning of a function that someone else wrote. This is _not_ a problem: What is a problem is that people want to be able to do something "useful" without knowing squat about their tools or languages. I mean, when people have picked up K&R and typed in the "hello, world" codelet and it runs, that is rewarding to a rank beginner. It is _not_ rewarding to a seasoned programmer. It is a huge mistake to offer Common Lisp to beginners. (Scheme even more so.)
| Here's a theory I've developed over the years: the digital world has | become so complicated that it's impossible for any one person to keep up.
What does this mean? "My circle of friends has become so large that I can no longer keep up" means that you are no longer able to obtain information about what happens to people you care about, miss out on deaths in their families, new or passing pets, new or passing lovers, people moving, etc. If this is the meaning, it has _never_ been possible for any one person to keep up with the "digital world", wherever the hell the boundaries for _that_ is, so the criticism is _completely_ vacuous.
| People therefore rely on the opinions of others at least as guides to | where they should focus their attention and often as guides to actual | decisions.
And this was a change from _what_? There is absolutely no merit to the "therefore". People have always done this, too. Local communities of people who do things certain ways is the way human society has evolved. There is _nothing_ peculiar about the digital world in this regard.
| In such a climate there is a positive-feedback effect where ideas get | accepted as truth completely irrespective of actual facts.
This is true in all possible climates. Nothing special, nothing new.
| One influential "consultant" says something, enough people embody that | opinion into their worldview, and suddenly "everybody just knows" that X | is true.
Sure, until the next influential "consultant" comes along.
| This has happened to languages like Lisp and Dylan and Eiffel: everybody | just knows that no one uses them, they aren't good for anything (except | that Lisp is good for AI), and so the vast majority of people don't even | bother to learn about them.
This line of reasoning is not empirically supported. If the majority of people do not bother to learn Common Lisp, Dylan, or Eiffel, it is _not_ because they know that _nobody_ uses them. It is because the people they hang out with, the people they compete with for jobs, etc, do not use it. If a job offer comes up that requires a skill, a lot of people are smart enough to figure out that they could get it if they had that skill, and go learn it. If some entrepreneurial guy discovers something unusual that he thinks will offer him an edge over his competition, he _will_ use it to that effect.
| Interestingly, the Lisp community is a little island of this same | phenomenon happening, but anchored to a different "local maximum".
But how the hell is this _different_ from anything? _Every_ community is anchored to its own local maximum. Every community is different. There is no global maximum. What is considered the most popular thing on earth depends on who you ask.
The only problem we seem to have is that Common Lisp is not even the most popular language in its very own community, thanks to people like you.
| In the Lisp community, Lisp is the ultimate language, all language | innovations that can possibly happen have already happened, and Lisp | incorporates them all, so there is no point in learning any language | other than Lisp.
What a load of crap. If this is one your premises, no wonder you have to be a fucking obnoxious pest in this forum and fight what you think is wrong, like you fight all other meaningless things you think is wrong.
| I am caricaturing, of course, and most people don't take these extreme | position in their pure form.
I challenge you to find that it is present in even one person regarding even one programming language innovation. The insulting attribution of stupidity on such a massive scale to a whole community is how you get dethroned as a leader, not how you gain followers.
| But (putting on my scientist hat for a moment) this theory actually makes | a testable prediction: that most people who like Lisp don't know much | about other langauges, and most people who like other langauges don't | know much about Lisp.
With a scientist hat, you would at least have called it a hypothesis.
But. good, at last a way to make you realize that you are wrong. Not only empirically, but also logically: Common Lisp is not only hard to find, it is, by your very own testimony, unpopular and good for nothing, so one cannot escape wondering how people first discover it. It is _so_ very unlikely that people pick up a Common Lisp book in the computer section of their favorite bookstore or library and say "hey, I want to learn about computers and this language!". (Well, I actually discovered computers and Basic that way from my favorite library as a kid because it had classified computers right next to mathematics, but the likelihood that it be Common Lisp is and will remain very close to zero.)
The average discoverer of Common Lisp _must_ therefore have been exposed to at least several other languages, have found that computer programming is rewarding and also have been _dissatisfied_ with what he was already familiar with, or he would simply have stuck with that "tradition". In fact, I discovered Lisp by accident and was unable to use it for anything for years, but the ideas it had presented somehow "fit" how I thought.
Being so obnoxious as to list a lot of languages is counter-productive, but the languages that I have taken an interest in _after_ I learned Common Lisp appear to be even more important to defeat your stupid line of argument than those I knew before, and those include: Java, Dylan, Ada 95, JavaScript, Python, SQL, and Perl. In all cases, I have looked for stuff that I could learn from and incorporate into my own thinking. In a lot of cases, I have determined, after a significant period of study, that the value of switching to those languages as my "mainstay" would be a very bad idea. Java is too big for me and too much of a moving target and also seems to depend very much on "living" in a Java community, but that means a lot of _really_ ignorant people who know _only_ Java, and very little about computer programming. If I cannot become filthy rich programming Common Lisp, I no longer have the stomach (literally) to try to become filthy rich _programming_. This is why I am preparing to change carreer to law over the next few years, because, as I joke: there are two _really_ suspicious professionals: an old programmer, and a young lawyer.
| (Here's a data point: when Paul Graham started designing Arc he didn't | know Python.)
That is not a data point for your hypothesis.
/// -- 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.
Duane> e...@cs.berkeley.edu (Edward Jason Riedy) writes: >> And Duane Rettig writes: >> And the age-old rule derives more from _binary_ than it does >> from inexactness in operations. People wanted to add 0.1 ten >> times and get 1.0 exactly. In a decimal floating-point system, >> no problem. But 0.1 isn't exactly representable in the binary >> schemes. The problem would still have occured on a decimal >> arithmetic, but not often enough to merit an age-old rule.
Duane> Nevertheless, the rule is there. I don't know if _every_ Fortran Duane> manual has such a rule, but yesterday I did a web search to Duane> verify that the caveat was still there, and sure enough, the Duane> first online Fortran manual I came to had the warning against Duane> using floats in DO loops.
Perhaps that was true long ago for, say, Fortran IV and earlier, but Fortran 77 does not have this problem. An integral iteration count is computed from the start, end, and step values of the loop. This iteration count is used to control the loop end condition.
See www.fortran.com and click on the information link to get the to F77 standard.
Erann Gat writes: > But (putting on my scientist hat for a moment) this theory actually > makes a testable prediction: that most people who like Lisp don't > know much about other langauges, and most people who like other > langauges don't know much about Lisp.
I've written significant (for-pay) programs in BASIC, 6809 assembly, Honeywell DPS-6 assembly, C, p-best (a production system language), COBOL, php (ouch!!!), Java, perl, and Lisp. I've programmed a lot in Logo for volunteer work I've done in schools.
I've written at least one program in Fortran, Ada, Pascal, Forth, Smalltalk, 6502 assembly, 8080 assembly, 68000 assembly, etc. etc. etc.
I used to be a `language junkie', installing and trying out every new language that came along.
Do I count as a data point?
I like Lisp.
Erann, you have enormous prestige in my eyes from the Lisp work you did at JPL. In my mind, that work earns you a hearing.
But it doesn't earn you agreement. I simply disagree with your current views on Lisp. Someone who wants to lead needs followers. But a follower has to think the leader will lead him where he wants to go. I don't think you'll do that for me.
Thinking about my programming experiences, the following occurs to me:
There's a feeling of power I get when I program in assembly, the sense that I'm the complete master of the machine. The strange thing is that the only programming language that gave me this same feeling is Lisp. I know it's not the same, but somehow there's the sense that Lisp lets me get my ideas across to the machine. I don't think I'm a master programmer. But I think Lisp lets me reach most of my potential.
People have already discussed this issue, but the term I like to use is `mental overhead'. Lisp minimizes the mental overhead of programming. At the opposite end is something like C++, where one puts in a lot of mental effort that doesn't directly address the problem. This is not to say that C++ programmers are stupid, in fact almost exactly the opposite. They are very clever --- they have to be! I'm thinking about an article I read about the constructor problem of mixin-based programming in C++. The cleverness is consumed by dealing with artificial problems, problems that are caused by the formalism they express their ideas in. Lisp, after one gets over a few conceptual hurdles, is almost transparent.
Here's a quotation from Kaz Kylheku that captures this thought:
I can't escape the sensation that I have already been thinking in Lisp all my programming career, but forcing the ideas into the constraints of bad languages, which explode those ideas into a bewildering array of details, most of which are workarounds for the language.
-- -Fred Gilham gil...@csl.sri.com "In America, we have a two-party system. There is the stupid party. And there is the evil party. I am proud to be a member of the stupid party. Periodically, the two parties get together and do something that is both stupid and evil. This is called -- bipartisanship." --Republican congressional staffer
In article <87u1s6fqxv....@nkapi.internal>, Bulent Murtezaoglu
<b...@acm.org> wrote: > OK, I have read most of your postings and still do not understand what > you would percieve to be a productive direction. In the parts of this > particular posting I have deleted you seem to indicate 'hiding' s-exps > would be beneficial. I also know that lack of solid DB connectivity > libraries in MCL was a factor in your choosing Python. What else?
That's a fair question. I'm working on a paper that will hopefully give a more cogent answer than a bunch of newsgroup postings can. Stay tuned.
In article <Pine.A41.4.21L1.0202241734050.44596-100...@login3.isis.unc.edu>, Bijan
Parsia <bpar...@email.unc.edu> wrote: > But this suggests that unless you can *find* such to rally behind, you may > want to brush up your own political leadership skills. Otherwise, you may > end up in a pretty frustrating situtation.
I'm working on it.
> I notice that in debates you tend to externalize the difficulties of those > debates, i.e., people misreading you, double standards, folks resistent to > change or uninterested in helping, Erik's tactics or personality, > etc. Even if these externalizations are largely correct, it doesn't seem > that confronting them head on has made much headway. Perhaps there are > other ways to deal?
I'm open to suggestions.
> (What's wrong with Dylan as your "popular" Lisp, btw?)
Perhaps nothing, but I've bandied Dylan and Eiffel about a bit, and my perception is that they aren't "new" enough any more.
> Thus, people who want to use > something substantially like *Common* Lisp are not going to be remotely > helped by Arc. Indeed, they might be hurt by it.
Right. That's why one of my criteria has always been backwards-compatibility with Common Lisp. Don't forget, I'm one of those people who wants to use Common Lisp. The backwards-compatibility might not necessarily be 100% though (I think it would be good to do a little housecleaning. How many people really want to port CL applications to TOPS20 file systems?)
> Personally, I don't think that a new name and surface syntax are necessary > or sufficent. See Dylan.
Certainly not sufficient. I think the jury is out on necessary.
> > BTW, I > > state this as a proposed solution to a problem,
> Which problem? Parenthephobia? Anti-lisp bias?
Yes.
> I don't see that *at all*. That seems to be something an "expert" said was > true :) Worse, you're saying may have that effect on others!
I may well be projecting too much of my own mindset on others, but I really don't see how a reasonable person could see me as advocating knowing Lisp and nothing else at this point. A few people have come away with the opposite impression, so let me say again: nothing I have said should in any way be construed as advocating not learning or using Lisp.
> Aside from the people posting about their language experience, I see Kent > and Erik (to take two) both discussing Java and what it got right. People > seem reasonably open to my interjections of Smalltalk :) (Indeed, I > recognized several Smalltalkers 'round here.)
Yes, but how often does a C++ advocate get a warm reception?
> > I am caricaturing, of course, and most people > > don't take these extreme position in their pure form. But (putting on my > > scientist hat for a moment) this theory actually makes a testable > > prediction: that most people who like Lisp don't know much about other > > langauges, and most people who like other langauges don't know much about > > Lisp.
> I agree it's testable, but I don't think it's true ;)
> > (Here's a data point: when Paul Graham started designing Arc he > > didn't know Python.)
> He didn't know Python *at all*? Wow, that seems a bit odd.
Well, he knew *something* about it. This was a while ago and I don't want to misrepresent Paul, but I'm pretty sure he said he had never used it.
