This information was last updated on November 28, 2014

Axiom was most recently released in August, 2014. You can view the 
release notes for each release.
The new release is available for different platforms on the
downloads page.

This TODO list represents abbreviated notes to categorize the work directions
and note progress (completed items have a - prefix). Items are expanded as
the work thread moves into that subject. There is no priority and no schedule.
The ratio is (# of completed task per section)/(total completed tasks) and
is a measure of the ratio of effort between areas. Completed tasks are marked
with a - in column 1 (+ indicates changes since last update)

There are approximately 285 tasks listed. These tasks are broken into the
following groups:

 Literate sources is the main thread of developing Axiom
 Splits are pieces of work to give away
 Joins are pieces of work to incorporate or cooperate with
 New Development is a list of ideas for new directions or needed work
 Research is a list of ideas that need investigation
 Community is a list of supporting tasks for the algebra community

 Motivation: Axiom needs to be well documented to live. To achieve
             this end it is being rewritten into literate software form.

  rewrite src/interp into the current books and remove this directory
    - rewrite the machine-generated lisp into hand-generated form
    - flatten the many layers, using macros for inline efficiencies

  reorganize the interpreter (vol5) into high level chapters and sections
    - make the structure of the interpreter obvious

  reorganize the compiler (vol9) into high level chapters and sections
    - make the structure of the compiler obvious

  organize the algebra theory by topic (vol10)
    - design a rational layout

  make regression, help, and examples for all algebra (vol10.*)
    - a .input for every constructor
    - a )help file for every constructor and function
    - a )d op "example" for every function

  split src/input into parts and remove src/input
    - some full domain examples into vol10
    - some function uses into vol10* tests
    - some files into a regression test suite
  recover numerics
  port to Windows

 Motivation: several pieces of the system have nothing to do with algebra
             and either have old technology that needs to be rewritten or
             common technology that ought to be contributed to other efforts.

  Motivation: We need a portable, useful front end to Axiom that combines
  the separate pieces of the Axiom command line, hyperdoc, and graphics
  into a unified way of working with pamphlet files.

 * Rewrite Hyperdoc Pages
    This task is to extract the information from the current
    hyperdoc system and make it available in the browser.
      rewrite all pages using AJAX
      add additional pages
      rearrange the order for clarity
      dynamically create category/domain/packages pages
      dynamically create operations pages 
      allow ASQ style lookups

 * Integrate Graphics
    This task is to extract the functionality from the graphics
    and make it work within the browser.
+     collect the graphics into a book volume
      document the graphics
      refactor graphics to extract X11 API
      make API compatible version of graphics for CANVAS element
      enable dynamic drawing into CANVAS
      enable popup page with CANVAS and control menu elements
 * Write Notebook Front End
    This task is to make a new, browser-based front end to Axiom.
      create new API domain to expose history
      make new context sensitive menus
      make card/div/Record objects 
      enable create/destroy/rearrange/import/export of card decks
      unify card decks and pamphlets

  Motivation: Algebra needs a hand-verified test suite which ought to be
              shared with other computer algebra systems. Needs a common
              syntax, could be a driver for previous item.
   rewrite regression test files with results from MMA, Maple, Maxima
   reformat files to use a common theory/practice format
   organize files into a useful taxonomy

 Motivation: there are several CA systems with very interesting features
             and/or algebra. Axiom needs to import these ideas or find
             ways to cooperate with these projects.

  Motivation: GAP has much stronger facilities for manipulating groups.
              Axiom can do group manipulation but GAP needs to be studied.

  Motivation: Octave has the capability to be a replacement for the NAG
              numeric libraries. Either an interface has to be retargetted
              or the code has to be ported to Aldor or Lisp.
-  Test rewriting Fortran code into Aldor
+  BLAS converted to pamphlet form
   BLAS integrated into Axiom

  Motivation: Magnus is strong in infinite group theory. Like GAP it needs
              to be studied and imported.
-  Discussion and proposal for work in this area with CCNY
+  Magnus is being rebuilt as a literate program and will eventually be
+  merged with Axiom
   Rebuild Magnus as a literate program
   Extract and categorize the magnus algorithms
   Provide Axiom implementations of the algorithms

  Motivation: Internal representation of polynomials that can be scaled to
              ~250k terms needs to be imported.

This task is dead.

  Motivation: External basis representation of large polynomials needs to
              be imported.

This task is dead.

  Motivation: Workbooks need to be imported.

This task has changed. Rather than focus on the mathematica workbooks
we plan to create and use the new Axiom firefox browser as a notebook
front end similar to Sage.


  Motivation: in order to allow users to use the system we need to collect
              and organize the documentation and help facilities.
- The Axiom book was rewritten and is now available as part of the normal
- distribution. 
- The Axiom tutorial book was published at
- The firefox browser was created
+ Additional pages from hyperdoc need firefox rewrites
  The .dvi files need to be accessible in the firefox hyperdoc
+ )help files are needed for more domains
+ )display operation needs examples for operations 

  Motivation: in order to allow multiple developers to work on the system
              the structure of the system needs to be explained.
-  Directory structure
-   document shell script
-   Makefile structure
-   document how the makefile tree works
-  Lisp structure
-   src structure
-    algebra 
-   boot
-    clef
-    doc
-    etc
-   graph
-    htex
-    hyper
-    include
-    input
-    interp
-   install
-   lib
-    lsp
-   noweb
-    paste
-    sman

  Motivation: restructure Axiom into literate book volumes
- Volume 0: Jenks book
- Volume 1: Tutorial
  Volume 2: User's Guide
  Volume 3: Programmer's Guide
+ Volume 4: Developer's Guide
+ Volume 5: Interpreter
  Volume 6: Axiom Command
+ Volume 7: Hyperdoc
+ Volume 8: Graphics
  Volume 9: Compiler
  Volume 10: Algebra
  Volume 11: Firefox Hyperdoc

   Motivation: algebra code should be able to include research papers
               and documentation of design choices, space, time and
               complexity. Researchers should be encouraged to write
               literate programs. Literate programs should be easily
               turned into book sections or chapters. 
-   seek appropriate tools
-     tangle, weave
-     cweb
-     noweb
-   seek feedback
-   create preliminary setup
-   create example pamphlet (DHMATRIX)
-     define doc structure
-     prototype
-   modify/rewrite noweb
-     make undefined chunks transparent
-     example generation
      test case generation
-   create booklet example (MATRIX)
+     define booklet structure
+     prototype
-   integrate into make
-   integrate into obj/mnt
+   integrate example (DHMATRIX2) into make
+   integrate book example into make
    write pamphlets for type hierarchy
      write SetCategory pamphlet
      integrate into make
      integrate into test
    write pamphlets for data structure hierarchy
      write aggregate pamphlet
      integrate into make
      integrate into test
    create example pamphlet from scratch (PRIMES is in P algorithm)
      recreate paper in tex
      write algorithm
      merge into build
+   create example pamphlet from planarity paper
      recreate paper in tex
      write algorithm
      merge into build
    create complex pamphlet (Barry Trager's Integration thesis)
-     recreate thesis in tex
      factor thesis into booklets
      factor booklets into pamphlets

  Motivation: Users of algebra should be able to step thru algorithms at
              some "appropriate" level of detail. Hard to do as most 
              algebra algorithms differ from hand methods.

  Motivation: FullyExplicitRingOver needs a better theory basis, etc.

  Motivation: run on a popular common lisp
-  Download GCL
-  Build image in /spad/lsp/gcl
-  Build Axiom on image

  Motivation: run on a popular common lisp
   Download CMUCL sources
   Build image in /spad/lsp/cmucl
   Build Axiom on image

  Motivation: run on a popular common lisp
-  Get final CCL sources from Arthur
-  Build image in /spad/lsp/ccl
-  Build Axiom on image

This effort is dead.

  Motivation: Provide a motivation and place to publish Axiom algorithms
              in a literate programming style. Journal development will
              require refereed papers.
-  Discuss with Community
   Contact TOMS at ACM
   Create License for pamphlet submission
-    This is likely to be the creative commons license
-  Create Prototype online site (
     Create Journal directory
     Structure pages similar to Journal
     Integrate into CVS
     Allow dynamic referee lists
   Research online/offline references to Axiom in literature
   Create citations bibliography
   Get permission to mirror/host published papers
-  Give presentation to Univ of Pisa re: literate journal
-  Worked with ACM to provide electronic ISSAC journal

+ Motivation: Soon it will be possible to have all prior published math
+             online and locally available. We need to design and build
+             a user interface model that supports researchers in math
+             by providing semantic searches, multi-faceted problem views,
+             real-time problem classification, and an "intensional stance"
+             assistant user interface.
+ Define model of interaction
  Prototype semantic markup
  Prototype semantic classification with KROPS
  Prototype facet viewer
  Prototype classifier
  Prototype intensional stance assisant

  Motivation: Axiom is fully layered. Research results in the lowest 
              layers can be leveraged to generate results in higher layers.
              Use Axiom against itself to create towers of complexity.
              Insist on complexity results in documentation.

  Motivation: Axiom interpreter objects don't have a standard name for
              their parts and do not have a manipulation language for
              rewriting parts. 
              idea: have a "tree" primitive for each type
              idea: define a graph of tree to tree maps that label each 
                    edge with the transformation applied to the subtree

  Motivation: Equations are ambiguous when standing alone. Textbooks provide
              context in the surrounding text. This is not adequately 
              captured by the type system. A new approach to this issue
              is required.

  Motivation: Magnus maintains a community agreed-upon list of "open problems"
              This is an excellent source of PhD work and a good focus
              mechanism. Create and maintain this.

  Motivation: Assume is a weak, global mechanism for capturing provisos.
              A new proviso object needs to exist that wraps existing 
              objects, provides scope for provisos and provides an
              algebra of provisos based on type (arithmetic, boolean,
              typed, etc).
-  Review the literature to extract proviso forms.
-  Classify proviso forms.
-  Draft research paper
   Develop an arithmetic of proviso forms.

  Motivation: This is a fundamentally stronger way to represent uncertainty
              in results. It needs to be lifted from the numeric domain and
              defined symbolically. It needs to be integrated into the
              proviso algebra.

   Document algebra domain

+ Motivation: Research needs to be done on how to represent and compute
+             with indefinite objects from domains. An indefinite object
+             has a fixed type (such as Integer) but a non-specified value.
+             Thus it is possible to say that x+1 is of type Indefinite Integer
+             since 1 is an Integer and x is an Indefinite Integer.
+ Submit NSF grant proposal (awarded)
+ Conduct research on indefinites
   Construct domain examples

+ Motivation: There are several research efforts to make computer algebra
+             available on the web. Axiom needs to participate and lead.
+ Work with ORCCA
   rebuild OPENMATH support
   update to latest OPENMATH standards
+ Work with MathAction
+  integrate automatically running Axiom into web pages

  Motivation: Axiom would be strongly useful in domains such as robotics.
              Areas such as backsolving of joint position can be fruitful
              areas of research. Deep integration in domains (DSP, Vision)
              needs to be pushed.
+ The Doyen effort is the current direction for this. Axiom will integrate
+ with the rest of the sciences thru this effort.

  Motivation: Axiom could provide parallel tasks that would continuously
              try to extract analytic solutions from incoming data. For
              example, in vision finding analytic edges to feed to a
              parallel recognizer algorithm.

  Motivation: Axiom can be used to model games in novel ways. For example,
              flight games with pursuit curves that live in a non-uniform
              space (planet gravity, changing density across air/water).

  Motivation: Force motion that always remains analytic. Thus the final
              solution is known to be analytic. For example, constrain
              intersecting pipes to known boundary conditions. Computational
              geometry seems the most fruitful area.

  Motivation: Algebra systems need a high level of confidence in the results.
              Hand checking of the results is difficult and expensive. 
              Automatically substituting results into the original equations
              could raise confidence. Auditing of boundaries of algebra
              algorithms. Precondition/Postcondition results for domains.
              Audited test suites used for regression testing.

  Motivation: Algebra systems have interpreters that embody a lot of 
              knowledge about the actions available to manipulate equations.
              This knowledge needs a language. The language needs to be
              crafted so that it can be added to domains and applied
              in symbolic form by a generalized simplification routine.
   Review the literature to extract manipulation sentences.
   Classify manipulation forms.
   Draft manipulation paper

  Motivation: Computational logic is a branch of computer mathematics
              that is not currently available in Axiom. The Boyer-Moore
              theorem prover, written in common lisp, provides a good
              general purpose platform to study the interaction of the
              theorem proving systems with Axiom
-  Contact Boyer & Moore
-  Contact Chandy & Misra
-  Download ACL2
   Build ACL2
   Invoke ACL2 from Axiom
   Integrate ACL2 into Axiom
     Use Dijkstra's methods against SetCategory
   Draft research paper

  Motivation: MetaPRL is a Higher-order Logic proof system that is well
              suited to proving Axiom-style languages. The proofs from
              this system would give higher confidence levels in the
              correctness of Axiom's algorithms.
-  Contact Artimov 
-   Review nuprl
-   Review MetaPRL
-   Construct trial example
-     Collect all sorting routines in Axiom
      Model the required subset of Axiom's language 
      Construct a proof of the sort algorithms

  Motivation: Work in Axiom has continued over the years but has not
              been integrated. Find this work and integrate it.
+ Motivation: Axiom has known bugs. Create a known bug list.
+   Integrate fixes for catdef
+   Integrate fixes for pleqn
  Motivation: Many of the subtasks listed above can be split off, done in
              parallel and lead independently. Find people who are interested,
              especially external projects (eg work with Gnuplot to enhance
              it with Axiom's abilities).
-  Set up cvs on Tenkan
-  Set up accounts for developers
-  Import current Axiom tree into CVS
-  Try system builds on developers machines
-  Exchange code via CVS
-  Expand platforms
-    Cygwin
-    Mingw
-    FreeBSD

  Motivation: An organized community will help focus new Axiom development.
-  Lyon conference presentation
-  Set up OSCAS group
-  Announce OSCAS group
-  Moderate OSCAS group
  This is a dead branch of effort.

  Motivation: Community needs all the usual tools enabled like bug list,
              mailing list, cvs, etc.
- (CVS)
- (CVS)
- (ARCH)
+ github (GIT)

  Motivation: Expose leading edge work
- (SVN)
- (GIT) (GIT)

  Motivation: the community needs to see and use the many open source
              computer algebra systems so they can compare and contrast
              the various systems. This will help focus the issues of
              what is currently possible and how hard it is to develop
              a large, general purpose system. Also useful for teaching.
-  Build Rosetta CD
-   collect open source systems
-   build them on a common subtree
-   write Rosetta document
-   write them to CD such that they can be run with installation
-   distribute CD to conferences, teachers, etc
+  Update Rosetta CD
+   add Axiom
+   fix mistakes
+   add paragraph per table
+   update Rosetta document for Giac
+   update Rosetta document for DoCon
+   update Rosetta document for Macsyma
+   write Meta-Rosetta document to expound on differences
+   integrate systems with browser front-end
+   build broken systems
+    feed back diffs to original projects
+   add new systems
+   find new customers
+ The Rosetta effort is joining with the Quantian effort and the result
+ will be known as Doyen. This work is in process.
  Build Doyen
   Create live CD
   Create standalone MathAction
   Integrate Axiom into standalone MathAction
   Build coordination tools between daughter Doyen and mother Doyen site

  Motivation: maintain a website so that progress on making
              Axiom open-source is made visible and the community has
              a place to discuss issues and ideas (not necessarily
              related to Axiom but to the community in general).
-  create website
-  build interest list
-  create and maintain update schedule

  Motivation: Find creative ways to pay people who work on Axiom. Everybody
              wants free developers but paid work will motivate development.
   Academic degree (BA in open source? BA in computer algebra?)
- Developed an open source lab at City College of NY. Lab is up and running
- Lab is part of the capstone projects for CS undergrads
   Grant model by line of code
-   contact IBM
-   contact SUN
+   contact NSF
    contact INRIA
    contact DARPA 
+   explore other contacts
   Award Model 
-   Schelter Award
-    contact UTexas
-    contact FSF
     develop plan
      define award type and frequency
      find sponsor organization
-       Efraim Armendariz 
-       Brad Kuhn 
      find volunteers to judge award
    Oscars/Emmy/Tony award model for CA at ISSAC?
-   Jenks Award
   Pay for support model
+  Pay for travel model
+   Contact Google
+   Contact IBM
+   Contact SUN
+   Contact Sage
+   Contact NSF  


Completed, dead, or abandoned tasks
  Motivation: hypertex was pre-browser technology. It should be rewritten
              to fit into today's technology. At least HTML, possibly XML.
- This work has forked into two paths. The first path is to recreate the
- browser from the hypertex sources. The second path is to rebuild the
- whole effort into a standard browser-based tool. Ultimately this will
- probably get merged with the Doyen science platform effort 
- Recreate Hypertex
- Create standard browser
-   create standalone browser version
-   merge into Doyen

  Motivation: asq is pre-javadoc. It should be rewritten to fit into the
              browser/tex new world of docs
- The ASQ tool needs to get redone so that standard html pages get built
- during system build and made available. They should have a javadoc-like
- look and feel.
- Create ASQ-HTML page generator

This task is complete.

  Motivation: plot has nothing to do with algebra but has some nice features
              such as data feedback from graph manipulation. These facilities
              should be moved to Gnuplot and the plot function retargetted.
  The graphics have been rebuilt and currently work. The graphics can only
  be run from a file at the moment because the connecting process, called
  sman, which manages all of the axiom processes is not yet working again.
  Rebuild sman
  Connect sman to graphics
  Connect graphics to gnuplot

This task was abandoned.

The 2D I/O direction has changed. The current plan is to use the
firefox browser as a universal front-end to Axiom.

  Motivation: the time has come for 2d input. TeXmacs provides this. There
              needs to be a much tighter integration of TeXmacs and Axiom.
   Connect to TeXmacs community
-  Build TeXmacs on Linux
-  Build TexMacs on Cygwin
   Build TexMacs on Windows
   pick up the notebook interface ideas from Sage

  Motivation: Rosetta should not exist. Algebra syntax should standardize.
              Existing committee work needs feedback from Axiom.

The Rosetta effort is complete.