[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Axiom-developer] More random thoughts on the crystal: goals & technolog
[Axiom-developer] More random thoughts on the crystal: goals & technologies
Wed, 31 Dec 2003 12:58:33 +0100
Gnus/5.1002 (Gnus v5.10.2) Emacs/21.2 (gnu/linux)
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.
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
b) (David) Document the compiler internals. I would like to start by
documenting the usage for the various files found in the src/
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
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
- 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
- PERSONAL FACETS: the user builds its own vision of the system, using
information available in other users' system (it reminds me of
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.
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
"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
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
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?
David MENTRE <address@hidden> -- http://www.nongnu.org/axiom/
|[Prev in Thread]
||[Next in Thread]|
- [Axiom-developer] More random thoughts on the crystal: goals & technologies,
David MENTRE <=