2008-01-07
I just ran into a newsgroup post, where the redoubtable Richard J
Fateman (a well-known Mathematica hater) sullies Mathematica by
sputtering computer sciency obfuscation.
Here's the source of the message:
http://groups.google.com/group/comp.lang.lisp/msg/163eb656becfcab6?dmode=source
Newsgroups: comp.lang.lisp
From: "Richard J. Fateman" <·······@eecs.berkeley.edu>
Date: Tue, 14 Nov 2006 11:58:23 -0800
Local: Tues, Nov 14 2006 11:58 am
Subject: Re: Lisp and Scheme with fewer parentheses / Mathematica??
-----------------------------------------------
In the following, i dissect Richard's writings as a reply to that
post.
Jon Harrop wrote:
$B!V(BEverything in Mathematica is a "macro" because it is a rewrite system
so all "functions" are actually rewrite rules that map exprs to exprs
whereas functions in normal languages map values to values.$B!W(B
Richard Fateman wrote:
$B!V(B1. Rule-based transformation systems such as Mathematica are not
doing macro-expansions. Macro expansions typically map "templates for
programs" into "programs". Mathematica programmers typically define
rules (though they think of them as conventional functions for the
most part). There are lots of rule-based systems. Prolog is perhaps
most prominent today, but there were lots of expert system tools
designed over the last 20 years, and before that there were languages
like SNOBOL.$B!W(B
Give me a fucking flying break.
What Richard Fateman is doing here, is to resort to computer sciency
mumble jumble to sell his point.
In the same way, lispers can argue that there's no parenthesis in lisp
as a lisp fanatic Pascal Costanza has argued, or that lisp's $B!H(Bsort$B!I(B
doesn't destroy its argument. (These phenomenon is fashionly known in
this decade as the $B!H(BThere's no spoon$B!I(B syndrom. (how the fuck the world
has degraded, where metaphors these days are from Hollywood movies.
(fuck the tech geekers)))
Lisper morons daily swoon giddily about how their $B!H(Bmacros$B!I(B feature is
so fantastic and out-of-this-world that blows all other languages.
These lisping morons do not realize, in Mathematica, just about every
line of code is what lisper's would call macro in the full context of
the word's practical meaning and applicability, and a far more
powerful and flexible one at that. (beyond lisper's imagination,
literally.)
Now, Richard tries to bend this by saying, using a ruse constructed
out of programing language classification, that Mathematica is rule-
based. Meanwhile, throwing in dead languages like Prolog and SNOBOL in
juxtaposition, trying to give the impression that these are the same
class as Mathematica.
Consider, even Lisp is also rule based. The compiler based on a bunch
of rules to contruct machine code based on the source code. It is thus
rule based. Lisp's macro facilities, is also rule-based like
Mathematica. It is just a very primitive one.
Jon Harrop wrote:
$B!V(BEverything in Mathematica is a "macro" because it is a rewrite system
so all "functions" are actually rewrite rules that map exprs to exprs
whereas functions in normal languages map values to values.$B!W(B
Richard wrote:
$B!V(B2. I don't know what distinction you mean to make by referring to
"normal" languages, but in Lisp as well as in Mathematica, a value can
be an arbitrary symbolic expression.$B!W(B
Sure you don't, because your eargerness to belittle Mathematica
prevented you from interpreting a normal sentence in its normal sense.
Let me tell you, symbols, is also a value. Got it?
The way Jon Harrop expressed it is perfectly sensible.
Richard wrote:
$B!V(BLisp is better at issues involving scope, binding, functions, but not
so much so that a typical physicist/programmer would necessarily
notice.$B!W(B
This is the latch-on, where we can see, Richard's eagerness to sell
lisp.
Richard wrote the following moronic long paragraph:
$B!V(B3. Computer-assisted symbolic math is a special case for infix
because so many people use infix notation for non-computer-assisted
symbolic math. Unfortunately, the full scope of math notation as input
syntax is substantially missing from Mathematica, C, Python ...
Compare any of these languages to TeX. (Mathematica tries to provide
for typesetting, but mostly as output. So do other computer algebra
systems like Maple, Macsyma/Maxima, ...) The substantial failure of
infix notation outside of the realm of simple arithmetic is often
unnoticed by people who use programming languages primarily for simple
arithmetic! Pick up a symbolic logic textbook and open it up in the
middle, and see if you can figure out the syntax. It is pretty hard
because typically the infix operator " " (that is, a space) or
concatenation (that is, no space), has several meanings. In fact, in
conventional algebra, concatenation is overloaded. consider a(b+c)
vs. f(b+c) vs cos(b+c). What operation is implicit just to the left
of the (? How many meanings are there for "." in your favorite infix
language?... My belief is that an excess of infix notation is a
crutch. It certainly helps if you are weak, but hinders you if you are
pushing the limits.$B!W(B
I couldn't possibly start to dissect this rambling passage, other than
starting to write a complete standalone essay about the meaning and
semantics of notations. Luckily, i have started such a essay
previously. Please see:
$B!z(B The Concepts and Confusions of Prefix, Infix, Postfix and Fully
Functional Notations
http://xahlee.org/UnixResource_dir/writ/notations.html
$B!z(B The Codification of Mathematics
http://xahlee.org/cmaci/notation/math_codify.html
$B!z(B the TeX Pestilence
http://xahlee.org/cmaci/notation/TeX_pestilence.html
Xah
···@xahlee.org
$B-t(B http://xahlee.org/
Can you say flamebait? Also, it almost looks like you're siding with
Jon Harrop. Careful, that might turn you into a creature impenetrable
by vague, geeky concepts like "logic." But then, I fear you've already
passed the point of no return.
On Jan 8, 3:18 pm, Xah Lee <····@xahlee.org> wrote:
> 2008-01-07
>
> I just ran into a newsgroup post, where the redoubtable Richard J
> Fateman (a well-known Mathematica hater) sullies Mathematica by
> sputtering computer sciency obfuscation.
>
> Here's the source of the message:
>
> http://groups.google.com/group/comp.lang.lisp/msg/163eb656becfcab6?dm...
>
> Newsgroups: comp.lang.lisp
> From: "Richard J. Fateman" <·······@eecs.berkeley.edu>
> Date: Tue, 14 Nov 2006 11:58:23 -0800
> Local: Tues, Nov 14 2006 11:58 am
> Subject: Re: Lisp and Scheme with fewer parentheses / Mathematica??
>
> -----------------------------------------------
> In the following, i dissect Richard's writings as a reply to that
> post.
>
> Jon Harrop wrote:
>
> $B!V(BEverything in Mathematica is a "macro" because it is a rewrite system
> so all "functions" are actually rewrite rules that map exprs to exprs
> whereas functions in normal languages map values to values.$B!W(B
>
> Richard Fateman wrote:
>
> $B!V(B1. Rule-based transformation systems such as Mathematica are not
> doing macro-expansions. Macro expansions typically map "templates for
> programs" into "programs". Mathematica programmers typically define
> rules (though they think of them as conventional functions for the
> most part). There are lots of rule-based systems. Prolog is perhaps
> most prominent today, but there were lots of expert system tools
> designed over the last 20 years, and before that there were languages
> like SNOBOL.$B!W(B
>
> Give me a fucking flying break.
>
> What Richard Fateman is doing here, is to resort to computer sciency
> mumble jumble to sell his point.
>
> In the same way, lispers can argue that there's no parenthesis in lisp
> as a lisp fanatic Pascal Costanza has argued, or that lisp's $B!H(Bsort$B!I(B
> doesn't destroy its argument. (These phenomenon is fashionly known in
> this decade as the $B!H(BThere's no spoon$B!I(B syndrom. (how the fuck the world
> has degraded, where metaphors these days are from Hollywood movies.
> (fuck the tech geekers)))
>
> Lisper morons daily swoon giddily about how their $B!H(Bmacros$B!I(B feature is
> so fantastic and out-of-this-world that blows all other languages.
> These lisping morons do not realize, in Mathematica, just about every
> line of code is what lisper's would call macro in the full context of
> the word's practical meaning and applicability, and a far more
> powerful and flexible one at that. (beyond lisper's imagination,
> literally.)
>
> Now, Richard tries to bend this by saying, using a ruse constructed
> out of programing language classification, that Mathematica is rule-
> based. Meanwhile, throwing in dead languages like Prolog and SNOBOL in
> juxtaposition, trying to give the impression that these are the same
> class as Mathematica.
>
> Consider, even Lisp is also rule based. The compiler based on a bunch
> of rules to contruct machine code based on the source code. It is thus
> rule based. Lisp's macro facilities, is also rule-based like
> Mathematica. It is just a very primitive one.
>
> Jon Harrop wrote:
>
> $B!V(BEverything in Mathematica is a "macro" because it is a rewrite system
> so all "functions" are actually rewrite rules that map exprs to exprs
> whereas functions in normal languages map values to values.$B!W(B
>
> Richard wrote:
>
> $B!V(B2. I don't know what distinction you mean to make by referring to
> "normal" languages, but in Lisp as well as in Mathematica, a value can
> be an arbitrary symbolic expression.$B!W(B
>
> Sure you don't, because your eargerness to belittle Mathematica
> prevented you from interpreting a normal sentence in its normal sense.
>
> Let me tell you, symbols, is also a value. Got it?
> The way Jon Harrop expressed it is perfectly sensible.
>
> Richard wrote:
>
> $B!V(BLisp is better at issues involving scope, binding, functions, but not
> so much so that a typical physicist/programmer would necessarily
> notice.$B!W(B
>
> This is the latch-on, where we can see, Richard's eagerness to sell
> lisp.
>
> Richard wrote the following moronic long paragraph:
>
> $B!V(B3. Computer-assisted symbolic math is a special case for infix
> because so many people use infix notation for non-computer-assisted
> symbolic math. Unfortunately, the full scope of math notation as input
> syntax is substantially missing from Mathematica, C, Python ...
> Compare any of these languages to TeX. (Mathematica tries to provide
> for typesetting, but mostly as output. So do other computer algebra
> systems like Maple, Macsyma/Maxima, ...) The substantial failure of
> infix notation outside of the realm of simple arithmetic is often
> unnoticed by people who use programming languages primarily for simple
> arithmetic! Pick up a symbolic logic textbook and open it up in the
> middle, and see if you can figure out the syntax. It is pretty hard
> because typically the infix operator " " (that is, a space) or
> concatenation (that is, no space), has several meanings. In fact, in
> conventional algebra, concatenation is overloaded. consider a(b+c)
> vs. f(b+c) vs cos(b+c). What operation is implicit just to the left
> of the (? How many meanings are there for "." in your favorite infix
> language?... My belief is that an excess of infix notation is a
> crutch. It certainly helps if you are weak, but hinders you if you are
> pushing the limits.$B!W(B
>
> I couldn't possibly start to dissect this rambling passage, other than
> starting to write a complete standalone essay about the meaning and
> semantics of notations. Luckily, i have started such a essay
> previously. Please see:
>
> $B!z(B The Concepts and Confusions of Prefix, Infix, Postfix and Fully
> Functional Notations
> http://xahlee.org/UnixResource_dir/writ/notations.html
>
> $B!z(B The Codification of Mathematicshttp://xahlee.org/cmaci/notation/math_codify.html
>
> $B!z(B the TeX Pestilencehttp://xahlee.org/cmaci/notation/TeX_pestilence.html
>
> Xah
> ····@xahlee.org
> $B-t(Bhttp://xahlee.org/
In article
<····································@e25g2000prg.googlegroups.com>,
Xah Lee <···@xahlee.org> wrote:
> 2008-01-07
>
> I just ran into a newsgroup post, where the redoubtable Richard J
> Fateman (a well-known Mathematica hater) sullies Mathematica by
> sputtering computer sciency obfuscation.
>
> Here's the source of the message:
>
> http://groups.google.com/group/comp.lang.lisp/msg/163eb656becfcab6?dmode=source
You may want to read Richard's mail again and check what he is saying.
He is basically right.
Mathematica is a rule-based rewrite-system at its core.
That makes it substantially different from the evaluation
'rules' of (Common) Lisp.
http://www.lispworks.com/documentation/HyperSpec/Body/03_ab.htm
or older:
http://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node55.html#SECTION00900000000000000000
Compare that with
http://documents.wolfram.com/mathematica/book/section-2.6.1
http://documents.wolfram.com/mathematica/book/section-2.6.4
That's why I said in another posting that you need to understand
the evaluation / compilation model of Lisp.
No Rainer, you don't understand.
Try to get out of lisp mindset, and view things from general humanity.
Alternatively, imagine a alien from outer space is visiting earth. He,
being a alien, don't understand how computer scientists classifed
languages here, nor anything about our hardware such as silicon cpu
and $B!H(Bmemories$B!I(B etc. He, being advanced alien, we assume he understands
advanced mathematics far beyond us. In particular, 1+1 is still 2 for
him, and any implications.
Now, will this Alien, buy your stuff about how lisp is this and that?
Also, let's be explicit about what we are arguing here, even in
general there is no clearly defined or focus of a newsgroup
argumentation. But, roughly, in our context, the argument is about,
whether, is it reasonable, to say that programing in mathematica is
analogous to a far more powerful system of lisp's macros.
Now, if you agree that this is the subject as i phrased it, then, i
think you either don't have opion, or, you agree with me. Further, i
argue, that this phrase, is a reasonable interpretation where the
thread is from, more specifically, it is a reasonable interpretation
of what Jon Harrop said, of which Richard Fateman retorts.
Now, if you don't agree that the subject is as i phrased it, then, you
can rephrase it, or explicitly define a subject that we would argue
about. Then, i, or others, can voice our opinion. (or not)
Xah
···@xahlee.org
$B-t(B http://xahlee.org/
On Jan 8, 1:50 pm, Rainer Joswig <······@lisp.de> wrote:
> In article
> <····································@e25g2000prg.googlegroups.com>,
> Xah Lee <····@xahlee.org> wrote:
>
> > 2008-01-07
>
> > I just ran into a newsgroup post, where the redoubtable Richard J
> > Fateman (a well-known Mathematica hater) sullies Mathematica by
> > sputtering computer sciency obfuscation.
>
> > Here's the source of the message:
>
> >http://groups.google.com/group/comp.lang.lisp/msg/163eb656becfcab6?dm...
>
> You may want to read Richard's mail again and check what he is saying.
>
> He is basically right.
>
> Mathematica is a rule-based rewrite-system at its core.
> That makes it substantially different from the evaluation
> 'rules' of (Common) Lisp.
>
> http://www.lispworks.com/documentation/HyperSpec/Body/03_ab.htm
>
> or older:
>
> http://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node55.html#SECTION0090...
>
> Compare that with
>
> http://documents.wolfram.com/mathematica/book/section-2.6.1
> http://documents.wolfram.com/mathematica/book/section-2.6.4
>
> That's why I said in another posting that you need to understand
> the evaluation / compilation model of Lisp.
On Tue, 8 Jan 2008 14:39:33 -0800 (PST), Xah Lee <···@xahlee.org>
wrote:
>No Rainer, you don't understand.
>
>Try to get out of lisp mindset, and view things from general humanity.
>
>Alternatively, imagine a alien from outer space is visiting earth. He,
>being a alien, don't understand how computer scientists classifed
>languages here, nor anything about our hardware such as silicon cpu
>and ?memories? etc. He, being advanced alien, we assume he understands
>advanced mathematics far beyond us. In particular, 1+1 is still 2 for
>him, and any implications.
>
>Now, will this Alien, buy your stuff about how lisp is this and that?
It doesn't matter. Regardless of what "mathematics" the alien may or
may not understand itself, it still will not understand the meaning of
"1+1" or "2" because it will not be able to identify the symbolism.
And because you were vaporized in a cultural misunderstanding while
trying to show it Mathematica, you will not be there to explain
things.
Humans (aside from you) think remarkably alike and that allows us to
establish basis for communication in the absence of common language.
Psychologists refer to this phenomenon variously as the "Gestalt" or
the "collective unconscious". The alien, having evolved elsewhere,
may think in an entirely differently way and there may be no basis
whatsoever for communication with it.
It's mathematically impossible for life not to exist elsewhere in the
universe. The hypothesis that some of that life might be intelligent
is based on the facts that it has not tried to contact us.
George
--
for email reply remove "/" from address
In article
<····································@q39g2000hsf.googlegroups.com>,
Xah Lee <···@xahlee.org> wrote:
> No Rainer, you don't understand.
>
> Try to get out of lisp mindset, and view things from general humanity.
>
> Alternatively, imagine a alien from outer space is visiting earth. He,
> being a alien, don't understand how computer scientists classifed
> languages here, nor anything about our hardware such as silicon cpu
> and $B!H(Bmemories$B!I(B etc. He, being advanced alien, we assume he understands
> advanced mathematics far beyond us. In particular, 1+1 is still 2 for
> him, and any implications.
>
> Now, will this Alien, buy your stuff about how lisp is this and that?
Could be.
> Also, let's be explicit about what we are arguing here, even in
> general there is no clearly defined or focus of a newsgroup
> argumentation. But, roughly, in our context, the argument is about,
> whether, is it reasonable, to say that programing in mathematica is
> analogous to a far more powerful system of lisp's macros.
I don't think Lisp macros are more 'powerful'. Mathematica
(the language and its implementation) works a bit differently.
In some ways you could say that Mathematica is more
powerful (since it transforms expressions by rewrite rules) and
more 'high-level'. There are some similarities to Lisp,
but the core 'evaluation' model is different.
Let me try to describe the main difference:
* Lisp evaluates functions to values or executes special forms.
Macros do source transformation before the code
gets executed (the created code is then executed).
* Mathematica applies transformations to data
as long as their are applicable transformations.
Lisp has a 'simpler' and more straight forward model evaluation model.
Even Common Lisp. That also has some advantages.
Lisp has a 'Functional' core. Mathematica has a 'rule-based
rewrite engine' at its core. This allows Mathematica to easily
do symbolic manipulations like you see in computer algebra
systems.
In Lisp you need to extend the basic system to do that. The
infrastructure is there. This infrastructure has been designed
such these kind of systems can be 'relatively' easily
be written. So Lisp is a bit more low-level than Mathematica.
Lisp has been used to write systems that work in some ways 'similar'
to Mathematica. Examples are Macsyma, Reduce, Axiom.
If you look at Macsyma, you can easily see where the evaluation
model of Lisp has been extended to manipulate symbolic
expressions (like mathematical formulas). Lisp's role
is more to be a straight-forward implementation language
for systems and languages like Mathematica.
There is one part of Common Lisp that I would think
is also 'high-level' - that is CLOS. The rest is low- to mid-level.
So, coming back to your Subject
'Lisp and Scheme with fewer parentheses / Mathematica??'
No, Lisp and Scheme are sufficiently different from Mathematica
in the way how they do computation, that Mathematica is not
a Lisp with fewer parentheses. Lisp, the language, is in some
ways more low-level.
Lisp with fewer parentheses would be more like Logo or
Dylan. Especially the latter.
>
> Now, if you agree that this is the subject as i phrased it, then, i
> think you either don't have opion, or, you agree with me. Further, i
> argue, that this phrase, is a reasonable interpretation where the
> thread is from, more specifically, it is a reasonable interpretation
> of what Jon Harrop said, of which Richard Fateman retorts.
>
> Now, if you don't agree that the subject is as i phrased it, then, you
> can rephrase it, or explicitly define a subject that we would argue
> about. Then, i, or others, can voice our opinion. (or not)
>
> Xah
> ···@xahlee.org
> ? http://xahlee.org/
>
> On Jan 8, 1:50 pm, Rainer Joswig <······@lisp.de> wrote:
> > In article
> > <····································@e25g2000prg.googlegroups.com>,
> > Xah Lee <····@xahlee.org> wrote:
> >
> > > 2008-01-07
> >
> > > I just ran into a newsgroup post, where the redoubtable Richard J
> > > Fateman (a well-known Mathematica hater) sullies Mathematica by
> > > sputtering computer sciency obfuscation.
> >
> > > Here's the source of the message:
> >
> > >http://groups.google.com/group/comp.lang.lisp/msg/163eb656becfcab6?dm...
> >
> > You may want to read Richard's mail again and check what he is saying.
> >
> > He is basically right.
> >
> > Mathematica is a rule-based rewrite-system at its core.
> > That makes it substantially different from the evaluation
> > 'rules' of (Common) Lisp.
> >
> > http://www.lispworks.com/documentation/HyperSpec/Body/03_ab.htm
> >
> > or older:
> >
> > http://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node55.html#SECTION0090...
> >
> > Compare that with
> >
> > http://documents.wolfram.com/mathematica/book/section-2.6.1
> > http://documents.wolfram.com/mathematica/book/section-2.6.4
> >
> > That's why I said in another posting that you need to understand
> > the evaluation / compilation model of Lisp.
Dear Rainer,
Any dummy, at our level, knew that Mathematica and lisp have different
evalutaion models or computational models. (the $B!H(Bat our level$B!I(B, means
us, who have years of experience with one or more $B!H(Bfringe$B!I(B, functional
programing languages. Of course, if you ask a average industrial
programer, even with say 10 years of programing experience, chances
are, they wouldn't know what the fuck is a rule-based system or lisp
macros)
So, of course i'm not arguing that lisp and Mathematica have the same
evaluation models. I'm saying, as well as Jon is saying, that
programing in Mathematica is like in sense a glorified (or extened)
macros system as used in lisp. In fact, one might argue, that the
concept of so-called rule-based system or term-rewritting is developed
from lisp. (after all, it is almost the case that any advanced
functional programing concepts has origin or trace of origin from
lisp, because after all, lisp is for all practical purposes the first
functional language and one of the oldest language)
Now, what you might be arguing, is that it is not reasonable to say
programing mathematica is akin to programing with a advanced macros
system because they are different evalution models (more generally,
differente computational models). But this is like picking spellings
or drilling technicalities. To illustrate my point, if i say lisp's
list is far more powerful than Perl's, then the perl fuckheads will
argue that no, because Perl has list and array, which is entirely
different beast than lisp's cons cells model.
So, in your previous message, there is really nothing i disagree in
any technical sense. In fact, your admission that Mathematica is in
general higher-level than lisp, is all really me and perhaps Jon was
trying to make.
Now, this does not mean, Mathematica is better than lisp in all
aspects. Of course, Mathematica's high-level-ness, its ability to
computer thousands of advanced mathematical functions and equations,
its pattern matching, list manipulation power, is all good. And, don't
get me wrong: Mathematica is not a niche computer-algebra-only
language. However, there are certainly many things mathematica cannot
do and is not suitable to do as compared to lisp. For example, you
can't really do much of network programing with Mathematica (e.g.
writing a web application, networked file system, or ssh client,
etc.). You can't really use Mathematica to program GUI applications in
the general sense. (i.e. write a X-windows window manager, or write a
web browser) And, due to M's high-level-ness, it is also not suitable
to, say, to use it to write a OS device driver. (note: Mathematica has
WebMathematica that function as a general web-application framework,
and GridMathematica that functions as general parallel computing
system, and the Mathematica Kernel with its MathLink protocol allows
several general extension and programing with it in diverse areas)
In short, Mathematica's supreme high-level-ness is not a lisp killer.
Meanwhile, the fact it is higher-level than lisp, and in many ways
practically similiar to lisp, should not be dimsissed or bent out of
shape by that Richard Fateman or any Common Lisper.
PS It is not correct to say that Mathematica relies on pattern
matching or term-rewriting as its core computational model. Because,
in Mathematica, there are pure function $B!H(BFunction$B!I(B (lambda) construct,
as well as many imperative language constructs that cannot be
explained by pattern matching. (a simple example: $B!H(Bx++$B!I(B or the
syntactically equivalent $B!H(BIncrement[x]$B!I(B) In fact, it is not possible
to write any non-trivial programs in Mathematica by using only pattern
matching. In my over a decade programing with Mathematica (mostly
active in the 1990s, i actually avoid pattern matching, for reasons
that in general pattern matching is somewhat unpredictable, and code
based on it is not so portable since other langs don't have it.)
Xah
···@xahlee.org
$B-t(B http://xahlee.org/
On Jan 8, 3:31 pm, Rainer Joswig <······@lisp.de> wrote:
> In article
> <····································@q39g2000hsf.googlegroups.com>,
> XahLee<····@xahlee.org> wrote:
>
> > No Rainer, you don't understand.
>
> > Try to get out of lisp mindset, and view things from general humanity.
>
> > Alternatively, imagine a alien from outer space is visiting earth. He,
> > being a alien, don't understand how computer scientists classifed
> > languages here, nor anything about our hardware such as silicon cpu
> > and $B!H(Bmemories$B!I(B etc. He, being advanced alien, we assume he understands
> > advanced mathematics far beyond us. In particular, 1+1 is still 2 for
> > him, and any implications.
>
> > Now, will this Alien, buy your stuff about how lisp is this and that?
>
> Could be.
>
> > Also, let's be explicit about what we are arguing here, even in
> > general there is no clearly defined or focus of a newsgroup
> > argumentation. But, roughly, in our context, the argument is about,
> > whether, is it reasonable, to say that programing in mathematica is
> > analogous to a far more powerful system of lisp's macros.
>
> I don't think Lisp macros are more 'powerful'. Mathematica
> (the language and its implementation) works a bit differently.
> In some ways you could say that Mathematica is more
> powerful (since it transforms expressions by rewrite rules) and
> more 'high-level'. There are some similarities to Lisp,
> but the core 'evaluation' model is different.
>
> Let me try to describe the main difference:
>
> * Lisp evaluates functions to values or executes special forms.
> Macros do source transformation before the code
> gets executed (the created code is then executed).
>
> * Mathematica applies transformations to data
> as long as their are applicable transformations.
>
> Lisp has a 'simpler' and more straight forward model evaluation model.
> Even Common Lisp. That also has some advantages.
> Lisp has a 'Functional' core. Mathematica has a 'rule-based
> rewrite engine' at its core. This allows Mathematica to easily
> do symbolic manipulations like you see in computer algebra
> systems.
>
> In Lisp you need to extend the basic system to do that. The
> infrastructure is there. This infrastructure has been designed
> such these kind of systems can be 'relatively' easily
> be written. So Lisp is a bit more low-level than Mathematica.
> Lisp has been used to write systems that work in some ways 'similar'
> to Mathematica. Examples are Macsyma, Reduce, Axiom.
> If you look at Macsyma, you can easily see where the evaluation
> model of Lisp has been extended to manipulate symbolic
> expressions (like mathematical formulas). Lisp's role
> is more to be a straight-forward implementation language
> for systems and languages like Mathematica.
>
> There is one part of Common Lisp that I would think
> is also 'high-level' - that is CLOS. The rest is low- to mid-level.
>
> So, coming back to your Subject
> 'Lisp and Scheme with fewer parentheses / Mathematica??'
>
> No, Lisp and Scheme are sufficiently different from Mathematica
> in the way how they do computation, that Mathematica is not
> a Lisp with fewer parentheses. Lisp, the language, is in some
> ways more low-level.
>
> Lisp with fewer parentheses would be more like Logo or
> Dylan. Especially the latter.
>
>
>
> > Now, if you agree that this is the subject as i phrased it, then, i
> > think you either don't have opion, or, you agree with me. Further, i
> > argue, that this phrase, is a reasonable interpretation where the
> > thread is from, more specifically, it is a reasonable interpretation
> > of what Jon Harrop said, of which Richard Fateman retorts.
>
> > Now, if you don't agree that the subject is as i phrased it, then, you
> > can rephrase it, or explicitly define a subject that we would argue
> > about. Then, i, or others, can voice our opinion. (or not)
>
> > Xah
> > ····@xahlee.org
> > ?http://xahlee.org/
>
> > On Jan 8, 1:50 pm, Rainer Joswig <······@lisp.de> wrote:
> > > In article
> > > <····································@e25g2000prg.googlegroups.com>,
> > > XahLee<····@xahlee.org> wrote:
>
> > > > 2008-01-07
>
> > > > I just ran into a newsgroup post, where the redoubtable Richard J
> > > > Fateman (a well-known Mathematica hater) sullies Mathematica by
> > > > sputtering computer sciency obfuscation.
>
> > > > Here's the source of the message:
>
> > > >http://groups.google.com/group/comp.lang.lisp/msg/163eb656becfcab6?dm...
>
> > > You may want to read Richard's mail again and check what he is saying.
>
> > > He is basically right.
>
> > > Mathematica is a rule-based rewrite-system at its core.
> > > That makes it substantially different from the evaluation
> > > 'rules' of (Common) Lisp.
>
> > > http://www.lispworks.com/documentation/HyperSpec/Body/03_ab.htm
>
> > > or older:
>
> > > http://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node55.html#SECTION0090...
>
> > > Compare that with
>
> > > http://documents.wolfram.com/mathematica/book/section-2.6.1
> > > http://documents.wolfram.com/mathematica/book/section-2.6.4
>
> > > That's why I said in another posting that you need to understand
> > > the evaluation / compilation model of Lisp.
The discussion is interesting, don't blame neither Xah L. nor Richard F. for their extreme
opinions. Mathematica is *interesting* for the Lisp community, it is perhaps - for now - the
most advanced Lisp-like language. I can understand the opinion that a rewrite system is
*perceived* from the programmer's point of vue as a macro expansion, even if it is
not actually...
The best thing which could happen is that the core language of Mathematica, without
math librairies, is placed in the public domain. This idea was in the air some years
ago, don't remember exactly, but was abandonned by Wolfram Research. They missed
a point, this language could have been a killer, when augmented with general capabilities
such as network or GUI programming. Steven, come on, give us your baby ! You will make
money with the maths...
Or at least show us a meta circular Mathematica interpreter :-)
-JG
Jean Guillaume Pyraksos wrote:
> The discussion is interesting, don't blame neither Xah L. nor Richard F.
> for their extreme opinions. Mathematica is *interesting* for the Lisp
> community, it is perhaps - for now - the most advanced Lisp-like language.
> I can understand the opinion that a rewrite system is *perceived* from the
> programmer's point of vue as a macro expansion, even if it is not
> actually... The best thing which could happen is that the core language of
> Mathematica, without math librairies, is placed in the public domain. This
> idea was in the air some years ago, don't remember exactly, but was
> abandonned by Wolfram Research. They missed a point, this language could
> have been a killer, when augmented with general capabilities such as
> network or GUI programming. Steven, come on, give us your baby ! You will
> make money with the maths...
>
> Or at least show us a meta circular Mathematica interpreter :-)
Richard Fateman and I already did that and I'm quite sure others will do it
again. However, although Mathematica is superb for its niche of symbolic
and numerical technical computing, the Mathematica language itself is
grossly inadequate for real software development. For example, it doesn't
even have an expressive static type checker.
--
Dr Jon D Harrop, Flying Frog Consultancy Ltd.
http://www.ffconsultancy.com/products/?u
In article <···············@corp.supernews.com>,
Jon Harrop <······@jdh30.plus.com> wrote:
> Or at least show us a meta circular Mathematica interpreter :-)
>
> Richard Fateman and I already did that and I'm quite sure others will do it
> again.
Actually ? A Mathematica interpreter written in Mathematica (not in Lisp) ?
Please give me the links !...
-JG
Xah Lee wrote:
> So, of course i'm not arguing that lisp and Mathematica have the same
> evaluation models. I'm saying, as well as Jon is saying, that
> programing in Mathematica is like in sense a glorified (or extened)
> macros system as used in lisp.
Exactly.
> In fact, one might argue, that the
> concept of so-called rule-based system or term-rewritting is developed
> from lisp. (after all, it is almost the case that any advanced
> functional programing concepts has origin or trace of origin from
> lisp, because after all, lisp is for all practical purposes the first
> functional language and one of the oldest language)
Actually I would argue the opposite. Term rewriting is fundamental to
mathematics and predates Lisp and even the lambda calculus by hundreds if
not thousands of years.
> PS It is not correct to say that Mathematica relies on pattern
> matching or term-rewriting as its core computational model. Because,
> in Mathematica, there are pure function ?Function? (lambda) construct,
> as well as many imperative language constructs that cannot be
> explained by pattern matching.
You might not be able to get far using pattern matching alone but you can
implement virtually everything using only term rewriting. This is exactly
how I bootstrapped my Mathematica JIT compiler in OCaml.
> (a simple example: ?x++? or the
> syntactically equivalent ?Increment[x]?) In fact, it is not possible
> to write any non-trivial programs in Mathematica by using only pattern
> matching. In my over a decade programing with Mathematica (mostly
> active in the 1990s, i actually avoid pattern matching, for reasons
> that in general pattern matching is somewhat unpredictable, and code
> based on it is not so portable since other langs don't have it.)
Yes. One of the practical problems with Mathematica's pattern matching is
that it goes well beyond the linear patterns of ML and allows patterns to
have arbitrarily high asymptotic complexities. Consequently, the complexity
of almost any non-trivial pattern match is undefined.
--
Dr Jon D Harrop, Flying Frog Consultancy Ltd.
http://www.ffconsultancy.com/products/?u
Jon Harrop wrote:
$B!V(B... Term rewriting is fundamental to mathematics and predates Lisp
and even the lambda calculus by hundreds if not thousands of years.$B!W(B
The so-called term-rewriting, and as well as lambda calculus, in the
form and shape we understand these words today, are pretty much only
developed in predominantly 1900s. They are parts of modern
investigation on logic. (which is primarily spurred as a investigation
on the foundation of mathematics)
The concept of term rewriting can be further pushed back to David
Hilbert (1862-1943)'s formalism: the idea that mathematics is just a
meaningless transformation of symbols.
They could be traced further back, but that would be more like tracing
history of logic, as far back to the ancient Greeks, or ancient
Chinese mohism.
Xah
···@xahlee.org
$B-t(B http://xahlee.org/