[Top][All Lists]

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

[Axiom-developer] new "projects" file

From: daly
Subject: [Axiom-developer] new "projects" file
Date: Wed, 26 Nov 2014 04:55:13 -0600

Axiom is being developed on a very wide range of topics.
Due to the range of topics and the available manpower the
development is slow but steady in many areas.

There has been, and continue to be, changes made in Axiom for each of
these areas.

In order to communicate better (that being the whole point of literate
software) these areas will be listed in a new top-level "projects"
file which contains entries for various subprojects currently in
process.  It is not complete but it will be maintained on a regular
ongoing basis.

This is the initial version.

This file contains notes on current development projects in Axiom

Axiom Database reorganization

  The databases were intially created on an ad-hoc, history-driven
  basis (e.g. the compress database was created when I needed to
  put Axiom on a 1Meg memory machine. It is now gone).

  1) reorganize the database layer use better technology

  2) merge the databases into a single database.

Axiom Burge recursive parser

  The Burge zipper parser accepts input and "zips it up" into a
  recursive data structure.

  1) document this idea and the underlying data structures

Axiom Charybdis

  recordandprint receives an sexpression form of the output,
  computes subexpression lengths, and prints. This is an
  implementation of the Charybdis paper.

  1) use the paper to document Charybdis in detail

Axiom mkAtree

  mkAtree receives the InputForm as an sexpression and constructs
  a tree object. 

  1) This tree object to be documented in detail

Axiom src/interp cleanup

  src/interp still contains many lisp files. 

  1) these need to be rewritten from machine-generated lisp to
     human-written lisp and documented.

  2) remove src/interp

Axiom interpreter merge

  src/interp contains functions called by the interpreter.

  1) tree-shake the interpreter to drag in the referenced

Axiom compiler merge

  src/interp contains functions called by the compiler.

  2) tree-shake the compiler to drag in the referenced

Axiom browser help

  help files are generated for the algebra. )help calls an
  external command called SPADEDIT. This currently either types
  out the help file (straight text) or opens an editor of choice,
  defaulting to vi. 

  1) SPADEDIT needs to have the choice of displaying the help files
  in a browser window.

  2) SPADEDIT needs to be able to handle pdfs

Axiom help files

  All of the categories, domains, and packages needs a help file.

  1) All of the exported functions need help files

Axiom display op examples

  )d op somefunction will display examples which are taken from
  ++X lines in the export section of the constructor.

  1) All of the exported functions need ++X example lines.

  2) d op needs to display the ++ text for functions

Axiom makefile removal

  The makefiles are organized as a tree with shell variables passed
  through the branches. 

  1) rewrite the makefiles into a single documented makefile

  2) rewrite the single makefile into lisp

Axiom CATS expansion

  The computer algebra test suite (CATS) needs comprehensive
  test suites for more coverage. 

  1) find a suitable textbook with a lot of examples of
     input/output pairs (like Schaums). Write a CATS test suite.

Axiom continuous integration

  Currently we follow a model of publishing a "release"

  1) set up a continuous integration server

  2) move to a continuous integration model so that every change
     gets built, tested, and pushed immediately. 

Axiom buglist

  The bug list has some very old bugs on it and lacks entries for
  known bugs.

  1) pick a bug and fix it

  2) pick up the bug list from fricas, test the open bugs, and
     merge them into the bug list

Axiom algebra availability documentation

  Currently the algebra is just a pile of constructors. There is
  no good organization by topic

  1) organize the algebra by topic using some external, known
     organization. possibly use maxima/maple/MMA organization
     so users can compare.

  2) highlight the areas where Axiom is weak or missing some
     functionality and suggest new algebra

Axiom algorithm documentation

  The algebra uses some known, published algorithms and also 
  uses unknown, unpublished algorithms.

  1) find an area with published algorithms (e.g. symbolic
     summation) and find the corresponding Axiom algorithm.
     Document it and reference the published papers

  2) find an area where Axiom has old algorithms (e.g.
     symbolic summation), update the algorithms, document
     them, and reference the published papers

  3) update the algorithm bibliographic history page to 
     trace the history, current implementation, and future
     direction of Axiom's algorithms.

Axiom history

  The history of Axiom as free software is documented in the
  mailing list archives. 

  1) Condense, organize, and write a book on the history of Axiom.

Axiom proofs

  Axiom uses algorithms which have been proven in the literature
  (e.g. Euclid's algorithm) in theory. Axiom reduces these to

  1) prove Axiom's implementation of Euclid's algorithm

    a) Math-to-Spad proof (e.g. COQ)
    b) Spad-to-Lisp proof (e.g. ACL2)
    c) Lisp-to-C proof (e.g. LLVM work)
    d) C-to-machine proof (Conditional-Concurrent Assignments)

  2) merge ACL2 beneath the Axiom interpreter and make it 
     available at the command prompt.

Axiom category axioms

  Add mathematical axioms to Axiom's category hierarchy.

  1) decorate each category with their axioms (e.g. monoid)

Axiom numerics

  Since moving away from NAG, Axiom numerics are missing

  1) expand bookvol10.5 with working lisp code and expose
     the numeric routines in packages

  2) investigate and recreate NAG-equivalent code for the
     exposed NAG library routines

Axiom Browser Notebook

  Axiom can currently serve as a backend for a browser.

  1) expand the existing notebook code bookvol11 to make
     the notebooks more functional

  2) expand/port the existing hyperdoc documentation to
     the new browser

Axiom SVG hierarchy

  Currently the SVG graph of Axiom's constructors is static.

  1) modify the static structure so clicking on a node goes
     directly to the constructor algebra

  2) modify the static structure to use a better, more useful
     graph structure so it can be easily navigated in the browser

Axiom graphics

  Axiom currently uses its own graphics package written in C.

  1) rewrite the graphics package to use HTML5 canvas

  2) integrate the graphics with the new browser front end

Axiom expression server

  Axiom can listen on a port.

  1) modify Axiom to take a command-line input from a port,
     compute the result, and return it over the net.

Axiom algebra use documentation

  Currently the algebra use documentation just shows how to call
  various functions but not solving actual problems.

  1) find a problem to solve, solve it, and document it in detail

  2) create "intro" videos for new users showing how to 
     use Axiom in different domains. Relate these to the
     algebra use documentation.

Axiom new developer support

  Axiom has videos of talks and videos of how-to.

  1) expand the how-to videos for developers detailing how
     to understand, maintain, modify, and extend Axiom

  2) list and publish potential projects

Axiom src/input dispersal

  The src/input files were created as initial attempts at testing
  and documentation. Thus there are two kinds of files in the
  same directory.

  1) reorganize the directory
    a) move complete examples into the user's guide or the algebra
    b) merge constructor example files with the constructor help
    c) organize, cleanup, and expand test coverage files to support
       continuous integration

  2) remove src/input

Axiom youtube channel

  Axiom has a new video library section

  1) create a youtube channel for Axiom videos and upload

reply via email to

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