[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: [Axiom-developer] B#

From: Gabriel Dos Reis
Subject: Re: [Axiom-developer] B#
Date: 21 Nov 2005 05:49:35 +0100

"Bill Page" <address@hidden> writes:

| On November 20, 2005 8:28 PM Gaby wrote:
| > 
| > "M. Edward (Ed) Borasky" writes:
| > ... 
| > | On the other hand, if you're looking to do symbolic math, 
| > | is there any reason not to use Lisp?
| > 
| > Not a significant reason -- but Lisp's type system is not
| > what I would consider "strong" :-)
| We have mentioned before on this lisp the very good article
| about type systems in programming languages. "strong type
| checking" has several different definitions but I think most
| people would agree that Lisp is a strong dynamically typed
| language by most of these definitions.

That is interesting but the link above is confused to start with.  I

   An example of the absence of strong typing is a C cast gone wrong; if
   you cast a value in C, not only is the compiler required to allow the
   code, but the runtime is expected to allow it as well.

That is misleading at best. The core C system is consistent -- the only
trouble is that I would be in difficult position to prove it, in the
mathematical sense because I have not sense any formal definition of C
in the mathematical sense.  However, the fundamental point is that if
you make a cast, the runtime is not required to accept it if it is
semantically ill-formed. And the compiler is not required to accept it
if it can somehow determine that it is invalid.  In fact, we're seeing
more compilers taking advantages of those semantics invariants, in
terms of optimizations.

Fundamentally, the C semantics is defined for *typed* objects and the
specification is done so that it allows for "erasing" translation --
which means that runtime checking is not -required- but definitely
*allowed* to check for every operation.  Indeed, there are checking C
translators around. 

I'm not here to "defend" C -- that would be a difficult task :-) but
at least, if we're going to be picky about "strong typing", let's not
pretend C allows just about anything :-)


| > | There must be some reason nearly every successful symbolic
| > | mathematics package was at least bootstrapped from some Lisp
| > | variant!
| I wonder if that is true. Was Maple bootstrapped from Lisp?
| Was Mathematica bootstrapped from Lisp? Was MuPad bootstrapped
| from Lisp?

I took his remark as not meaning Lisp literally, but in its
"conceptual" sense -- for example, at one point I could pretend that
the C source part of GCC was written in Lisp :-)
MuPAD, Matematica implement, in their core, functionality found as
"built-in" in Lisp or variants. 


| > But in 2005, would you want to start with BOOT? 
| > [Bill, Tim, that was a joke :-)]
| > 
| Gaby, you have a strange sense of humour!

Yup, that is what my wife keeps telling me; I'm for diversity ;-)

-- Gaby

reply via email to

[Prev in Thread] Current Thread [Next in Thread]