Rainer Joswig wrote in
http://groups.google.com/groups?hl=en&lr=&ie=UTF-8&oe=UTF-8&selm=joswig-EB037A.10115830082003%40news.fu-berlin.de&prev=/groups%3Fhl%3Den%26lr%3D%26ie%3DUTF-8%26oe%3DUTF-8%26q%3Dwrong%2Bstep%2Bin%2Bwrong%2Bdirection%26btnG%3DGoogle%2BSearch%26meta%3Dgroup%253Dcomp.lang.lisp.*
+--------------------------------------
Yes, we want InterLisp back.
Read Erik Sandewall, The Lisp Experience, 1978
It gives valuable insight in the discussion of "structure vs. text"
with respect to user interfaces (editors, histories, ...)
in the InterLisp vs. MacLisp communities. The Appendix has
a letter by Stallman and an answer by Sandewall regarding these
issues. Common Lisp and Emacs are the wrong step in the wrong
direction, if the direction would be more pure Lisp.
+--------------------------------------
I couldn't get that article since it is no publicly available. Could
someone please post it here? Or could you please summarize why CL and
Emacs are the wrong step in the wrong direction?
Thanks...
In article <····························@posting.google.com>,
·········@gmx.net (thelifter) wrote:
> Rainer Joswig wrote in
> http://groups.google.com/groups?hl=en&lr=&ie=UTF-8&oe=UTF-8&selm=joswig-EB037A.10115830082003%40news.fu-berlin.de&prev=/groups%3Fhl%3Den%26lr%3D%26ie%3DUTF-8%26oe%3DUTF-8%26q%3Dwrong%2Bstep%2Bin%2Bwrong%2Bdirection%26btnG%3DGoogle%2BSearch%26meta%3Dgroup%253Dcomp.lang.lisp.*
>
> +--------------------------------------
> Yes, we want InterLisp back.
>
> Read Erik Sandewall, The Lisp Experience, 1978
>
> It gives valuable insight in the discussion of "structure vs. text"
> with respect to user interfaces (editors, histories, ...)
> in the InterLisp vs. MacLisp communities. The Appendix has
> a letter by Stallman and an answer by Sandewall regarding these
> issues. Common Lisp and Emacs are the wrong step in the wrong
> direction, if the direction would be more pure Lisp.
> +--------------------------------------
>
> I couldn't get that article since it is no publicly available. Could
> someone please post it here? Or could you please summarize why CL and
> Emacs are the wrong step in the wrong direction?
>
> Thanks...
get a Lisp system, write some hundred kilo lines of Lisp,
etc. - maybe that helps to get an idea.
Reading the InterLisp manuals may additionally
give some ideas:
http://www.spies.com/~aek/pdf/xerox/interlisp/
Rainer Joswig <······@lispmachine.de> wrote in message news:<····························@news.fu-berlin.de>...
> get a Lisp system, write some hundred kilo lines of Lisp,
> etc. - maybe that helps to get an idea.
>
> Reading the InterLisp manuals may additionally
> give some ideas:
Your answer doesn't make much sense to me. I was asking because I
don't want to go trough all those experiences to arrive at the same
conclusions as you. So how about summarizing the main points instead
of expecting me to find out myself?
thelifter wrote:
>
> Rainer Joswig <······@lispmachine.de> wrote in message news:<····························@news.fu-berlin.de>...
> > get a Lisp system, write some hundred kilo lines of Lisp,
> > etc. - maybe that helps to get an idea.
> >
> > Reading the InterLisp manuals may additionally
> > give some ideas:
>
> Your answer doesn't make much sense to me. I was asking because I
> don't want to go trough all those experiences to arrive at the same
> conclusions as you. So how about summarizing the main points instead
> of expecting me to find out myself?
Because then you'd be only learning second hand? Nothing
like going back to the original source and finding out for
yourself.
--
:ugah179 (home page: http://web.onetel.com/~hibou/)
"I'm outta here. Python people are much nicer."
-- Erik Naggum (out of context)
> > > Reading the InterLisp manuals may additionally
> > > give some ideas:
> >
> > Your answer doesn't make much sense to me. I was asking because I
> > don't want to go trough all those experiences to arrive at the
> > same conclusions as you. So how about summarizing the main points
> > instead of expecting me to find out myself?
>
> Because then you'd be only learning second hand? Nothing
> like going back to the original source and finding out for
> yourself.
If anyone wants to try this, you can always grab a copy of lfg on
ftp.parc.com under /pub/lfg. As far as I can tell, it has most if not
all of the Xerox D-machine lisp environment. For the hardcore, it
even has sedit.
--
Fred Gilham ······@csl.sri.com
The density of a textbook must be inversely proportional to the
density of the students using it. --- Dave Stringer-Calvert
Donald Fisk <················@enterprise.net> wrote in message news:<·················@enterprise.net>...
> thelifter wrote:
> >
> > Rainer Joswig <······@lispmachine.de> wrote in message news:<····························@news.fu-berlin.de>...
> > > get a Lisp system, write some hundred kilo lines of Lisp,
> > > etc. - maybe that helps to get an idea.
> > >
> > > Reading the InterLisp manuals may additionally
> > > give some ideas:
> >
> > Your answer doesn't make much sense to me. I was asking because I
> > don't want to go trough all those experiences to arrive at the same
> > conclusions as you. So how about summarizing the main points instead
> > of expecting me to find out myself?
>
> Because then you'd be only learning second hand? Nothing
> like going back to the original source and finding out for
> yourself.
I think I have to restore the original context. Rainer Joswig made the
following statement:
" Common Lisp and Emacs are the wrong step in the wrong
direction, if the direction would be more pure Lisp."
This was HIS statement. So all I want to know from him is why does he
think so. Am I asking too much? If I made a statement like: "I think C
is a bad language." and someone asks me "Why do you think so?" I don't
think he would be happy with: "Ohhh, read the manuals and program in C
for one year and you will find out."
Also isn't this newsgroup for learning second hand? Why do we ask
other people questions? It's because we don't want to go invest a lot
of time doing everything again... That's what newsgroups are for.
Hi
"thelifter" <·········@gmx.net> skrev i en meddelelse
·································@posting.google.com...
> Donald Fisk <················@enterprise.net> wrote in message
news:<·················@enterprise.net>...
> " Common Lisp and Emacs are the wrong step in the wrong
> direction, if the direction would be more pure Lisp."
>
Now I Lisped thru many small applications that over time became bigger and more
complicated, with the well known Lisp dialect AutoLisp.
Guess most will think that AutoLisp is a very small subset but AutoLisp acturly
carry all the basic printing and math. functions you ask , -------- but surely
it is a primitive dialect as either you use the functions avaible or you start
your programming defining these to be used within the same application. But
isn't this where Lisp "went wrong" ; that instead of a simple evaluator we now
must fight a number of compiler errors , just like any other high level
languages, for the only sake to save a few bytes in memmory..
Just think back to the day's where the only foult you could encounter, was a
misplaced parentets trying to persave the evaluator that the next 20 Kb. shuld
be a function and the rest not in the specified order, ---------- where today's
C++ style compilers tell you a wierd error messeage, that ask years of
experience to grasp.
Beside the more C++ like and profesional wearing both rubber boots, diving suit
, life jacket and slippers , you lost the magic of writing tree by four lines
recursive code , where you can freely replace atoms with functions, ----- use
functions as parameters and with today's computers experience a memmory overflow
in one tenth a second, where atleast in the old day's some 10 years ago, you
could sollow a memmory overflow.
With Lisp there alway's was a few things I been missing ; if they were there I
would proberly be a good programmer where today, if I want to compile a just
decent program, I will be fighting lame compiler directives making it impossible
to compile a simple "hello world" , except the compoiler will tell me a goodby
to my lame hopes to use compiled code or even the dream of it ; -------------
and that is realy wierd, as when I back then a few years ago was still doing
Lisp, my code looked very simular to how things was done in the C.L. bible ;
when I first came over a true manual in CommonLisp, it was obvious for me, that
even the limitations in AutoLisp, I was making the same matrixes to make the
same geometric calculations, as if I was pointing to a function Lib. and just
using already made functions . Acturly my code and my mind was as I se it now
split in two ; either doing the lot in tree line recursive functions or doing
the boring tradisional type of coding, that when reading the code, make Common
Lisp no different than any other high level language ; ----------- realy I
thought Lisp to be thee language, that had the best chance to develob into a
better compilable language ,
Now I can do what I need to do , in terms of defing the functions I need and I
will not need to fight a strict C++ style compiler making it impossible ever to
make any application work within Windows as anything but an application within
another program working with the set windows options. But I think that the
reson for this, is nip picking byte accounting and theoretical nonsense about
saving avaiable mem.
Anyway CommonLisp compilers is obviously made for programmers that just aswell
could write in C++, ---------- they are no help for those who thought Lisp and
the whole concept with Lisp to be fundamentaly different than those of other
tradisional high level.
P.C.
·········@gmx.net (thelifter) wrote in message news:<····························@posting.google.com>...
> Rainer Joswig <······@lispmachine.de> wrote in message news:<····························@news.fu-berlin.de>...
> > get a Lisp system, write some hundred kilo lines of Lisp,
> > etc. - maybe that helps to get an idea.
> >
> > Reading the InterLisp manuals may additionally
> > give some ideas:
>
> Your answer doesn't make much sense to me. I was asking because I
> don't want to go trough all those experiences to arrive at the same
> conclusions as you. So how about summarizing the main points instead
> of expecting me to find out myself?
It's kind of hard to summarize, but I may be able to give you an idea.
Rainer's suggestion that you write some hundred kilolines of
Lisp is somewhat misleading, because part of the charm of
Interlisp was that source code was of only secondary importance.
The basic development philosophy was based on dynamic modification
of an executing Interlisp image. So, your starting point in
developing an application is an Interlisp image. That
core image doesn't do what you want your application to do,
so you start modifying it by altering memory-resident Lisp data
structures. *One* way of doing that is by writing some code
and READ+EVALing it, but -- at least back in Interlisp-10 days --
the more common approach was by using an editor that
destructively modified memory-resident data structures, the
data that is your code. When you eventually modify Interlisp
enough that it has become your application -- or you're just
knocking off for the day -- you dump a new image. If you want
to, you can write out the current definitions of all the
and variables that have been altered, as summary of
what you've done. But it's not necessarily all that useful,
since there's no guarantee that loading that code into the
original executing image will result in modifying it so that
it behaves in the same way as the new executing image (for
subtle reasons that I won't go into here).
Interlisp is remembered for lots of other stuff as well --
such as DWIM (Do What I Mean), which could often successfully
guess that when you typed "9" you meant "(", and that when you
typed "CRD" you meant "CDR" -- but the basic idea that the
programmer's job is to sculpt a ball of mud into his or her
desired application, rather than "write source code", is the
fundamental difference, IMHO. I suppose one could argue this
is basically "just" a gestalt switch, since the mud is code
after all, and that modifying a list of strings
using Emacs is a huge efficiency win over modifying sexprs
with Interlisp's structure editor (which is certainly is).
But it must be admitted that Interlispers viewed the development
task from a differently perspective, and some of us still think
it was a nice scenic viewpoint.
Anyway, for the article Rainer referred to, go to the library --
you remember the library from the dark days before the Web,
right? -- and have a look at the book _Interactive Programming
Environments_.
Regards,
-- rar
···@sdl.sri.com (Bob Riemenschneider) wrote in message news:<····························@posting.google.com>...
> the basic idea that the
> programmer's job is to sculpt a ball of mud into his or her
> desired application, rather than "write source code"
[...]
> have a look at the book _Interactive Programming
> Environments_.
Are there other such books/sources on lisp UIs that people recommend?
I was actually interested in writing a similar system; from the
perspective of creating code by refactoring existing code (for other
languages which really could use less finger-typing). I guess I
couldn't have expected this to be a particularly novel idea...
> Anyway, for the article Rainer referred to, go to the library --
> you remember the library from the dark days before the Web,
> right?
If by "library" you're talking about Kazaa, it's not there, so I
ordered it from Amazon for 5 bux.
Thanks,
this was a really useful answer! Now I think I understand it. It is
amazing how many articles have been posted in this thread until your
answer. The signal to noise ratio is really low here.
Thanks...
·········@gmx.net (thelifter) writes:
> this was a really useful answer! Now I think I understand it. It is
> amazing how many articles have been posted in this thread until your
> answer. The signal to noise ratio is really low here.
Btw, if you really think this, I suspect you're not reading many
threads. While indeed some threads that do not seek technical
responses get side-tracked on unproductive philosophy and/or politics,
the ones that are oriented toward getting something done get pretty
good response, and most people grade the signal to noise ratio a lot
higher than for the average newsgroup.
Kent M Pitman <······@world.std.com> wrote in message news:<···············@shell01.TheWorld.com>...
> Btw, if you really think this, I suspect you're not reading many
> threads. While indeed some threads that do not seek technical
> responses get side-tracked on unproductive philosophy and/or politics,
> the ones that are oriented toward getting something done get pretty
> good response, and most people grade the signal to noise ratio a lot
> higher than for the average newsgroup.
What do you mean by "the ones that are oriented toward getting
something done"? I assume you mean the more "technical" threads. But
then your argument doesn't make sense. You do not know why a person is
asking any question, even a technical one. He might be asking just out
of curiosity, not necessaryly because he wants to solve a practical
problem.
I think the newsgroup is also here for technical questions, to
increase ones knowledge.
Additionally, may I remind you of another thread I started where I
asked about a free Lisp implementation that can access a MySql
database? Please go and read the first answer I received from one of
the "experts" here on the newsgroup. He wrote "Please do not feed the
trolls", and he even made the effort to add a nice ASCII art picture:
http://groups.google.com/groups?q=g:thl309275826d&dq=&hl=en&lr=&ie=UTF-8&oe=UTF-8&selm=874r5ox1c2.fsf%40bird.agharta.de
Kent I admire you because of your great knowledge in Lisp but I think
you got this one wrong, sorry.
From: Kenny Tilton
Subject: Re: CL wrong step in the wrong direction?
Date:
Message-ID: <3F5EB1CA.6070809@nyc.rr.com>
thelifter wrote:
> Kent M Pitman <······@world.std.com> wrote in message news:<···············@shell01.TheWorld.com>...
>
>>Btw, if you really think this, I suspect you're not reading many
>>threads. While indeed some threads that do not seek technical
>>responses get side-tracked on unproductive philosophy and/or politics,
>>the ones that are oriented toward getting something done get pretty
>>good response, and most people grade the signal to noise ratio a lot
>>higher than for the average newsgroup.
>
>
> What do you mean by "the ones that are oriented toward getting
> something done"?
What /I/ was going to say to your inflammatory "signal to noise" crap
was that you have to consider the OP; some just get answered, some get
told to go fuck themselves. Don't pretend you are not a variable in this
equation. Others are getting help where you are getting flamed. This is
not rocket science, which is not to say socializing well is easier than
rocket science.
kt
Kenny Tilton <·······@nyc.rr.com> writes:
> What /I/ was going to say to your inflammatory "signal to noise" crap
> was that you have to consider the OP; some just get answered, some get
> told to go fuck themselves. Don't pretend you are not a variable in
> this equation. Others are getting help where you are getting
> flamed. This is not rocket science, which is not to say socializing
> well is easier than rocket science.
In effect, I was saying the same thing. These things become somewhat
self-fulfilling prophecies. If you come here complaining that the free
service you get isn't up to par, you often find that people are happy
to continue to supply you with exactly that same level of service.
Did you consider this article of mine to be ironical? I was just
expressing my honest thanks. Maybe it is a misunderstanding? (Yes, I
was still complaining about the signal to noise ratio, but not
regarding my parent):
http://groups.google.com/groups?dq=&hl=en&lr=&ie=UTF-8&oe=UTF-8&selm=b295356a.0309090630.1ffc9fb4%40posting.google.com
You took your time to post a non-technical article in this thread, may
I ask for an additional few minutes for a technical one?
In my other thread, "Designing the next Lisp: draft 1 ":
http://groups.google.com/groups?dq=&hl=en&lr=&ie=UTF-8&oe=UTF-8&threadm=a3995c0d.0309091144.63552e63%40posting.google.com&prev=/groups%3Fhl%3Den%26lr%3D%26ie%3DUTF-8%26oe%3DUTF-8%26group%3Dcomp.lang.lisp
...I am discussing the possibility of making a simpler implementation
of CL.
But I have not forgotten ISLISP, which is one specification you know
pretty well(probably you did it), you even implemented it in CL. Now
the technical question would be:
How does the time for implementing/porting a CL compare to ISLISP?
The same question for size of implementation.
I was at the page of the only commercial implementor and it says it
was ported to more than 60 architectures, which is quite impressing.
Maybe it's better to answer this question to the other thread:
"Designing the next Lisp: draft 1 ", so everyone can find it.
Thanks for your time...
Sorry for any offense...
Kenny Tilton <·······@nyc.rr.com> wrote in message news:<················@nyc.rr.com>...
First of all, maybe there is some misunderstanding going on. In this
article where I thanked the parent for his post(in this thread), I was
not being ironic. I was serious:
http://groups.google.com/groups?dq=&hl=en&lr=&ie=UTF-8&oe=UTF-8&selm=b295356a.0309090630.1ffc9fb4%40posting.google.com
> told to go fuck themselves. Don't pretend you are not a variable in this
> equation. Others are getting help where you are getting flamed. This is
> not rocket science, which is not to say socializing well is easier than
> rocket science.
Thanks for the reminder, if you can tell me where I went wrong it
would be even better. Socializing is not easy, like in technical
questions I'm thankful for all that are willing to help.
From: Kenny Tilton
Subject: Re: CL wrong step in the wrong direction?
Date:
Message-ID: <3F5FB157.1080506@nyc.rr.com>
thelifter wrote:
> Kenny Tilton <·······@nyc.rr.com> wrote in message news:<················@nyc.rr.com>...
>
> First of all, maybe there is some misunderstanding going on. In this
> article where I thanked the parent for his post(in this thread), I was
> not being ironic. I was serious:
>
> http://groups.google.com/groups?dq=&hl=en&lr=&ie=UTF-8&oe=UTF-8&selm=b295356a.0309090630.1ffc9fb4%40posting.google.com
Jeez, your social IQ is lower than mine. This is good news, the National
Bureau of Standards can stop bothering me when they need to calibrate
their assholometer. Of course your article was sincere. Including the
flaming "The signal to noise ratio is really low here."
Homework for tonight: explain why that is a firebomb.
>
>
>>told to go fuck themselves. Don't pretend you are not a variable in this
>>equation. Others are getting help where you are getting flamed. This is
>>not rocket science, which is not to say socializing well is easier than
>>rocket science.
>
>
> Thanks for the reminder, if you can tell me where I went wrong it
> would be even better. Socializing is not easy, like in technical
> questions I'm thankful for all that are willing to help.
Ok, now that the horror at the thought of me as an expert on
socialization has subsided, it occurs to me that in fact a fellow social
cripple will be a better guide than one who does it naturally:
Just read what you write after you write it and before you send it. And
post more often, so you learn faster.
btw, Rainer's answer should to my mind have been parsed as "this is what
I know having done a whole lot of Lisp programming and having a solid
familiarity with InterLisp, and that experience cannot be reduced to a
sentence or I would." It is a commonplace rhetorical device. That's how
I took it, anyway, and if I am right, whining about not getting a quicky
answer obviously misses the message badly.
--
kenny tilton
clinisys, inc
http://www.tilton-technology.com/
---------------------------------------------------------------
"This is my simple religion.
There is no need for temples;
no need for complicated philosophy.
Our own brain, our own heart is our temple;
the philosophy is kindness."
-- Tenzin Gyatso, the Dalai Lama
On 9 Sep 2003 19:18:46 -0700, ·········@gmx.net (thelifter) wrote:
> Additionally, may I remind you of another thread I started where I
> asked about a free Lisp implementation that can access a MySql
> database? Please go and read the first answer I received from one of
> the "experts" here on the newsgroup. He wrote "Please do not feed
> the trolls", and he even made the effort to add a nice ASCII art
> picture:
>
> http://groups.google.com/groups?q=g:thl309275826d&dq=&hl=en&lr=&ie=UTF-8&oe=UTF-8&selm=874r5ox1c2.fsf%40bird.agharta.de
Well, you came here in good faith, asked a simple question and were
immediately flamed? Bummer!
But no! Check the link below the fine ASCII art (originally by Gareth
McCaughan IIRC) and you'll see that about the first thing you ever
posted to c.l.l was a lengthy article titled "Why I can't use Lisp"
[1] which resulted in more than 70 follow-ups. You have since taken
part in a couple of c.l.l threads so one can assume that you should
know what's there and what's not. Don't tell me you've never heard of
CLiki or you are too dumb to find the FAQ or search Google.
Now, in March 2003 you suddenly post an article where you ask about a
"free" CL implementation for Windows and Linux which can access MySQL
and Java. Wait a minute - weren't you the one who told us that such a
thing doesn't exist just a few months earlier. Let me quote:
"[...] there are no good compilers for free."
"But what does that help if you can't generate efficient code with
it?"
"A lot of people talk about the nice abstractions that Lisp enables,
but what if that produces slow, lousy code."
If that's not a troll I've never seen one.
Edi.
[1] <http://groups.google.com/groups?selm=b295356a.0208011247.562f2f26%40posting.google.com>
Edi Weitz <···@agharta.de> wrote in message news:<··············@bird.agharta.de>...
> Well, you came here in good faith, asked a simple question and were
> immediately flamed? Bummer!
>
> But no! Check the link below the fine ASCII art (originally by Gareth
> McCaughan IIRC) and you'll see that about the first thing you ever
Ohhh not again, this was already disussed in that old thread where you
first posted your nice ASCII art. I don't want to go trough it all
again.
> posted to c.l.l was a lengthy article titled "Why I can't use Lisp"
> [1] which resulted in more than 70 follow-ups. You have since taken
Yes, I'm glad and happy for the insight I gained from that thread. As
you can see, I'm still participating in this newsgroup, reading books
about Lisp and becoming impressed about it's power etc...
> part in a couple of c.l.l threads so one can assume that you should
> know what's there and what's not. Don't tell me you've never heard of
> CLiki or you are too dumb to find the FAQ or search Google.
No I'm not, and I'm also not too dumb to use the newsgroup. The fact
is I couldn't find what I wanted(AFAIK it doesn't exist until today)
so I asked in the Newsgroup, whats wrong with that?
> Now, in March 2003 you suddenly post an article where you ask about a
> "free" CL implementation for Windows and Linux which can access MySQL
> and Java. Wait a minute - weren't you the one who told us that such a
> thing doesn't exist just a few months earlier. Let me quote:
Ohhh, I can't believe that. Obviously after that old thread from few
months ago I had long changed my mind. I was still interested in
Lisp(and I'm still interested), or do you think I have fun wasting my
time posting here on google? I have more to do, believe me.
> If that's not a troll I've never seen one.
At that time I was still trying to introduce Lisp in my job. I needed
a Lisp that could work with MySql and Java. Couldn't find one. Well,
if you call that a troll what can I say?
Please consider that there are a lot of people that search the google
archives before posting(I have done it a lot and collected tons of
useful knowledge from several newsgroups).
Go to Google groups now and type in the following search terms(without
quotes):"lisp mysql database"
Guess what, the first thread to appear will be the one that I started,
the sad thing is that the searcher will have to read mostly flames.
Wouldn't it have been better if everyone just tried to contribute
useful information, remember: the Newsgroup is not email, it should be
useful to everybody, not only the original poster.
OK, I'll give you the benefit of doubt. If you're really planning to
use Lisp and get help from this group you should do at least three
things:
1. Use it! Just use it. Stop reading books and posting to c.l.l and
instead start with some project. Do whatever you think is useful
(maybe check CLiki first so you don't implement something for the
third time). Then, when you feel lost and don't know how to proceed
come back with precise questions and everybody including me will be
happy to help.
2. If you have a question, ask the question - that's enough. Be as
clear as possible and stay on topic. Don't explain to us why Lisp
is bad and why you can't use it and what should be changed to make
it better. We know that Lisp sucks, that's why we're here... :)
3. If you think something should be changed don't post complaints and
_demand_ that it should be changed. Either change it yourself or
pay someone to do it. Or prepare a convincing proposal and try to
find some implementors to agree on it. But don't expect anyone to
do your work just because you cry - that's not how Usenet
works. (And the same applies to the real world.)
Good luck,
Edi.
Edi Weitz <···@agharta.de> wrote in message news:<··············@bird.agharta.de>...
> OK, I'll give you the benefit of doubt. If you're really planning to
> use Lisp and get help from this group you should do at least three
> things:
Oh, the benefit of doubt. I thought this was a given. Well, it seems I
was wrong. Shall I thank you for granting it to me?
> 1. Use it! Just use it. Stop reading books and posting to c.l.l and
The problem is, I'm not happy with the existing implementations. This
may sound arrogant, but it is what I think. I'm also kind of afraid to
work into a dead-end. That's why I like to study things BEFORE I start
implementing. For a while I thought that Scheme was the solution,
until the recent thread "why some people think that scheme is not a
lisp" convinced me otherwise. The nice thing about scheme is that
there are some implementations that work very well with Java, which is
a very big plus if you are doing web-related stuff.
Posting ideas is the way I have found to contribute. You may not agree
with my ideas, that's ok. I don't have the knowledge or time to
implement most of them myself. Lack of knowledge is also a reason why
I'm mostly still studying(in the little spare time I have).
I will start a web-related project soon. I'm thinking about using
CLISP, but I already know some drawbacks, e.g. if I need to program
database access one day, I know it will not be easy, at least not as
easy as from Java, where it is really a trivial task.
Don't get me wrong. I really think that Lisp is a great language,
maybe the best around. But I think it misses in some practical issues.
I will say it once again: take CL for example. It is great and
powerful and at the sime time hard to implement. If you need an
implementation that works well together with Java you won't find one.
On 12 Sep 2003 09:17:14 -0700, ·········@gmx.net (thelifter) wrote:
> If you need an implementation that works well together with Java you
> won't find one.
Really?
<http://www.franz.com/support/documentation/6.2/doc/jlinker.htm>
<http://www.franz.com/support/documentation/6.2/doc/jil.htm>
Edi.
thelifter wrote:
> The problem is, I'm not happy with the existing implementations. This
> may sound arrogant, but it is what I think. I'm also kind of afraid to
> work into a dead-end. That's why I like to study things BEFORE I start
> implementing. For a while I thought that Scheme was the solution,
> until the recent thread "why some people think that scheme is not a
> lisp" convinced me otherwise. The nice thing about scheme is that
> there are some implementations that work very well with Java, which is
> a very big plus if you are doing web-related stuff.
One result of the discussion was that Scheme doesn't mandate a "lispy"
implementation. However, there are Scheme implementations that are quite
lispy due to their specific extensions. I am not quite sure, but SISC
seems to be one of those.
> I will start a web-related project soon. I'm thinking about using
> CLISP, but I already know some drawbacks, e.g. if I need to program
> database access one day, I know it will not be easy, at least not as
> easy as from Java, where it is really a trivial task.
>
> Don't get me wrong. I really think that Lisp is a great language,
> maybe the best around. But I think it misses in some practical issues.
> I will say it once again: take CL for example. It is great and
> powerful and at the sime time hard to implement. If you need an
> implementation that works well together with Java you won't find one.
I can relate to your feelings of despair, but at the same time I think
that your approach is not very effective.
Here is a possible approach:
1. Type the search words "java lisp" into Google.
The fourth result is a posting to a mailing list that discusses
Java/Lisp integration. They mention Lijos as one solution. Go to that
site and see if it suits your needs.
2. Type the search words "java lisp lijos" into Google.
The first link on that page that mentions another approach for Lisp/Java
integration is for JACOL. Go to that site and find out that they even
provide a discussion about some of the other alternatives.
Done.
Pascal
P.S.: The "Hitchhikers' Guide to Google" contains some more details
about the effective use of Google. See
http://hillside.net/europlop/papers/WorkshopA/A3_WeirC%2B.doc
--
Pascal Costanza University of Bonn
···············@web.de Institute of Computer Science III
http://www.pascalcostanza.de R�merstr. 164, D-53117 Bonn (Germany)
Pascal Costanza <········@web.de> writes:
> One result of the discussion was that Scheme doesn't mandate a "lispy"
> implementation. However, there are Scheme implementations that are quite
> lispy due to their specific extensions. I am not quite sure, but SISC
> seems to be one of those.
I would count Guile as such a Scheme, first because of a lot of practical
extensions (arrays, etc.), second because of its OO-system GOOPS which is
derived from TinyClos. Of course, if you are using such a Scheme the
question arises why you should not use the better and much more stable
Common Lisp. And if you do not really depend on tight C-Guile integration
you should switch. This is how I came to CL.
Nicolas.
thelifter writes:
> powerful and at the sime time hard to implement. If you need an
> implementation that works well together with Java you won't find one.
What about Allegro CL by Franz?
Paolo
--
Paolo Amoroso <·······@mclink.it>
thelifter <·········@gmx.net> wrote:
+---------------
| I will start a web-related project soon. I'm thinking about using
| CLISP, but I already know some drawbacks, e.g. if I need to program
| database access one day, I know it will not be easy, at least not as
| easy as from Java, where it is really a trivial task.
+---------------
Hey, dude, it's pretty trivial from Common Lisp, too!!
If you're using PostgreSQL, just grab Eric Marsden's "pg.lisp"
from <URL:http://www.chez.com/emarsden/downloads/> and you
can write stuff like this:
> (with-pg-connection (conn "my_data" "www")
(let* ((query "SELECT first, last, email FROM contact LIMIT 4")
(result (pg-exec conn query)))
(pg-result result :tuples)))
(("Joe" "Blow" ·····@nowhere.com")
("Betty" "Boop" NIL)
("Sally" "Summers" ···········@example.domain")
("Bart" "Ludd" NIL))
>
If you're using MySQL or some other database, go look at
<URL:http://www.cliki.net/Database>. There's lots of free
stuff available...
-Rob
-----
Rob Warnock, PP-ASEL-IA <····@rpw3.org>
627 26th Avenue <URL:http://rpw3.org/>
San Mateo, CA 94403 (650)572-2607
"thelifter" wrote:
> > 1. Use it! Just use it. Stop reading books and posting to c.l.l and
>
> The problem is, I'm not happy with the existing implementations. This
> may sound arrogant, but it is what I think.
Tough. I'm not happy with the existing implementations of
*any* language, but I still seem to manage to get some work
done using computers. So do lots of other people. What's
so hard?
> I'm also kind of afraid to
> work into a dead-end. That's why I like to study things BEFORE I start
> implementing. For a while I thought that Scheme was the solution,
> until the recent thread "why some people think that scheme is not a
> lisp" convinced me otherwise.
What about that thread convinced you otherwise? It seemed
to me to be an entirely philosophical thread. Are you choosing
a language on the basis of its philosophical soundness, or
of its practical technical capabilities?
> The nice thing about scheme is that
> there are some implementations that work very well with Java, which is
> a very big plus if you are doing web-related stuff.
If you need good interworking with Java, and there are
Scheme implementations that have that, and there are no
CL implementations that have that, then go and use Scheme.
Do you want to get whatever-it-is done, or do you just
want to complain?
> Posting ideas is the way I have found to contribute. You may not agree
> with my ideas, that's ok. I don't have the knowledge or time to
> implement most of them myself. Lack of knowledge is also a reason why
> I'm mostly still studying(in the little spare time I have).
Lack of knowledge is, I'm afraid, also the reason why
posting your ideas is not really a contribution.
> I will start a web-related project soon. I'm thinking about using
> CLISP, but I already know some drawbacks, e.g. if I need to program
> database access one day, I know it will not be easy, at least not as
> easy as from Java, where it is really a trivial task.
>
> Don't get me wrong. I really think that Lisp is a great language,
> maybe the best around. But I think it misses in some practical issues.
> I will say it once again: take CL for example. It is great and
> powerful and at the sime time hard to implement. If you need an
> implementation that works well together with Java you won't find one.
If that is true, then it will not get any better as a result
of you saying in c.l.l how deficient Lisp is in practical
issues. Nor will it get any better as a result of you saying
in c.l.l how Lisp ought to be redesigned to be more modular.
Fine words, as the saying goes, butter no parsnips. Write some
code, or do some *serious* design work and find people who
want to follow your design, or put in some money. The chances
of any other course of action improving the state of things
are essentially zero.
--
Gareth McCaughan
.sig under construc
From: Tim Bradshaw
Subject: Re: CL wrong step in the wrong direction?
Date:
Message-ID: <ey3vfrwlttu.fsf@cley.com>
* thelifter wrote:
> Don't get me wrong. I really think that Lisp is a great language,
> maybe the best around. But I think it misses in some practical issues.
> I will say it once again: take CL for example. It is great and
> powerful and at the sime time hard to implement. If you need an
> implementation that works well together with Java you won't find
> one.
Do you actually think CL is harder to implement than Java? Or, if you
stop to actually *think* about it, do you think that Java
implementations have had hundreds as times as much effort thrown at it
than CL has ever had? If Sun or IBM had decided to put the effort
they have put into Java implementations and libraries over the last 8
years into CL implementations and libraries, don't you think they
might have come with something pretty good?
No, I know, it must be something wrong with the language, mustn't it?
Let's just invent a new one. Even better, let's sit around whining to
try and get someone *else* to invent a new one. How very clever we
all are.
Damn, I knew it was stupid to even look at cll again. I'll retreat
back to my cave again now.
--tim
·········@gmx.net (thelifter) writes:
> the "experts" here on the newsgroup. He wrote "Please do not feed the
> trolls", and he even made the effort to add a nice ASCII art picture:
>
> http://groups.google.com/groups?q=g:thl309275826d&dq=&hl=en&lr=&ie=UTF-8&oe=UTF-8&selm=874r5ox1c2.fsf%40bird.agharta.de
The irony here is that this note is a pretty good example of why you
_are_ considered a troll.
/Jon
·········@gmx.net (thelifter) wrote in message news:<····························@posting.google.com>...
> Rainer Joswig <······@lispmachine.de> wrote in message news:<····························@news.fu-berlin.de>...
> > get a Lisp system, write some hundred kilo lines of Lisp,
> > etc. - maybe that helps to get an idea.
> >
> > Reading the InterLisp manuals may additionally
> > give some ideas:
>
> Your answer doesn't make much sense to me. I was asking because I
> don't want to go trough all those experiences to arrive at the same
> conclusions as you. So how about summarizing the main points instead
> of expecting me to find out myself?
Conclusions are only semantic symbols; triggers which are anchored in
the body of experience. Without the accompaniment of experience, they
have no meaning.
If conclusions are so great, why not be satisfied with ``Lisp sucks?''
Does that not summarize everything so you don't have to find out
anything for yourself? Someone who carries that conclusion, having
arrived at it himself, has a body of knowledge to which he constantly
refers whenever that conclusion surfaces in his consciousness. That
body is not discarded when the conclusion is made, otherwise the
conclusion may as well be discarded also.
Your attitude is that you want to avoid learning. It's as if you are
trying to collect a scrapbook of negative factoids about programming
languages which serve as excuses to avoid learning those languages.
Can you point to some project you have worked on in some programming
language that you liked?
Imagine a tourist who arrives at a strange town, finds an information
office for travellers and asks ``where can I book a tour of the
skankiest slums of this town so I can feel good about leaving it as
soon as possible? Is there some nice pamphlet about everything that is
wrong with this place that I can pass along to people so they can stay
away? Also, what's the fastest way out of this dive?'' I would
question why such a tourist didn't just stay home.
The right way to explore a new programming language is to find out the
positive space: what kind of programming it allows, or at least does
not prevent. If there is some purpose behind your inquiry, because you
want to write some software in a specific application area,
investigating the suitability of the language to that specific area is
indeed valuable, because it can save you from wasting time. But you
seem to have no area in mind; you are just looking for the weakness,
which indicates that you have no real purpose. For any given
programming language, you can find weaknesses, any of which could be
used as lame exuses to avoid it.
Sorry,
I have more to do than to answer your posting, I will just give it a
short answer because it isn't related to the topic in any way.
From the "Oxford Advanced Learner's Dictionary of Current English":
conclusion: ...belief or opinion which is the result of reasoning
Merriam-Webster: a reasoned judgment.
In other words, conclusions are totally independent from experience,
they are a pure rational entity. You don't need experience to arrive
at some conclusion. I will give your examples to make it clearer:
I never had a car accident, but fasten my seat belts.
Never had cancer, but know the hazards of smoking, etc...
Never programmed in Lisp(only minor stuff) but know that it is
probably the best language around, and a great deal of that knowledge
comes from this newsgroup and the web.
·········@gmx.net (thelifter) writes:
> Sorry,
> I have more to do than to answer your posting, I will just give it a
> short answer because it isn't related to the topic in any way.
>
> From the "Oxford Advanced Learner's Dictionary of Current English":
>
> conclusion: ...belief or opinion which is the result of reasoning
>
> Merriam-Webster: a reasoned judgment.
>
> In other words, conclusions are totally independent from experience,
> they are a pure rational entity. You don't need experience to arrive
> at some conclusion. I will give your examples to make it clearer:
>
> I never had a car accident, but fasten my seat belts.
> Never had cancer, but know the hazards of smoking, etc...
You can't really say this. If you had never seen or heard of a vehicle
before, then would you fasten your seat belt upon entering it?
Likewise, before the hazards of smoking were generally known, you
may have had no qualms about smoking.
We all experience these things indirectly, through knowing or hearing
of countless examples of auto deaths due to not wearing seatbelts or
people getting cancer from smoking. But it is still this indirect
experience which allows you to make a conclusion.
Jock Cooper <·····@mail.com> wrote in message news:<··············@jcooper02.sagepub.com>...
> people getting cancer from smoking. But it is still this indirect
> experience which allows you to make a conclusion.
Exactly my point!
·········@gmx.net (thelifter) writes:
> Jock Cooper <·····@mail.com> wrote in message
> news:<··············@jcooper02.sagepub.com>...
> > people getting cancer from smoking. But it is still this indirect
> > experience which allows you to make a conclusion.
>
> Exactly my point!
Then you missed the original point AND my point. You said conclusions
were totally independent of experience. My point is that experience
doesn't have to be your personal one to be used to draw a conclusion.
But it's still experience being used to draw a conclusion.
If conclusions were totally indepenendent of experience then for your
example you would have to decide not to smoke or to wear a seat belt
with *no* prior knowledge that smoking causes cancer or having an
accident without a seat belt is much worse than with. In fact you'd
have to have no knowledge of any kind about what happens when you
smoke a cigarette or ride in a car - this knowledge would have been
gained by experience of some kind.
·········@gmx.net (thelifter) writes:
> Sorry,
...
> In other words, conclusions are totally independent from experience,
> they are a pure rational entity. You don't need experience to arrive
> at some conclusion.
And you're an idiot who should just go away.
/Jon
On 9 Sep 2003 15:56:03 -0700, ···@ashi.footprints.net (Kaz Kylheku) wrote:
> Conclusions are only semantic symbols; triggers which are anchored
> in the body of experience. Without the accompaniment of experience,
> they have no meaning.
>
> If conclusions are so great, why not be satisfied with ``Lisp
> sucks?'' Does that not summarize everything so you don't have to
> find out anything for yourself? Someone who carries that conclusion,
> having arrived at it himself, has a body of knowledge to which he
> constantly refers whenever that conclusion surfaces in his
> consciousness. That body is not discarded when the conclusion is
> made, otherwise the conclusion may as well be discarded also.
>
> Your attitude is that you want to avoid learning. It's as if you are
> trying to collect a scrapbook of negative factoids about programming
> languages which serve as excuses to avoid learning those languages.
> Can you point to some project you have worked on in some programming
> language that you liked?
>
> Imagine a tourist who arrives at a strange town, finds an
> information office for travellers and asks ``where can I book a tour
> of the skankiest slums of this town so I can feel good about leaving
> it as soon as possible? Is there some nice pamphlet about everything
> that is wrong with this place that I can pass along to people so
> they can stay away? Also, what's the fastest way out of this dive?''
> I would question why such a tourist didn't just stay home.
>
> The right way to explore a new programming language is to find out
> the positive space: what kind of programming it allows, or at least
> does not prevent. If there is some purpose behind your inquiry,
> because you want to write some software in a specific application
> area, investigating the suitability of the language to that specific
> area is indeed valuable, because it can save you from wasting time.
> But you seem to have no area in mind; you are just looking for the
> weakness, which indicates that you have no real purpose. For any
> given programming language, you can find weaknesses, any of which
> could be used as lame exuses to avoid it.
That was a wonderful article. I've saved it for future reference.
Thanks,
Edi.