2008-01-22

I've been programing mathematica since 1993, worked as intern at
Wolfram Research Inc in 1995. And since have been coding Mathematica
daily up to 1998, and on and off since then.

I started to learn emacs in around 1997, and use it daily, about 8
hours a day, ever since and still today.

I started to learn lisp in about 1997. Mostly, i red word-for-word, 3
chapters of the book Structure And Interpretation Of Computer Programs
by Harold Abelson et al. (out of 5 chapters total) And, i have read
maybe half of the Scheme lisp spec “Revised(4) Report on the
Algorithmic Language Scheme”. These are all during 1997-1998. However,
at the time i've never really wrote any programs in lisp other than
toy factorial function.

In 2005, i started to casually learn emacs lisp. Because i use emacs
extensively and daily since 1998, thus emacs lisp is quite practical
for me, and i have kept learning it and in fact have wrote quite a few
small scale, but nevertheless practical, programs. (typically less
than a thousand lines of code; for text processing tasks)

--------------

Xah Lee wrote:

No, "List[1,2,3]" is just a couple of black pixels on the screen.

Pascal

--
1st European Lisp Symposium (ELS'08)
http://prog.vub.ac.be/~pcostanza/els08/

My website: http://p-cos.net
Common Lisp Document Repository: http://cdr.eurolisp.org
Closer to MOP & ContextL: http://common-lisp.net/project/closer/

Pascal Costanza p-cos.net> writes:

Are you sure? They appear in a subdued white on mine.

Regards,

Patrick

On Jan 22, 4:50 am, Xah Lee xahlee.org> wrote:
[...]

This is a *strength* of Lisp over Mathematica. M'ca's underlying list
representation is actually a vector, which means that pushing items
onto the front of a list is quite expensive. A lot of the time M'ca
programs end up using two-element "lists" as conses, giving you
results like:

{a[1], {a[2], {a[3], ...}}}

and you have to gratuitously flatten everything when you're done. It's
just plain annoying.

On Jan 22, 6:58 am, Pascal Costanza p-cos.net> wrote:

While I won't make a stand for or against constructor style output of
objects, their use is important in the /design/ of programs. Consider,
for instance, the typical Fibonacci definition:

fib(0) = 0
fib(1) = 1
fib(n) = fib(n-1) + fib(n-2)

A key to understanding the inefficiency of the naive recursive
implementation is seeing the repeated computation:

Because usually the argument is not a literal, but an s-expression
that needs to be evaluated to produce the list.

2008-01-22

sometimes its quite frustrating when discussing things in newsgroups.

As most know, newsgroups discussions are characterized by ignorance,
massive confusion, one-upmanship, and in general a showcase of the
loniness of the tech geekers in technological societies ...

but in this particular thread, a contributing factor is that most
people don't know Mathematica to the degree that nobody ever seen one
single line of code in Mathematica, and of the very few who have
actually used Mathematica (maybe in their school days in the computer
lab), most don't have the basic knowledge of programing it.
(Mathematica 6 sells for over 2 thousands dollars i think (check their
web to be sure), and before that version, it's over one thousand
dollars, and i guess it is sold perhaps 10 or hundreds times than
lisps sold by all lisp companies combined)

Xah Lee wrote:

...maciej made me snip this....

In article
v46g2000hsv.googlegroups.com>,
Xah Lee xahlee.org> wrote:

...

I think you are seriously confused when it comes to programming
language models. Don't take that offensive, just as a recommendation
to clear up basic things like: 'expression', 'object', 'process',
'interpretation'. Part of that may come from that Mathematica only
has a weak specification of the core programming language.

Ken Tilton wrote:

I'm not a Mathematica expert, but sometimes it is useful for solving
equations etc. If you hit F1 on "List" in Mathematic, the help screen says:

| Lists are very general objects that represent collections of expressions.

This means, Mathematica has objects and a list is an object. And you can
modify lists in Mathematica, without modifying other lists with the same
elements, which would be really strange. Functional languages like Haskell
doesn't allow to modify lists (with some exceptions and internally some
operations may be implemented in an efficient modifying way), which makes
it easier to write more bug-free code, if you think long enough to find a
good functional solution, which is more difficult for me sometimes than
writing a non-functional solution.

A Mathematica notebook:

In[1]:=x=List[4,5,6]
Out[1]={4,5,6}