[relax-ng] Minutes of RELAX NG TC Mtg. 2002-03-28

[Michael Fitzgerald <mike@wyeast.net>]

Minutes of a RELAX NG TC meeting held 28 March 2002 at 9:00 ET (UTC -05:00).

The next meeting will be held 11 April 2002 at 9:00 EDT (UTC -04:00).

Attendees

James
Josh
John Cowan
Kohsuke
Makoto
Mike
Norm
Tom Gaven

Not Attending

Fabio
David

Minutes

Makoto gave a review of the current state of DSDL, of which RELAX NG is a
part, and the work of SC34.

James joined us a bit late due a dinner engagement.

1. A name for the non-XML syntax

Makoto: What about a name?
John: How about RNX?
James: There could be zillions of non-XML syntaxes!
John: What about using "Authoring" in the name?
Makoto: How about "Compact"?
Norm: "Express" works for me.
John: I think "Express" is ambiguous. There are three syntaxes [for RELAX
NG]: standard XML, non-XML, and DTD. The DTD syntax maintains the structure
without flattening.
James: What do people think about "Compact"?
ALL: Yes

Resolved that we shall call the syntax hitherto known as the RELAX NG
Non-XML syntax as the RELAX NG Compact syntax.

2. Character escapes in compact syntax

John: What about character escapes?
James: Let's keep them simple.
John: Is there a need to do them a la Java?
James: I don't want backslashing.
John: What about \u syntax?
James: I just don't want names that you can't type easily.
Norm: I can imagine you would want to use character escapes in quoted
strings.
James: I think we want them in regular expressions.
John: Maybe we need to create a Reader?
James: It's not that simple. Use of something like "quoted string" + "quoted
string\n" makes sense.
James: In processing, there is no distinction between \n and \u000A.
Kohsuke: You could make headers distinctive.
James: The first non-character is <, and in compact, the first character is
not <. I would be overkill to lookahead for a word.
Kohsuke: OK.
John: It's cleaner to auto detect it.
Kohsuke: What if you want to do DTDs?
James: That's harder.

3. Character encoding statements in compact syntax

Kohsuke: What about a character encoding statements?
John: UTF-8 and UTF-16 are the defaults. Don't you just need a declaration
and a string? [encoding "UTF-8"]
Kohsuke: I am not that familiar with encoding issues.
James: I am not sure it is required. It's hairy to do an implementation. You
might do it like a bootstrapping program.
Tom: Couldn't you just inherit it?
James: You can pick up the value of an ns attribute from the including file.
The default ns is inherited, passed through from the included file to the
including file.
John: What about comments?
James: Comments not in RelaxNGCC makes it harder to implement.

[lost James as he rode the escalator]

Josh suggested that a link be added to the Web page [for what? I missed it].
Norm asked that it be added to the minutes as a reminder to him to add it
[whatever it was - sorry].

[James rejoins]

4. Type assignment

John: Let's talk about type assignment.
Makoto: There are many ways to do this. Do we really care about it?
John: We should distinguish between simple and complex type assignment.
James: For simple, for every string tell what the datatype is.
John: What was proposed for key/keyref?
James: In key/keyref you could do unambiguous define and simple keys.
Kohsuke: What [advantage] do you think we will have with type assignment?
James: I think that this is what we are trying to decide, not what is the
right way to do it.
Kohsuke: So we want to be conservative?
John: What's the difference in A & B?
James: In A & B, an int or a name or any int? [didn't get it]
John: An int and ID don't collide. I am trying to use a fixed set in Arch
Forms for RELAX NG (AFRNG).
James: Well a fixed set IS easier.
John: It solves datatype problems.
James: I agree.
John: What about returning a choice of datatypes?
James: I prefer that the user be statically told what datatypes there are.
John: Like in HTML?
James: That's not a compelling case. Most schemas are not datatype
ambiguous.
Makoto: You check this at compile time?
Kohsuke: That's expensive.
Makoto: Most schemas are unambiguous.
John: Can you make it available at compile time? New hooks that subset or
overlap.
James/Makoto: This is too difficult.
John: We should at least try to get some answers.
James: I don't think it is worth it. Give a simple rule, a different name
for a datatype.
Kohsuke: Do we allow schemas that are not datatype safe?
Makoto: If it is not unambiguous, no one can be sure if the instance is
safe.
James: I don't want to force implementations. I don't want them to have to
do anything at runtime.
John: With a state machine you can have known types.
James: If you don't keep track of it, if it fails, I just don't do type
assignment.
John: You could use an annotation method.
James: Why?
John: You could do in in a preprocessing step.
Kohsuke: How do you communicate to the application?
Makoto: Will this cover SOAP?
Kohsuke: It is tied to XML Schema. [?]

5. Except syntax

James: What about the except syntax?
John: - is ok.
James: There are some problems, such as in A or B - C.
John: Put all minuses in parens.
James: Let's talk about this in e-mail.

6. Other

Makoto: [something about direction subset?]
James: I haven't done anything, I am investigating.
Makoto: What about APIs?
James: I'm not sure we want to do this.
John: Are we going into the API business?
James: Should we go into the official API business for type assignment? Use
restriction or annotations? extend SAX/DOM?
Makoto: Who would want to use it?
John: You could add attributes?
James: That's a bit hacky?
Makoto: Yes but it works.
John: You could do APIs without one. Or there is xsi:type, why not exploit
it?
Makoto: We can force datatypes as well...
James: We can use restriction for simple types.
John: OK.
Makoto: I'd need to see a spec.
James: We can just do is ad hoc?
John: This would solve the easy cases.
Makoto: Would it cover the implementation case for SOAP?
John: The only way to find out is to try?
Makoto: I am not optimistic.
James: We may explore it, but we may not do it.
James: What about complex types?
John: Let's keep to simple for now.
Makoto: Let's stay away from complex types.
Norm: To be sure, if we can't do simple types, we won't do complex types.
John: Do it in syntax but not an API?
James: I am against doing APIs.
John/Norm: We can lobby for it later.
James: So we are against doing APIs?
All: Yes.

Resolved not to do APIs for type assignment.

John: Issuing IDs on multiple names?
James: We are doing an errata on that.