I discovered it by accident (using google).
[ http://www.newlisp.org/index.cgi?page=Differences_to_Other_LISPs ]
Has anyone tried to program in it?
Is it worth learning? ...seems to be really alien.
Regards, Szymon.
szymon schrieb:
> I discovered it by accident (using google).
> [ http://www.newlisp.org/index.cgi?page=Differences_to_Other_LISPs ]
> Has anyone tried to program in it?
> Is it worth learning? ...seems to be really alien.
Well, I love it.
Since version 2.0 I know this nice softpile. It was my first lisp
experience on dos5.0-386/33er box. The turn around version 6.3 (the last
version before win98 gets old) runs also as one *.exe with wine under
linux. The file is only 463kb ... and can move the smile.bmp around the
screen. :)
There is more to say, but test it. The code is Scheme oriented and there
are not very much specials, but it shows, what 'portable can be. You can
look at nuvatec.com, maybe they had the older versions still online.
Worth learning it? Hmmm... when you are tired with all that high level
stuff you will have lots of fun with it. Pscht, this is a secret hint:
there is not much to learn, just copy and paste and modify from the
docus and you can cross high mountains. The designers seem to know how
to spell intuition.
Something other strange I know is plisp, but don't know whether it is
supported.
stefan
Stefan Scholl schrieb:
> On 2004-09-22 23:06:33, lin8080 wrote:
> > Well, I love it.
> How is it compared to CLISP? I haven't seen any benchmarks comparing
> newLisp to CLISP.
With CLISP? Well, hmm, ok, CLISP.
I found CLISP 3 years later when someone give me an old TI - Modem with
14.4 bps. I won't miss it since then. This goes so far that for me any
OS that can not do CLISP is not worthable to look closer at.
But benchmarks I do not make. NewLisp is funny and givs me back a
special kind of lispy element. Maybe it is titled 'just playing around'
or something like that.
stefan
lin8080 wrote:
> But benchmarks I do not make. NewLisp is funny and givs me back a
> special kind of lispy element. Maybe it is titled 'just playing around'
> or something like that.
>
I recommend ColorForth if you're into that kind of "playing around". Why
half-measure?
David Golden schrieb:
> lin8080 wrote:
> > But benchmarks I do not make. NewLisp is funny and givs me back a
> > special kind of lispy element. Maybe it is titled 'just playing around'
> > or something like that.
> I recommend ColorForth if you're into that kind of "playing around". Why
> half-measure?
Oh, with forth I crashed two PCs (winforth). I better do not touch it
for a while...
stefan
In article <·················@freenet.de>, lin8080 <·······@freenet.de>
wrote:
> Well, I love it.
I find it amusing 'cause it's good for WTF! style yucks. I would never
trust it for serious work.
For example:
raffaelc$ newlisp
newLISP v.8.1.7 Copyright (c) 2004 Lutz Mueller. All rights reserved.
> (defun factorial (x) (if (< x 2) 1 (* x (factorial (- x 1)))))
(lambda (x)
(if (< x 2)
1
(* x (factorial (- x 1)))))
> (factorial 5)
120
> (dotimes (n 50) (begin (print (factorial n)) (print "\n")))
1
1
2
6
24
120
720
5040
40320
362880
3628800
39916800
479001600
1932053504
1278945280
2004310016
2004189184
-288522240
-898433024
109641728
-2102132736
-1195114496
-522715136
862453760
-775946240
2076180480
-1853882368
1484783616
-1375731712
-1241513984
1409286144
738197504
-2147483648
-2147483648
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
"\n"
>
Hmmm...
So I consulted the manual:
"Calculations which result in values bigger than 2,147,483,647 or
smaller than |2,147,483,648 wraps around from positive to negative or
negative to positive numbers."
I fail to see how this is a step forward for lisp. Though I think it is
appropriately named - sort of like Orwell's newspeak...
Raffael Cavallaro <················@junk.mail.me.not.mac.com> wrote in message news:<······································@netnews.comcast.net>...
> In article <·················@freenet.de>, lin8080 <·······@freenet.de>
> wrote:
>
> > Well, I love it.
>
> I find it amusing 'cause it's good for WTF! style yucks. I would never
> trust it for serious work.
>
> For example:
>
> raffaelc$ newlisp
> newLISP v.8.1.7 Copyright (c) 2004 Lutz Mueller. All rights reserved.
>
> > (defun factorial (x) (if (< x 2) 1 (* x (factorial (- x 1)))))
> (lambda (x)
> (if (< x 2)
> 1
> (* x (factorial (- x 1)))))
> > (factorial 5)
> 120
> > (dotimes (n 50) (begin (print (factorial n)) (print "\n")))
> 1
> 1
> 2
> 6
> 24
..
..
> 0
> 0
> "\n"
> >
>
> Hmmm...
> So I consulted the manual:
>
> "Calculations which result in values bigger than 2,147,483,647 or
> smaller than |2,147,483,648 wraps around from positive to negative or
> negative to positive numbers."
>
> I fail to see how this is a step forward for lisp. Though I think it is
> appropriately named - sort of like Orwell's newspeak...
Reposted from newlisp forum.
He could have just defined it using floating point arithmetik:
(define (factorial x) (if (< x 2) 1 (mul x (factorial (sub x 1)))))
and then it will work just fine.
If he dosn't like the possibility of Integer Arithmetik in a scripting
language, he can do:
(constant '+ add)
etc
Lutz
··········@spamgourmet.com (HPW) writes:
> Reposted from newlisp forum.
Is this for real or are you making this up?
> He could have just defined it using floating point arithmetik:
>
>
> (define (factorial x) (if (< x 2) 1 (mul x (factorial (sub x 1)))))
>
> and then it will work just fine.
>
> If he dosn't like the possibility of Integer Arithmetik in a scripting
> language, he can do:
>
> (constant '+ add)
> etc
>
> Lutz
This is so absurd it is (almost) no longer funny.
Think bignum, man!
On 2004-09-23 20:19:53, Mario S. Mommer wrote:
> ··········@spamgourmet.com (HPW) writes:
>> Reposted from newlisp forum.
>
> Is this for real or are you making this up?
You can find more funny stuff in that forum.
> Hmmm...
> So I consulted the manual:
>
> "Calculations which result in values bigger than 2,147,483,647 or
> smaller than |2,147,483,648 wraps around from positive to negative or
> negative to positive numbers."
>
> I fail to see how this is a step forward for lisp. Though I think it is
> appropriately named - sort of like Orwell's newspeak...
rlol. point taken. No support for Big Integers
Altso no type info added to the integer type
(3 bytes would give 2^29 not 2^32)
--
Using M2, Opera's revolutionary e-mail client: http://www.opera.com/m2/
John Thingstad wrote:
> rlol. point taken. No support for Big Integers
> Altso no type info added to the integer type
> (3 bytes would give 2^29 not 2^32)
3 byte = 3 * 8 bit = 24 bit = 2^24 different representable values?
With kind regards,
Oliver
On Thu, 23 Sep 2004 11:14:14 +0200, Oliver Korpilla
<·······@fh-landshut.de> wrote:
> John Thingstad wrote:
>> rlol. point taken. No support for Big Integers
>> Altso no type info added to the integer type
>> (3 bytes would give 2^29 not 2^32)
>
> 3 byte = 3 * 8 bit = 24 bit = 2^24 different representable values?
>
> With kind regards,
> Oliver
>
Far worse 2^32-2^29 or (/ (expt 32 2) (expt 3 2))
--
Using M2, Opera's revolutionary e-mail client: http://www.opera.com/m2/
On Thu, 23 Sep 2004 11:29:27 +0200, John Thingstad
<··············@chello.no> wrote:
> On Thu, 23 Sep 2004 11:14:14 +0200, Oliver Korpilla
> <·······@fh-landshut.de> wrote:
>
>> John Thingstad wrote:
>>> rlol. point taken. No support for Big Integers
>>> Altso no type info added to the integer type
>>> (3 bytes would give 2^29 not 2^32)
>>
>> 3 byte = 3 * 8 bit = 24 bit = 2^24 different representable values?
>>
>> With kind regards,
>> Oliver
>>
>
> Far worse 2^32-2^29 or (/ (expt 32 2) (expt 3 2))
>
Opps!! 3 bits .. not 3 bytes
--
Using M2, Opera's revolutionary e-mail client: http://www.opera.com/m2/
John Thingstad wrote:
> On Thu, 23 Sep 2004 11:14:14 +0200, Oliver Korpilla
> <·······@fh-landshut.de> wrote:
>
>> John Thingstad wrote:
>>
>>> rlol. point taken. No support for Big Integers
>>> Altso no type info added to the integer type
>>> (3 bytes would give 2^29 not 2^32)
>>
>>
>> 3 byte = 3 * 8 bit = 24 bit = 2^24 different representable values?
>>
>> With kind regards,
>> Oliver
>>
>
> Far worse 2^32-2^29 or (/ (expt 32 2) (expt 3 2))
>
Well, if you're getting your math reversed, that's not proving anything:
(expt 2 32) <=> 2^32 is the highest value representable by 32 bit: What we like
to call 4G (4 * 1024 * 1024).
(expt 2 8) <=> 2^8 = 256 different representable values.
Values to be representable by 3 byte:
(expt 2 24) = 2^24 = 16M, oh, and BTW: 16M * 256 (2^8) = 4G.
I don't know where your reasoning is coming from, but it is simply wrong!
2^32 - 2^8 = 2^(32 - 8) = 2^24 = 16M;
With kind regards,
Oliver
> I don't know where your reasoning is coming from, but it is simply wrong!
>
> 2^32 - 2^8 = 2^(32 - 8) = 2^24 = 16M;
>
> With kind regards,
> Oliver
No it's not! (/ 2^32 2^3) is right.
You are not subtracting 8 values (2^3) you are subtracting the upper 3
bits.
2^29 vs 2^32
--
Using M2, Opera's revolutionary e-mail client: http://www.opera.com/m2/
John Thingstad wrote:
>
>> I don't know where your reasoning is coming from, but it is simply wrong!
>>
>> 2^32 - 2^8 = 2^(32 - 8) = 2^24 = 16M;
>>
>> With kind regards,
>> Oliver
>
>
> No it's not! (/ 2^32 2^3) is right.
> You are not subtracting 8 values (2^3) you are subtracting the upper 3
> bits.
> 2^29 vs 2^32
1.) You said 3 byte. This is true for 3 byte.
2.) Your code was representing (/ 32^2 32^2), not vice versa.
With kind regards,
Oliver
In article <·················@freenet.de>, lin8080 <·······@freenet.de>
wrote:
> Didn't I type ... lots of fun?
>
> stefan
Well, to explain a joke is always to kill it (not that this one had much
life left in it anyway...)
You wrote, "Well, I love it," and "NewLisp is funny and givs me back a
special kind of lispy element." The two, in combination suggest that you
find it funny in the sense of liking and enjoying it.
I wrote "I find it amusing 'cause it's good for WTF! style yucks," which
suggests that I find it funny in the sense of laughing at it because it
is so grotesquely bad. Given the legions of high quality common lisp and
scheme implementations out there, not to mention Dylan and goo, newlisp
is a giant step backwards for the lisp family of languages. If I could,
I would euthanize newlisp for the good of programmers the world over.
Summary: You're laughing *with* newlisp. Most of us are lauging *at* it.
Raffael Cavallaro schrieb:
...
> Summary: You're laughing *with* newlisp. Most of us are lauging *at* it.
Yes. You can do so. Most can do so.
But this is not very nice. As you know that Common Lisp has a longer
history and many clever people to maintain it. (see this newsgroup)
Give the same to newLisp and I'm sure it looks better.
Will you laugh about the first issue of the lisp interpreter? In that
times there are also people (most) who laugh about that curios thing.
stefan
smile.bmp comes around :)
lin8080 <·······@freenet.de> writes:
> Raffael Cavallaro schrieb:
> > Summary: You're laughing *with* newlisp. Most of us are lauging *at* it.
> Yes. You can do so. Most can do so.
> But this is not very nice. As you know that Common Lisp has a longer
> history and many clever people to maintain it. (see this newsgroup)
> Give the same to newLisp and I'm sure it looks better.
> Will you laugh about the first issue of the lisp interpreter? In that
> times there are also people (most) who laugh about that curios thing.
Certainly, by our standards, many of the Lisps that appeared in the
late 50s through the early 80s were strange and funny. But there is
an important piece which you are missing, which sets so-called
``newLISP'' apart: this is 2004. We have the experience of the last
50 years which tells us that ``newLISP'' is a farce; why don't the
creators of ``newLISP'' realize this? They do not learn from history,
hence we laugh at them. They were given the advantage of long history
and the work of smart people, and they completely ignored it.
--
;; Matthew Danish -- user: mrd domain: cmu.edu
;; OpenPGP public key: C24B6010 on keyring.debian.org
In article <··············@mapcar.org>, Matthew Danish wrote:
> lin8080 <·······@freenet.de> writes:
>> Raffael Cavallaro schrieb:
>> > Summary: You're laughing *with* newlisp. Most of us are lauging *at* it.
>> Yes. You can do so. Most can do so.
>> But this is not very nice. As you know that Common Lisp has a longer
>> history and many clever people to maintain it. (see this newsgroup)
>> Give the same to newLisp and I'm sure it looks better.
>> Will you laugh about the first issue of the lisp interpreter? In that
>> times there are also people (most) who laugh about that curios thing.
>
> Certainly, by our standards, many of the Lisps that appeared in the
> late 50s through the early 80s were strange and funny. But there is
> an important piece which you are missing, which sets so-called
> ``newLISP'' apart: this is 2004. We have the experience of the last
> 50 years which tells us that ``newLISP'' is a farce; why don't the
> creators of ``newLISP'' realize this? They do not learn from history,
> hence we laugh at them. They were given the advantage of long history
> and the work of smart people, and they completely ignored it.
>
I'm new to LISP. Please explain why newLISP is a farse? For what I'm
considering it seems to do everything that I want.
Mike
Mike <·····@mikee.ath.cx> writes:
> I'm new to LISP. Please explain why newLISP is a farse? For what I'm
> considering it seems to do everything that I want.
A Turing machine can do everything you want, too. That doesn't mean
you want to program that way.
``newLISP'' makes design decisions which Lisp programmers out-grew
long ago. I'm not talking about availability of libraries here, I'm
talking about fundamental concepts in the language. ``newLISP'' does
not have proper lexically scoped variables, it does not have
polymorphic arithmetic functions with a numeric tower, it has an
extremely primitive, and in some cases downright poor, treatment of
objects. In short, ``newLISP'' is an anachronism; it belongs to the
1960s, before most people started to get a clue about language design.
Of course, one can point out flaws in any language; but what is
particularly ironic about ``newLISP'' is that despite its name, it
does not indicate that there was any knowledge of current Lisps in the
minds of the authors. How could they create a truly ``new'' Lisp if
they don't know anything about existing Lisps?
--
;; Matthew Danish -- user: mrd domain: cmu.edu
;; OpenPGP public key: C24B6010 on keyring.debian.org
In article <··············@mapcar.org>, Matthew Danish wrote:
> Mike <·····@mikee.ath.cx> writes:
>> I'm new to LISP. Please explain why newLISP is a farse? For what I'm
>> considering it seems to do everything that I want.
>
> A Turing machine can do everything you want, too. That doesn't mean
> you want to program that way.
>
> ``newLISP'' makes design decisions which Lisp programmers out-grew
> long ago. I'm not talking about availability of libraries here, I'm
> talking about fundamental concepts in the language. ``newLISP'' does
> not have proper lexically scoped variables, it does not have
> polymorphic arithmetic functions with a numeric tower, it has an
> extremely primitive, and in some cases downright poor, treatment of
> objects. In short, ``newLISP'' is an anachronism; it belongs to the
> 1960s, before most people started to get a clue about language design.
>
> Of course, one can point out flaws in any language; but what is
> particularly ironic about ``newLISP'' is that despite its name, it
> does not indicate that there was any knowledge of current Lisps in the
> minds of the authors. How could they create a truly ``new'' Lisp if
> they don't know anything about existing Lisps?
>
Ok, I'll certainly take your word for it. What I'm searching for is
something that either has the kinds of words that are present in newLISP,
or that I can easily modify to add those words. I am looking for something
that is small and efficient. I have PERL on my servers, but I don't
really want to use its multi-megabyte system. Nor do I want to install
clisp everywhere. What are other options? I don't need nor want a full
CL implementation; I don't understand the architecture as you do.
I want something small, simple, and reasonably efficient that I can
tailor to my specific needs.
Some options I'm considering are xlisp, picoLisp, lisp500, and just
writing my own using L.I.S.P. or I'll buy a new copy of SICP (I can't
find the copy I think I've already bought :().
Mike
On 2004-09-27 21:38:11 -0400, Mike <·····@mikee.ath.cx> said:
> Some options I'm considering are xlisp, picoLisp, lisp500, and just
> writing my own using L.I.S.P. or I'll buy a new copy of SICP (I can't
> find the copy I think I've already bought :().
>
> Mike
Since you want to run on several systems (possibly on several OSes) you
might want to look at SISC:
<http://sisc.sourceforge.net/>
which is a fully R5RS compliant scheme implementation built on top of
Java, will full access to the many existing Java libraries out there.
"Mike" <·····@mikee.ath.cx> wrote in message
····················@corp.supernews.com...
> Ok, I'll certainly take your word for it. What I'm searching for is
> something that either has the kinds of words that are present in newLISP,
> or that I can easily modify to add those words. I am looking for something
> that is small and efficient. I have PERL on my servers, but I don't
> really want to use its multi-megabyte system.
Perls libraries may well be multi-megabyte, but the Perl executable is not
gigantuan.
Even if it is, the executable part is shared and cached among invocations of
Perl (assuming your system isn't thrashing, of course).
If you want to use "lightweight" Perl, then use lightweight libraries or
write your own. Perl modules suffer bloat and nasty dependency issues, but
since there are literally a gazillion modules and bits of code available for
it, I'm confident that you can find the subset of the system that suits your
needs. You don't need to download all of CPAN to use Perl.
I'm no advocate for Perl, but I want to see it damned for the right reasons
and not the wrong ones.
> Nor do I want to install clisp everywhere.
But you're willing to install something else everywhere?? Perl is
ubiquitous. Python is getting there. Anything else, you'll have to install
yourself. So, why not CLISP?
> What are other options? I don't need nor want a full CL implementation; I
don't understand the architecture as you do.
You do not need to understand all of CL to use CL. You can pick and choose
the bits you like to use, and the idioms you choose to use.
But, I understand, that's the rub. If you don't understand it, how can you
pick and choose. When your generic scripting language gives you two ways of
iteration, it's easy to pick the write one. When your language gives you 20,
it can be an issue.
But with just Functions, Structures, Lists, HashTables, (do ...), (dolist
...), (dotimes ...), Mapping, Symbols, Strings and basic math, you can do a
LOT. You don't necesarily need CLOS, macros, conditions, LOOP, hacking the
reader, MOP, &key, &aux, &optional, etc.
> I want something small, simple, and reasonably efficient that I can tailor
to my specific needs.
CLISP is tailorable, unless you're planning to hack the implementation. Its
bytecode implementation makes loadiing of compiled code very efficient
compared to parsing of source text (which you'd need to do with most
"simple" systems). This makes actual CLISP startup quite quick. The larger
the program, the faster it starts in comparison.
> Some options I'm considering are xlisp, picoLisp, lisp500, and just
> writing my own using L.I.S.P. or I'll buy a new copy of SICP (I can't
> find the copy I think I've already bought :().
Any "lesser" system will mean that you invest time redoing stuff that
something like CLISP (perhaps with a 3rd party library) is probably already
providing. As implementations go, CLISPs biggest weakness compared to other
systems is threading. But unless you're writing servers, that's simply not a
real concern.
The time you invest in deciphering how to use one of the library module
systems available for CL will be minor compared to adding the base
functionality to any of these "tiny" languages.
Finally, you're running these scripts either on a Unix box or a Windows box.
Both of these systems are ENORMOUS, with vast arrays of apis, utilities, and
functionality. Yet, you're not worried about the unused capabilities in
those systems. You've already mastered the fraction of those systems
features to get it to do what you want to do. What makes you think that
Common Lisp is any different? Master the 20% you need to master and move on.
By using CL, you'll be able to leverage code from other writers who may well
need something within the other 80% of CL that you haven't mastered. But if
you start with a system whose 100% is the same as CL's 20%, then you've
already hit a brick wall and have to reinvent the wheel before you even get
out of the gate.
Simply put, the added complexity and capability of CLISP and CL does not
cost you anything. You need not worry about it. But should you ever need it,
that extra capability will be there waiting for you and you won't have to
reinvent the wheel.
Regards,
Will Hartung
(·····@msoft.com)
"Will Hartung" <·····@msoft.com> wrote in message
····················@uni-berlin.de...
> "Mike" <·····@mikee.ath.cx> wrote in message
> ····················@corp.supernews.com...
> > Ok, I'll certainly take your word for it. What I'm searching for is
> > something that either has the kinds of words that are present in
newLISP,
> > or that I can easily modify to add those words. I am looking for
something
> > that is small and efficient. I have PERL on my servers, but I don't
> > really want to use its multi-megabyte system.
>
> Perls libraries may well be multi-megabyte, but the Perl executable is not
> gigantuan.
*snip*
Hey Mike, you sent me an email, but my reply to you bounced.
Send me a working address if you're interested.
Regards,
Will Hartung
(·····@msoft.com)
Mike wrote:
> [.....]
> really want to use its multi-megabyte system. Nor do I want to install
> clisp everywhere. What are other options? I don't need nor want a full
> CL implementation;
Very interesting scripting language: [ http://www.iolanguage.com ]. Not
LISP.
Regards, Szymon.
Matthew Danish schrieb:
> lin8080 <·······@freenet.de> writes:
> > Raffael Cavallaro schrieb:
> Certainly, by our standards, many of the Lisps that appeared in the
> late 50s through the early 80s were strange and funny. But there is
> an important piece which you are missing, which sets so-called
> ``newLISP'' apart: this is 2004. We have the experience of the last
> 50 years which tells us that ``newLISP'' is a farce; why don't the
> creators of ``newLISP'' realize this? They do not learn from history,
> hence we laugh at them. They were given the advantage of long history
> and the work of smart people, and they completely ignored it.
Yes. This is a good point.
Now, when "our standarts" is implement a second time, this will end in
the same thing. Otherwise you see something different and have to choose
(see Lisp's History).
Or, since I read in cll I saw posts like "lets build a new interpreter".
What is coming out from there?
In some Items above, someone will start with a new text editor. And when
that is done, the next step arise, so this can end in a complete new
implementation.
Most persons I follow watching in their (lisp oriented) projects
progress give up sooner or later and parts lie around uncompleted. It is
too much work and rarely one project comes to the market with success
(ie, say in 10 Years). Some made it in the past, but I do not know, how
many did not. (in this point no one will learn from the history)
So, I give newLisp a change. It looks like they go their way and it is a
bit different.
stefan
Meanwhile there is also a lot of work to do on CL, ...
In article <··············@g.mccaughan.ntlworld.com>, Gareth McCaughan wrote:
> "lin8080" wrote:
>
> [Matthew Danish:]
>> > Certainly, by our standards, many of the Lisps that appeared in the
>> > late 50s through the early 80s were strange and funny. But there is
>> > an important piece which you are missing, which sets so-called
>> > ``newLISP'' apart: this is 2004. We have the experience of the last
>> > 50 years which tells us that ``newLISP'' is a farce; why don't the
>> > creators of ``newLISP'' realize this? They do not learn from history,
>> > hence we laugh at them. They were given the advantage of long history
>> > and the work of smart people, and they completely ignored it.
>
> ["lin8080":]
>> Yes. This is a good point.
>>
>> Now, when "our standarts" is implement a second time, this will end in
>> the same thing. Otherwise you see something different and have to choose
>> (see Lisp's History).
> ...
>> So, I give newLisp a change. It looks like they go their way and it is a
>> bit different.
>
> Matthew's complaint isn't that "newLISP" isn't just the same
> as CL. It's that "newLISP" is the opposite of what its name
> implies, a reversion to ideas and techniques that have been
> *tried extensively* and found unsatisfactory. Symbols instead
> of strings. FEXPRs masquerading as macros. Dynamic scoping as
> the default.
>
> Now, it does look as if there are a few new ideas in there.
> They look to me like pretty bad ideas, but probably most
> good ideas look bad to a lot of people when they first appear.
> So there might be something there worth watching. But my
> overriding impression is like Matthew's: these people are
> proclaiming that their version of Lisp is New And Improved
> but showing very little sign of having looked enough at
> the allegedly Old and Creaky versions that they'd be entitled
> to make that claim. (Example: the current last item in their
> list of differences between newLISP and other Lisps seems
> to indicate that they aren't really very familiar with
> either CL or Scheme.)
>
To help the new folks around here learn (me!), can you contrast
some of the CL/LISP features to how those same features are
implemented in newLISP and why the CL/LISP is better?
Mike
"Mike" <·····@mikee.ath.cx> wrote in message
····················@corp.supernews.com...
> In article <··············@g.mccaughan.ntlworld.com>, Gareth McCaughan
wrote:
> > Now, it does look as if there are a few new ideas in there.
> > They look to me like pretty bad ideas, but probably most
> > good ideas look bad to a lot of people when they first appear.
> > So there might be something there worth watching. But my
> > overriding impression is like Matthew's: these people are
> > proclaiming that their version of Lisp is New And Improved
> > but showing very little sign of having looked enough at
> > the allegedly Old and Creaky versions that they'd be entitled
> > to make that claim. (Example: the current last item in their
> > list of differences between newLISP and other Lisps seems
> > to indicate that they aren't really very familiar with
> > either CL or Scheme.)
> >
>
> To help the new folks around here learn (me!), can you contrast
> some of the CL/LISP features to how those same features are
> implemented in newLISP and why the CL/LISP is better?
You need to be specific here Mike.
You need to come up with the things that you like about newLisp, otherwise
someone contrasting CL/Scheme and newLisp will contrast them base on core
language and implementation issues that may not be central to what you are
looking for.
I sense you're priorities and what really interest you in this endeavor are
not the same as a CL grognard.
Regards,
Will Hartung
(·····@msoft.com)
"Will Hartung" <·····@msoft.com> wrote in message
····················@uni-berlin.de...
>
>
> You need to be specific here Mike.
>
> You need to come up with the things that you like about newLisp, otherwise
> someone contrasting CL/Scheme and newLisp will contrast them base on core
> language and implementation issues that may not be central to what you are
> looking for.
>
> I sense you're priorities and what really interest you in this endeavor
are
> not the same as a CL grognard.
>
Ok I have been following this thread with curiosity as I must admit I have
been using newlisp for a while even though I own a professional version of
ACL 5.01.
My use of it is actually very limited and indirect i.e. in acl I have the
following function:
(defun make-newlisp-file-getter (list-of-links)
(format nil "~&···················@
(set 'links (list ~{\"~a\" ~}))·@
(dolist (link links)·@
(set 'file (last (parse link \"/\")))·@
(write-file file (get-url link)))" list-of-links))
The list of links is clearly a list of files I would like to download and
it's generated by other code written in acl, however I haven't yet figured
out of to dwld files with acl.
I have the acl.socket package however reading the manual didn't help while
newlisp had one simple clear example of how to do such dwld and eventually
it was easier for me to just write a bunch of files wrap them up and then
run them in newlisp.
If any one can point me to a good example of actual code on how to interact
with the web for acl 5.01 I would be more than happy not to have to deal
with newlisp anymore (I didn't find the manual of the socket package that
useful http://www.franz.com/support/documentation/6.2/doc/socket.htm).
Thanks for any indication of where to look.
"Raistlin Magere" <·······@*the-mail-that-burns*.com> wrote in message
·················@news.ox.ac.uk...
> Ok I have been following this thread with curiosity as I must admit I have
> been using newlisp for a while even though I own a professional version of
> ACL 5.01.
*snip*
> The list of links is clearly a list of files I would like to download and
> it's generated by other code written in acl, however I haven't yet figured
> out of to dwld files with acl.
> I have the acl.socket package however reading the manual didn't help while
> newlisp had one simple clear example of how to do such dwld and eventually
> it was easier for me to just write a bunch of files wrap them up and then
> run them in newlisp.
And this is the key to what I think is what confuses the differences between
CL and newLisp, these higher order utility functions that simply aren't part
of the ANSI spec, but which make "scripting" languages so handy.
Most scripts are simply automation of large tasks and simply don't need to
worry about things like the numeric tower or even lexical binding.
But it helps if this is brought to the forefront of the discussion rather
than having folks talk past each other.
Regards,
Will Hartung
(·····@msoft.com)
"Raistlin Magere" <·······@*the-mail-that-burns*.com> writes:
> If any one can point me to a good example of actual code on how to interact
> with the web for acl 5.01 I would be more than happy not to have to deal
> with newlisp anymore (I didn't find the manual of the socket package that
> useful http://www.franz.com/support/documentation/6.2/doc/socket.htm).
aserve (http://opensource.franz.com/aserve/index.html) has a
do-http-request function in client.cl.
Andras
"Andras Simon" <······@math.bme.hu> wrote in message
····················@csusza.math.bme.hu...
>
> aserve (http://opensource.franz.com/aserve/index.html) has a
> do-http-request function in client.cl.
>
> Andras
Thanks for the tip, I'll have a try at it.
Hi Mike,
> To help the new folks around here learn (me!), can you contrast
> some of the CL/LISP features to how those same features are
> implemented in newLISP and why the CL/LISP is better?
Mike, this has already been addressed in the thread. Trying reading some
of the responses again.
You may not be aware why the claim that floating point arithmetic could
be used to calculate n! (as a substitute for true integers) was so amusing.
Here's a definition of n! in Common Lisp:
(defun ! (n) (if (zerop n) 1 (* n (! (1- n)))))
Let's calculate 19!: (! 19) => 121645100408832000
If we add 1+19! and subtract 19! we expect 1 as the result. Let's try that
out: (- (1+ (! 19)) (! 19)) => 1
Now let's compute the form using double floats:
(- (1+ (! 19d0)) (! 19d0)) => 0.0
Oops the answer is zero. Floats only have finite precision. 1 and
121645100408832000 are of too different magnitude. If I'd used single
floats then even a mere 11!=39916800 plus 1 is equal to 11!.
Wanton misuse of floating point arithmetic is terribly common. Let's see
how well Google's calculator performs with 1+19!-19!:
<http://www.google.com/search?q=1%2B19%21-19%21>
It returns a precise expression that is precisely wrong. And there's not
even a hint that floating point arithmetic was used to return the wrong
answer (0 is an integer. 0.0 or some other floating point notation would
indicate that the answer might be "imprecise").
Regards,
Adam
Adam Warner <······@consulting.net.nz> writes:
> Wanton misuse of floating point arithmetic is terribly common. Let's see
> how well Google's calculator performs with 1+19!-19!:
> <http://www.google.com/search?q=1%2B19%21-19%21>
>
> It returns a precise expression that is precisely wrong. And there's not
> even a hint that floating point arithmetic was used to return the wrong
> answer (0 is an integer. 0.0 or some other floating point notation would
> indicate that the answer might be "imprecise").
:-) The Great Home Work Flunker!
--
__Pascal Bourguignon__ http://www.informatimago.com/
Our enemies are innovative and resourceful, and so are we. They never
stop thinking about new ways to harm our country and our people, and
neither do we.
Gareth McCaughan <················@pobox.com> writes:
> [...]
> So there might be something there worth watching. But my
> overriding impression is like Matthew's: these people are
> proclaiming that their version of Lisp is New And Improved
> but showing very little sign of having looked enough at
> the allegedly Old and Creaky versions that they'd be entitled
> to make that claim. [...]
If only he had called his lisp differentLisp, we would have been
spared this discussion...
--
__Pascal Bourguignon__ http://www.informatimago.com/
Our enemies are innovative and resourceful, and so are we. They never
stop thinking about new ways to harm our country and our people, and
neither do we.