[Axiom-developer] More random thoughts on the crystal: goals & technologies

[David MENTRE]

Hello,

Thank you Tim, Bertfried and Bill for detailed replies. It makes me
realize that, despite I have said before, we have slighlty different
short term objectives. I try to summarize the discussion up to now.

1) Goals

 A) Short and Mid term goals 

 As far as I have understood, we have two short/mid term goals:

 a) (Bill, Tim, Bertfried) Document the algebra to have a kind of
    reference manual for the Axiom programmer and researcher. Bertfried
    has detailed the kind of Type browser he would like to have in the
    short term
    (http://mail.nongnu.org/archive/html/axiom-developer/2003-12/msg00042.html).

 b) (David) Document the compiler internals. I would like to start by
    documenting the usage for the various files found in the src/
    directory.


 B) Long term goals

 We all want a system to navigate into _structured_ information that
 document the whole Axiom system. We all agree that you have different
 views on such a big system and, depending on your current work, we want
 to look more specifically at a subset of those views. Tim is using the
 idea of a Crystal, with several facets. Tim has detailed some facets
 examples:
 http://mail.nongnu.org/archive/html/axiom-developer/2003-12/msg00056.html 

 Now the hard part: which structure? How to document? How to explore?
 What underlying technology?

 Regarding structure, I have proposed to use a graph like approach. Tim
 has expressed interest for a Knowledge Network with a sound underlying
 technology (KROPS). Bertfried has proposed to use a Matroid
 approach. Tim and Bertfried objections is that we need a _structured_
 way of representing semantics in Axiom. I agree with them.


 Regarding ways how to add information to current Axiom, several
 approaches have been proposed by Tim
 (http://mail.nongnu.org/archive/html/axiom-developer/2003-12/msg00069.html).
 In summary:
  - COLLECT COMPILER INFORMATION: use compiler knowledge to produce
    indexes and other useful information
  - LATEX STRUCTURE INFORMATION: add manual information (issue:
    difficult to parse using a computer). Already used by Tim to
    document the build process
  - SPECIAL INFORMATION STRUCTURE: building "information sources" on
    specific topics. Several sources for different purposes can be made
  - GENERAL MATHEMATICS STRUCTURE: impose mathematical structures on
    facets 
  - PERSONAL FACETS: the user builds its own vision of the system, using
    information available in other users' system (it reminds me of
    SmallTalk Environment)
 

 From those several ideas, I deduce that we will probably need several
 information sources (i.e. like databases but possibly with a different
 model that the relational model). Those information sources should be
 able to be parsed by a computer, but sometimes it won't be possible at
 full extent (e.g. the PhD included in DHmatrix: we can extract some
 literate programming structure but the full meaning of the english
 text cannot be understood by a computer).

 We will also need several tools (Unix approach) to pick up information
 is those several sources (and probably build other sources). The main
 issue is to not use too many technologies, languages, etc.


2) Technologies

 a) W3C Semantic Web

 Bill as proposed to consider the W3C Semantic Web, which is build
 around XML technologies like RDF (Resource Description Framework) and
 OWL (Web Ontology Language). Those technologies are probably not well
 enough structured (in the sense that Tim and Bertfried want to
 structure semantics added to Axiom) but they form a standard that we
 could build upon. Even using unstructured RDF, we could _impose_ our
 own structure (e.g. Bertfried's Matroid) on our RDF files.

 Another important point in that they are build from the ground-up to be
 distributed and reusable by any user.

 Those technologies are not very easy to use (e.g. cumbersome syntax)
 but we could use them as a common file format to store our knowledge on
 Axiom (Tim's information sources). It would allow use to build on
 existing tool and infrastructure, to not reinvent the wheel and to
 maybe to gather additional developers and community interest.

 For example, it exists a lot of research on ways to browse RDF files
 (like MIT Haystack if I remember correctly).


 b) Ad-hoc information sources

 Tim as suggested that we instrument the compiler to produce additionnal
 information used to build information source. Using current tool (ASQ),
 we could query those information. The advantage is that the technology
 is already there. The disavantage is that the file format is
 proprietary to Axiom, so we will need to build bridges with other tools
 and technologies (browsers, query languages, ...). Bu I agree with Tim
 that it can be used (1) as a first step and (2) as a proof of concept.


 c) literate programming

 Noweb is useful as a first step to add information onto existing
 code. However, we need to find a way to categorize this information and
 build relations. We need a multi-dimensional book. Should we
 standardize the naming of pamphlets (<<algebra:typing:...>>) or should
 we add another technology (RDF?)  above or below code and documentation
 chunks?


 d) "browsers"

 "Browsers" (in a wide sense, i.e. more than just showing hyper-links)
 should allow users:

  - to add information is both a distributed (simultaneously in France,
    Germany, Canada and US) and structured way

  - to "navigate" into this information, using both graphical approaches
    (e.g. follow hyperlinks) and computational approaches (e.g. query
    languages)

  They should be build on existing tools and technology (TeXmacs?
  Haystack? Web browsers & HTML?).


 e) Knowledge Network

  Tim has expressed interest for a tool like KROPS
  (http://mail.nongnu.org/archive/html/axiom-developer/2003-12/msg00071.html).
  It would allow users to put semantics in the computer in a sound
  way. Possible issues: is it difficult to build such a system? How to
  interconnect it with current and future information sources?
 
 

3) What to do?

 I think our community has setup the goals the short term goals:

 - fix our current bugs (just a reminder ;), have a documentation and
   release our first public release of Axiom

 - build a type browser as Bertfried request

 - build a usable lattice of the algebra 

 - (for myself, I would like to also document the files in src/)


 After those steps, we could make a point (a kind of workshop), draw
 conclusion and ways towards the next step.


 To decide on the technology to use, we need a consensus. Personnaly, I
 am open to any technology, programming language (please avoid Java :),
 etc. For the short term, we could probably consider using existing
 information sources and tools (asq) and then consider a migration path
 towards more standardized file format (RDF?).

 What is your opinion?


Yours,
d.
-- 
David MENTRE <address@hidden> -- http://www.nongnu.org/axiom/