[Top][All Lists]

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

Re: [Axiom-developer] Roadmap

From: Tim Daly
Subject: Re: [Axiom-developer] Roadmap
Date: Thu, 21 Jul 2016 05:24:50 -0400

I've been trolling my wife's cookbooks.
There I find basic ingredients (e.g. make batter, making
eggs), main dishes (steak), and 7-course means (how to
choose side dishes, wines, etc). The 'cake' section, for
example, has option "subroutines" such as toppings.

The idea would be to develop a cookbook-style of presentation
for computational mathematics. Pick an algorithm, write a page.
When something is used that is not explained, there is a reference
to other sections (ala cakes that suggest "see the frostings")

Each entry would be an algorithm or idea, explained in at most one
2-sided loose-leaf paper. The algorithms would be gathered into
sections, e.g. "basic ingredients" like resultant, "main dishes"
like polynomial factorization, and "7-course meals" like solving
the heat equation (target is the physics class). The 'cake'
subroutines would involve choice of polynomial representation,
sparse, dense, distributed, recursive, etc.

I want to be able to "write in the small" (1 page) with a focus on
a single subject but "organize in the large" so I can shuffle these
subjects into groups by purpose. The analogy is that my wife has
a cookbook that only deals with pickles. I'd like a cookbook that
only deals with rings, composed of loose-leaf selections from the
overall collection. This would be assembled for a computational
mathematics class. The same material could be re-arranged and
re-selected for a different class.

The key focus is on providing explanation and motivation. Most
books that mention the resultant spend pages on the proof and
not a word about why or where to use it.

The 1 page / 2 sides focus is much easier to write than a whole
chapter and, since you're staring at a single routine, it is easier
to provide motivation for why it exists and what the tradeoffs are.
"How" is interesting but "Why" is vital.

I've drafted a 0th cut at the idea. See

The explanation/motivation section will be written tomorrow,
actually later today (it's 5:20am).

On Thu, Jul 21, 2016 at 4:56 AM, Andrew Tonks <address@hidden> wrote:
I have deadlines coming out of my ears, but I'll do what I can!  What's the best way to start?
PS: did you read the slides from Stein last month?

On 21 July 2016 at 01:11, Tim Daly <address@hidden> wrote:
>I've been checking the progress of axiom over the years,
somewhat despondently, I probably even installed it 3 or 4
years ago but didn't spend enough time looking at it. Sagemath
has taken over maybe. But I'd be very interested if there is an
updated roadmap or research project in preparation somewhere.

I'm trying hard to make Axiom live.

You'll notice that of the many (I made a CD with over 100)
dozens of CAS started in the 1970-2000s, only Mathematica,
Maple, and Axiom (of the big systems) still seem to be maintained.

Macsyma died when Symbolic died (although you can still run it on
DOS). Maxima, the FOSS version, has not been changed since

Symbolics Macsyma is what worries me the most. A LOT of
computational mathematicians depend on Mathematica and Maple.
But companies, like Symbolics, die (average less than 15 years).

Maplesoft died (it was bought by a Japanese firm, fortunately).
Soft Warehouse (Derive) died. TI bought it and makes calculators.

What happens when Wolfram goes out of business? Mathematica
can't be given away as software is now considered a "hard asset",
which means it would have to be sold to someone.

If (when?) Maple and Mathematica get withdrawn from the market,
what will become of computational mathematics? What happens
when your code will no longer run?

Open Source is not a solution. Maxima is open source but the only
changes seem to be in autoconf to keep it running. There is no
active development at all.

FOSS projects die when their founders stop working on them.
One of the key reasons is that software is written in tiny files
(as if it had to run on a PDP-11), and stacked up into piles like
sand. This pile-of-sand (POS) approach makes it really hard to
get into an existing project, especially one the size of Axiom
(1.2 million lines of code).

I'm trying to get Axiom to the point where it can be maintained,
modified, and extended by new people. To that end, I've spent
a lot of time converting the system, using Knuth's Literate
Programming idea. The hope is that people will be able to
I want to add your code to the system but I also want to use
your paper (with attribution, of course) to explain the code so
others "have a clue". The raw code is completely opaque.

So, in the near term, the "roadmap" is to try to relate the code
to the literature. I'm trolling the world for Axiom references,
building a bibliography, and connecting the ideas and papers
to the existing code.

I'm asking people to write simple introductions
to their areas of expertise with a focus on Axiom (e.g. James
Davenport just wrote 2 chapters in Volume 2). Feel free to
explain simplical and cubical groups at a beginner level, e.g.
why and where you might find/use them and what are some
basic concepts needed as background.

I find that computational mathematicians know WHY they
use resultants, chinese remainders, lifting and other ideas.
These don't seem to be common knowledge. I'm trying to
change that so the code doesn't look like magic.

As for research, I'm doing my own (proving Axiom correct)
but nobody cares :-)



Dr Andrew Tonks

Department of Mathematics, University of Leicester, 
University Road, Leicester, LE1 7RH, UK

0116 252 3881


reply via email to

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