[Top][All Lists]

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

Re: [Axiom-developer] Re: SPAD and Aldor again

From: Antoine Hersen
Subject: Re: [Axiom-developer] Re: SPAD and Aldor again
Date: Tue, 21 Nov 2006 02:32:54 -0800


My personal experience with Aldor/Axiom Aldor/Algebra, is that
everything that is a bit complicated tend to break miserably. Not only
Aldor Axiom incomparability, but Aldor with libAlgebra.

The compiler is broken, optimization break semantic, some code will
work in O1 not in O2 and vice versa, O3 and O4 can make for some very
efficient optimization that just decide that you code is better left
un executed, faster indeed.
Also seen : incorrect biding of variable, this one was a joy to debug(
Ralf catch it thanks)

I just had a glance at the Aldor source code and no salvation will
come from having it release I guaranty, just a lot of old and lightly
documented C code.

My experience with Aldor is that it obey the principle of maximum
surprise and minimum code productivity.
But it made me happy to code in PPC assembler again, at least the
semantic is clear and debugging is a bliss.

To be honest most of my difficult come from the fact that I am used to
code in ML and I have a functional style that Axiom does not support
really well, anonymous function, and curry style function definition
are a sure way to break stuff.

I personally will not try to implement any new math in Axiom, till the
compiler is in better shape. The good news is that I do believe in the
underlying approach and that being a Comp Sci grad student I might
even be able to do something about it.

Since time to hope for Aldor release has pass, I agree that we should
concentrate on SPAD+,++,prime,#,2006.

I think that Aldor backward combability is not important, since we do
not have libAlgebra or SumIT.
LibAlgebra has tones of copyright in it, from a lot of institution and
individuals. Also merging it with axiom algebra will be quite
difficult. My exploration of the multivariate polynomials
implementation make me believe that libAlgebra is nicer but the
documentation is quite out of sync and a lot is missing.
I never seen SumIT so cant say.

I think the language need to be clearly defined, maybe not a complete
semantic a la SML but at least something precise like the Haskell
We need to be able to decide if it is sound enough and co.

From a theoretical aspect of SPAD', dependent type seem a must to
accommodate the problem of doing a descent job at representing
But there is dependent type and dependent type, I am in the process of
getting informed about it I got my hand on Pierce thank to inter
library loans, and I am having a look at epigram which I believe is
the only language alive that is implementing depend type.

I would like SPAD' to have a more functional flavor to it( personal taste)

Good news with depend type no need for polymorphisms or GADT !!!

Algebraic type will be great !!! but I guess we will also need pattern
matching to make good use of them.

Also some type inference( I dont mean auto coercion) will be helpful.

For the monoid problem I guess we need something like chapter 6 of
Nicolas Doye PhD thesis.

Also should coercion have a special semantic ?

What to do about Rep ? I dont like it at all, why cant I have
arbitrary number of instance variables named like I want.

I am personally worried about the current :
(that is broken in Aldor and required the horrible "pretend" aka cast)

"if xValue has someSubtype then
        ADT signature extention"

Can we do that in the SML module system with functors ? I should know this :(
( I think I have read that with dependent type we get SML module for free )

Also we have it as control flow in function definition.
"if xValue has someSubtype then"

what about :

"if someType has someSubType then" ?

What are the valuable lesson from SML module system, Haskell type
class, and C++ template  we can use ?

I know there is some effort to improve C++ template system, I guess
Gabriel is quite informed on the subject ?

Should we incorporate axioms for our far away dream of proof checking ?
Before having a proof we could use them for QuickCheck like testing
without too much work.

On a practical point of view.
For me the highest importance will be good error messages during
compilation and possibility of debugging after.
I remember to be quite frighten by SPAD error messages, this being the
reason I switched to Aldor.

I know that compiler book are more interested in advanced optimization
method than good error messages but my own experience in developing a
toy ML language to assembler compiler in Haskell is that monads make
it almost easy, I guess Ocaml error system should make it manageable

I think speed is not important, modern computer are so fast and have
so much memory.( And if we are to plan for speed automatic parallelism
seem the direction of the future but SPAD heavy use of reference will
make it difficult, mabe == should be the rule and := the exception )

FOAM is dead since Axiom doest no understand it.
We still need some intermediary representation, maybe simply lisp.
(Is getting rid of boot still on the agenda ?)

Also I feel that depend type will ask a lot from the runtime system to
do some late type checking.

We do need a FFI interface in the language in someway, maybe Lisp
should provide it but it should be apparent in SPAD'. We should be
able to use
I dont personal feel the need for FORTRAN by I understand why it will
be important for a CAS.
Having a C interface is of course primordial.

On the syntax side, I am not very found of indentation based syntax,
it work without trouble with haskell and python because they have good
emacs mode but that alway gave me trouble in SPAS, can we have both(
indentation and bracket) like Haskell ? So no need for an holy war.

I guess language design is quite difficult and it is important to know
what kind of problems we need to solve.

My keys test problems will be multivariate polynomials, ore
polynomials, a graph library( data and algebraic), combinat and a
plotting library. I think that it has to be possible to create an
elegant implementation in SPAD' to those problems.

I am motivated, who want a PhD student ?

Antoine Hersen


reply via email to

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