>>>>> "Graham" == Graham Matthews <firstname.lastname@example.org> writes:
Daniel Wang wrote:
>> I think there is a real important difference between a "scripting"
>> and "systems programming" languages. "scripting" languages are
>> designed to let you *manipulate* a certain set of *fixed*
>> abstractions easily. "System languages" are desgined to let you
>> *create* new abstractions.
Graham> But the point is that a language (eg.Lisp) can do both -- ie:
Graham> let you manipulate the provided abstractions, and let you create
Graham> new ones.
But it doesn't provide any special builtin pre-packaged support for
manipulating a specific set of abstractions. (Special syntax for example)
It's designed to let you build your own. In any case I'm not claiming this
is a hard distinction. Just that Lisp is not designed to be like Perl5 or
vice versa, and that the design tradeoffs that Lisp and Perl5 make are
different because one has a "scripting" philosophy while the other a more
Graham> Sorry but you have fallen for the warped Mathematica
Graham> mind-set. Lets say I have a polynomial whose coefficients are
Graham> "just numbers in the most abstract sense". Now I ask for this
Graham> polynomial to be factorised. The exact factorisation you get
Graham> depends on the precise types of those "abstract numbers" -- a
Graham> polynomial can factor over the complex numbers, but NOT over say
Graham> the real numbers, or the integers. Exactly how and whether the
Graham> polynomial factors depends on the precise type of the
Graham> numbers. This Mathematica line that everything is "just abstract
Graham> numbers" is baloney. What Mathematica actually assumes (by
Graham> default) is that everything is a complex number.
And in most cases if I want integer or real solution and Mathematica returns
a complex factoriziation I know there aren't any real or integer
solutions. The point being it's not worth my trouble to annotate the type of
each variable in this any many situations. In cases where I really care
Mathematica has factorization functions specified for specific types. You're
missing the point that in some situations when you have sufficently abstract
objects a type system isn't worth it. This is why Lisp doesn't have a type
system, even though I think it could really use it.