Issues

• Is it ok to have a separate namespace for experimental things?

  RESOLVED: Yes, conversion can be automated / done with inference. Any URI in the experimental space should not be widely used before being properly defined and accepted.

  It is desirable to be able to see from the URI which data is stable, which is not, without having to look at the definitions.

  For example, grepping for the experimental ns from a file would give you a good idea whether your data is based on stable code.

  The idea is also that conversion wouldn't be too often necessary: the move from lava to real wouldn't require too much work, just a PEG round.

  The experimental namespace is part of lava, which means that we automatically exclude it from production code.

• What about ALPH? How much should we be defining ALPH things here, outside Alph proper?

  RESOLVED: Remove & rename. We are talking about fenfire things, not alpha things, with content &c.

  We could, in principle, move some of it to Alph, but we don't want to depend on Swamp there.

• Should we merge spatial into canvas2d?

  RESOLVED: Yes. Spatial will most likely not be used without canvas2d? The point is, the x and y coordinates are pretty specific to canvases, and while containment + x + y is a reasonable structure orthogonal to everything else, separating containnment and x and y to does not seem make sense.

  Also, if it's spatial, it should also have z ;)

  It would be acceptable to have Spatial be a superclass of Canvas2D, but this is probably not worth the trouble.

  Another point: the x and y are the default coordinate attributes, see the discussion on extensibility (to be done later) in javadoc.

• What should be the namespace prefix? vocabulary, rdf or terms or rdfv?

  RESOLVED: rdf-v. For "RDF Vocabulary", which mentions the term RDF as well as that this is not just RDF, it's something else.

• Should URIs contain timestamps?

  RESOLVED: [benja:]

  > - NEVER use URIs you want to be permanent without a timestamp.
  >
  > Actually the above could be used with a timestamp, but you don't
  > explicitly say so. Please define a full template for namespaces. I
  > suggest::
  >
  >     http://fenfire.org/terms/YYYY/MM/[DD/]namespacename
  >
  > where ``YYYY``, ``MM``, ``DD`` are the date (or month) when the
  > namespace was created, and ``namespacename`` is chosen by the person
  > creating the namespace. (DD is optional.)
  >
  > Items in the namespace would have the form::
  >
  >     http://fenfire.org/terms/YYYY/MM/[DD/]namespacename#id
  >
  > where ``id`` is chosen by the person creating the namespace.
  

• Should we separate cLink from FF? A separate CLink namespace?

  RESOLVED: Yes. It is sufficiently orthogonal to other structures.

• Should we merge PP (directed links) into FF, or something else?

  RESOLVED: Move to DLINK, Analogous to CLink and Canvas2D, this property creates its own orthogonal substructure.

• What should the types of coordx, coordy be? Float? Int? Numeric?

  RESOLVED: Floats. We use them with all coordinate systems anyway. If you want gridding, it's something for the UI to provide.

• Should each vocabulary also define its "identity", a RDF node that is used to talk about that vocabulary. This could be useful for describing the schema of some data, e.g. "This is spatial canvas data with dLinks".

  RESOLVED: Not yet. While this might be nice, it needs further thinking.

• Where should the RDF schemas the objects be defined?

  RESOLVED: Not yet. A further PEG will address this issue.

• Should the URI names contain the .HTML suffix?

  RESOLVED: No. It serves zero purpose (except allowing the website admin to be lazy) and makes it unintuitive to serve non-HTML representations of the namespace (such as RDF Schema).

• Should we stick to the previous convention that namespace class names should be all caps?

  RESOLVED: Yes. It says "constant" to C, C++ and Java programmers, but leaves the actual field names easier to read.

Changes

/** RDF Vocabulary of central concepts of Fenfire.
 */
public class FF {

    static public final String _nsId = 
        "http://fenfire.org/rdf-v/2003/05/ff";

    /** A property signifying fluid media "content" of a node.
     * Used as  (node, FF.content, literal) where the literal is
     * an XML literal containing an enfilade
     * parseable by alph.
     * This is analogous to spreadsheet or zzStructure cell contents.
     */
    static public final Object content;
}

/** RDF Vocabulary of content links.
 */
public class CONTENTLINK {
    static public final String _nsId = 
        "http://fenfire.org/rdf-v/2003/05/contentlink";

    /** The RDF class for content links. An node which is a content link
     * must have both the cLinkFrom and cLinkTo properties.
     */
    static public final Object Link;
    /** The Alph-parseable enfilade XML literal of a content link from-end.
     */
    static public final Object from;
    /** The Alph-parseable enfilade XML literal of a content link to-end.
     */
    static public final Object to;
}

/** RDF Vocabulary of 2D spatial canvases.
 */
public class CANVAS2D {
    static public final String _nsId = 
        "http://fenfire.org/rdf-v/2003/05/canvas2d";

    /** The RDF class of spatial 2D canvases.
     * Canvases contain (with the "contains" property)
     * nodes, which shall have the "x" and "y" properties.
     */
    static public final Object Canvas;
    /** The property by which the canvas is connected to
     * the nodes, as (canvas, contains, node).
     */
    static public final Object contains;
    /** The x and y coordinates of a node on a canvas.
     * (node, x, literal), where the literal is parseable
     * as a floating-point number (similar to Java doubles). 
     * Note that these are the <em>default</em> coordinate
     * properties: later on, we might make it possible for a Canvas2D
     * to define its own coordinate attributes, which would take
     * use close to Ted's floating world ideas.
     */
    static public final Object x, y;
}

STRUCTLINK
"""""

/** RDF vocabulary for directed (so far typeless)
 * one-to-one links.
 */
public class STRUCTLINK {
    static public final String _nsId = 
        "http://fenfire.org/rdf-v/2003/05/structlink";

    /** The directed link association.
     * A and B are linked by the tuple (A, DLINK.dLink, B)
     */
    static public final Object linkedTo;
}

/** RDF vocabulary of central RDF URIs defined outside fenfire.
 */
public class RDF {

    /** The RDF type attribute. A node's type can be declared 
     * to be Foo 
     * by a triple (node, RDF.type, Foo).
     */
    static public final Object type;
}