Another Word For It Patrick Durusau on Topic Maps and Semantic Diversity

November 3, 2015

XML Prague 2016 – Call for Papers [Looking for a co-author?]

Filed under: Conferences,XML,XPath,XQuery,XSLT — Patrick Durusau @ 6:54 pm

XML Prague 2016 – Call for Papers

Important Dates:

  • November 30th – End of CFP (full paper or extended abstract)
  • January 4th – Notification of acceptance/rejection of paper to authors
  • January 25th – Final paper
  • February 11-13, XML Prague 2016

From the webpage:

XML Prague 2016 now welcomes submissions for presentations on the following topics:

  • Markup and the Extensible Web – HTML5, XHTML, Web Components, JSON and XML sharing the common space
  • Semantic visions and the reality – micro-formats, semantic data in business, linked data
  • Publishing for the 21th century – publishing toolchains, eBooks, EPUB, DITA, DocBook, CSS for print, …
  • XML databases and Big Data – XML storage, indexing, query languages, …
  • State of the XML Union – updates on specs, the XML community news, …

All proposals will be submitted for review by a peer review panel made up of the XML Prague Program Committee. Submissions will be chosen based on interest, applicability, technical merit, and technical correctness.

Accepted papers will be included in published conference proceedings.

Authors should strive to contain original material and belong in the topics previously listed. Submissions which can be construed as product or service descriptions (adverts) will likely be deemed inappropriate. Other approaches such as use case studies are welcome but must be clearly related to conference topics.

Accepted presenters must submit their full paper (on time) and give their presentation and answer questions in English, as well as follow the XML Prague 2016 conference guidelines.

I don’t travel but am interested in co-authoring a paper with someone who plans on attending XML Prague 2016. Contact me at patrick@durusau.net.

October 2, 2015

Debugging XQuery Advice

Filed under: XQuery — Patrick Durusau @ 6:02 am

If you are ever called upon to diagnose or repair network connectivity issues, you know that the first thing to check is the network cable.

Well, much to my chagrin, there is a similar principle to follow when debugging XQuery statements.

If you type an element name incorrectly, you may not get an error from the query and it will happily complete, sans your expected content.

To broaden that a bit, the first thing to check, outside of reported syntax and type errors, are your XPath expressions, including the spelling of element names.

Especially for no errors but also not the expected result cases.

Thus ends the XQuery lesson for the day.

September 25, 2015

Three Reasons You May Not Want to Learn Clojure [One of these reasons applies to XQuery]

Filed under: Clojure,Functional Programming,XQuery — Patrick Durusau @ 7:34 pm

Three Reasons You May Not Want to Learn Clojure by Mark Bastian.

From the post:

I’ve been coding in Clojure for over a year now and not everything is unicorns and rainbows. Whatever language you choose will affect how you think and work and Clojure is no different. Read on to see what some of these effects are and why you might want to reconsider learning Clojure.

If you are already coding in Clojure, you will find this amusing.

If you are not already coding in Clojure, you may find this compelling.

I won’t say which one of these reasons applies to XQuery, at least not today. Watch this blog on Monday of next week.

September 4, 2015

Apache VXQuery: A Scalable XQuery Implementation

Filed under: XML,XQuery — Patrick Durusau @ 1:34 pm

Apache VXQuery: A Scalable XQuery Implementation by E. Preston Carman Jr., Till Westmann, Vinayak R. Borkar, Michael J. Carey, Vassilis J. Tsotras.

Abstract:

The wide use of XML for document management and data exchange has created the need to query large repositories of XML data. To efficiently query such large data collections and take advantage of parallelism, we have implemented Apache VXQuery, an open-source scalable XQuery processor. The system builds upon two other open-source frameworks — Hyracks, a parallel execution engine, and Algebricks, a language agnostic compiler toolbox. Apache VXQuery extends these two frameworks and provides an implementation of the XQuery specifics (data model, data-model dependent functions and optimizations, and a parser). We describe the architecture of Apache VXQuery, its integration with Hyracks and Algebricks, and the XQuery optimization rules applied to the query plan to improve path expression efficiency and to enable query parallelism. An experimental evaluation using a real 500GB dataset with various selection, aggregation and join XML queries shows that Apache VXQuery performs well both in terms of scale-up and speed-up. Our experiments show that it is about 3x faster than Saxon (an open-source and commercial XQuery processor) on a 4-core, single node implementation, and around 2.5x faster than Apache MRQL (a MapReduce-based parallel query processor) on an eight (4-core) node cluster.

Are you looking for more “pop” in your XQueries? Apache VXQuery may be the answer.

Suitable for the Edgar dataset and the OpenStreetMap dataset.

This maybe what finally pushes me over the edge in choosing between a local cluster or pursuing one of the online options. Just looks too interesting to not want to play with it.

September 2, 2015

XQuery Exercise

Filed under: XQuery — Patrick Durusau @ 6:54 pm

I was reading a collection of resources on XQuery by Joe Wicentowski (more on that below) when I stumbled on one in particular:

XQuery Questions on Stack Overflow.

Although the examples in slides, books and blog posts are going to be helpful (most of them anyway), they are after all, examples. There are no false steps, solutions work, etc.

Reading XQuery questions on Stack Overflow will be like real life. You will hear unexpected questions to which you don’t know the answer. (OK, for some people that’s rare but it does happen.)

Even if you can’t answer the questions, now, spend a little time trying to puzzle out how it could be answered. Then check your suspicions or answer against those that are posted.

Using the XQuery questions on Stack Overflow that way will do several important things:

  1. You will become familiar with a variety of XQuery resources.
  2. You will see how experienced XQuery users answer XQuery questions.
  3. Over time you will become a contributing member of the XQuery community (if you aren’t already).

Joe has lists of other XQuery resources:

Resources built on or with XQuery

Resources for learning XQuery

GitHub repositories with XQuery

August 28, 2015

eXist: XQuery FLWOR Expression Updates

Filed under: eXist,XQuery — Patrick Durusau @ 8:52 am

Fixes for FLWOR expressions #763

From the webpage:

This is a major update to FLWOR processing in eXist to align it with the 3.0/3.1 specification. The “for”, “let”, “where”, “order by” and “group by” clauses are now implemented as separate classes (instead of being attached to a main “for” or “let”), and may thus appear in any place the spec allows. A FLWOR expression may have multiple “order by”, “group by” or “where” clauses. The previous implementation was too restrictive, allowing those clauses only in specific positions.

The “group by” clause, which was added back in 2007 and has been updated a few times since then, was completely rewritten and does now also support collations. The “allowing empty” spec within a “for” is now respected.

You need the nightly build version to benefit from these latest changes. (As of August 28, 2015. Eventually the changes will make it into a release candidate and then into a stable version.)

Currently available versions include:

Stable Release, version 2.2

Release Candidate, version 3.0 RC 1 (not recommended for production)

Nightly Builds, Use at your own risk

I first saw this in a tweet by Jonathan Robie.

March 13, 2015

W3C Invites Implementations of XQuery and XPath Full Text 3.0;…

Filed under: W3C,XPath,XQuery — Patrick Durusau @ 4:26 pm

W3C Invites Implementations of XQuery and XPath Full Text 3.0; Supporting Requirements and Use Cases Draft Updated

From the post:

The XML Query Working Group and the XSLT Working Group invite implementation of the Candidate Recommendation of XQuery and XPath Full Text 3.0. The Full Text specification extends the XPath and XQuery languages to support fast and efficient full text searches over arbitrarily large collections of documents. This release brings the Full Text specification up to date with XQuery 3.0 and XPath 3.0; the language itself is unchanged.

Both groups also published an updated Working Draft of XQuery and XPath Full Text 3.0 Requirements and Use Cases. This document specifies requirements and use cases for Full-Text Search for use in XQuery 3.0 and XPath 3.0. The goal of XQuery and XPath Full Text 3.0 is to extend XQuery and XPath Full Text 1.0 with additional functionality in response to requests from users and implementors.

If you have comments that arise out of implementation experience, be advised that XQuery and XPath Full Text 3.0 will be a Candidate Recommendation until at least 26 March 2015.

Enjoy!

February 13, 2015

XPath/XQuery/FO/XDM 3.1 Comments Filed!

Filed under: XML,XPath,XQuery — Patrick Durusau @ 8:00 pm

I did manage to file seventeen (17) comments today on the XPath/XQuery/FO/XDM 3.1 drafts!

I haven’t mastered bugzilla well enough to create an HTML list of them to paste in here but no doubt will do so over the weekend.

Remember these are NOT “bugs” until they are accepted by the working group as “bugs.” Think of them as being suggestions on my part where the drafts were unclear or could be made clearer in my view.

Did you remember to post comments?

I will try to get a couple of short things posted tonight but getting the comments in was my priority today.

January 21, 2015

Balisage: The Markup Conference 2015

Filed under: Conferences,XML,XML Schema,XPath,XProc,XQuery,XSLT — Patrick Durusau @ 8:48 pm

Balisage: The Markup Conference 2015 – There is Nothing As Practical As A Good Theory

Key dates:
– 27 March 2015 — Peer review applications due
– 17 April 2015 — Paper submissions due
– 17 April 2015 — Applications for student support awards due
– 22 May 2015 — Speakers notified
– 17 July 2015 — Final papers due
– 10 August 2015 — Symposium on Cultural Heritage Markup
– 11–14 August 2015 — Balisage: The Markup Conference

Bethesda North Marriott Hotel & Conference Center, just outside Washington, DC (I know, no pool with giant head, etc. Do you think if we ask nicely they would put one in? And change the theme of the decorations about every 30 feet in the lobby?)

Balisage is the premier conference on the theory, practice, design, development, and application of markup. We solicit papers on any aspect of markup and its uses; topics include but are not limited to:

  • Cutting-edge applications of XML and related technologies
  • Integration of XML with other technologies (e.g., content management, XSLT, XQuery)
  • Web application development with XML
  • Performance issues in parsing, XML database retrieval, or XSLT processing
  • Development of angle-bracket-free user interfaces for non-technical users
  • Deployment of XML systems for enterprise data
  • Design and implementation of XML vocabularies
  • Case studies of the use of XML for publishing, interchange, or archiving
  • Alternatives to XML
  • Expressive power and application adequacy of XSD, Relax NG, DTDs, Schematron, and other schema languages
  • Detailed Call for Participation: http://balisage.net/Call4Participation.html
    About Balisage: http://balisage.net/
    Instructions for authors: http://balisage.net/authorinstructions.html

    For more information: info@balisage.net or +1 301 315 9631

    I wonder if the local authorities realize the danger in putting that many skilled markup people so close the source of so much content? (Washington) With attendees sparking off against each other, who knows?, could see an accountable and auditable legislative and rule making document flow arise. There may not be enough members of Congress in town to smother it.

    The revolution may not be televised but it will be powered by markup and its advocates. Come join the crowd with the tools to make open data transparent.

    January 20, 2015

    pgcli [Inspiration for command line tool for XPath/XQuery?]

    Filed under: PostgreSQL,XPath,XQuery — Patrick Durusau @ 1:22 pm

    pgcli

    From the webpage:

    Pgcli is a command line interface for Postgres with auto-completion and syntax highlighting.

    Postgres folks who don’t know about pgcli will be glad to see this post.

    But, having spent several days with XPath/XQuery/FO 3.1 syntax, I can only imagine the joy in XML circles for a similar utility for use with command line XML tools.

    Properly done, the increase in productivity would be substantial.

    The same applies for your favorite NoSQL query language. (Datomic?)

    Will SQL users be the only ones with such a command line tool?

    I first saw this in a tweet by elishowk.

    January 19, 2015

    XPath/XQuery/FO/XDM 3.1 Definitions – Deduped/Sorted/Some Comments! Version 0.1

    Filed under: XML,XPath,XQuery — Patrick Durusau @ 10:11 am

    My first set of the XPath/XQuery/FO/XDM 3.1 Definitions, deduped, sorted, along with some comments is now online!

    XPath, XQuery, XQuery and XPath Functions and Operators, XDM – 3.1 – Sorted Definitions Draft

    Let me emphasize this draft is incomplete and more comments are needed on the varying definitions.

    I have included all definitions, including those that are unique or uniform. This should help with your review of those definitions as well.

    I am continuing to work on this and other work products to assist in your review of these drafts.

    Reminder: Tentative deadline for comments at the W3C is 13 February 2015.

    January 15, 2015

    Corrected Definitions Lists for XPath/XQuery/etc.

    Filed under: Standards,XML,XPath,XQuery — Patrick Durusau @ 3:01 pm

    In my extraction of the definitions yesterday I produced files that had HTML <p> elements embedded in other HTML <p> elements.

    The corrected files are as follows:

    These lists are unsorted and the paragraphs with multiple definitions are repeated for each definition. Helps me spot where I have multiple definitions that may be followed by non-normative prose, applicable to one or more definitions.

    The XSLT code I used yesterday was incorrect:

    <xsl:for-each select=”//p/a[contains(@name, ‘dt’)]”>
    <p>
    <xsl:copy-of select=”ancestor::p”/>
    </p>
    </xsl:for-each>

    And results in:

    <p>
    <p>[<a name=”dt-expression-context” id=”dt-expression-context” title=”expression context” shape=”rect”>Definition</a>: The <b>expression
    context</b> for a given expression consists of all the information
    that can affect the result of the expression.]
    </p>
    </p>

    Which is both ugly and incorrect.

    When using xsl:copy-of for a p element, the surrounding p elements were unnecessary.

    Thus (correctly):

    &lt:xsl:for-each select=”//p/a[contains(@name, ‘dt’)]”>
    <xsl:copy-of select=”ancestor::p”/>
    </xsl:for-each>

    I reproduced the corrected definition files above. Apologies for any inconvenience.

    Work continues on the sorting and deduping.

    January 14, 2015

    Building Definitions Lists for XPath/XQuery/etc.

    Filed under: Standards,XPath,XQuery,XSLT — Patrick Durusau @ 3:30 pm

    I have extracted the definitions from:

    These lists are unsorted and the paragraphs with multiple definitions are repeated for each definition. Helps me spot where I have multiple definitions that may be followed by non-normative prose, applicable to one or more definitions.

    Usual follies trying to extract the definitions.

    My first attempt (never successful in my experience but I have to try it so as to get to the second, third, etc.) resulted in:

    DefinitionDefinitionDefinitionDefinitionDefinitionDefinitionDefinitionDefinitionDefinition

    Which really wasn’t what I meant. Unfortunately it was what I had asked for. 😉

    Just in case you are curious, the guts to extracting the definitions reads:

    <xsl:for-each select=”//p/a[contains(@name, ‘dt’)]”>
    <p>
    <xsl:copy-of select=”ancestor::p”/>
    </p>
    </xsl:for-each>

    Each of the definitions is contained in a p element where the anchor for the definition is contained in an a element with the attribute name, “dt-(somename).”

    This didn’t work in all four (4) cases because XPath and XQuery Functions and Operators 3.1 records its “[Definition” elements as:

    <p><span class=”termdef”><a name=”character” id=”character” shape=”rect”></a>[Definition] A <b>character</b> is an instance of the <a href=”http://www.w3.org/TR/REC-xml/#NT-Char” shape=”rect”>Char</a><sup><small>XML</small></sup> production of <a href=”#xml” shape=”rect”>[Extensible Markup Language (XML) 1.0 (Fifth Edition)]</a>.</span></p>

    I’m sure there is some complex trickery you could use to account for that case but with four files, this is meatball XSLT, results over elegance.

    Multiple definitions in one paragraph must be broken out so they can be sorted along with the other definitions.

    The one thing I forgot to do in the XSLT that you should do when comparing multiple standards was to insert an identifier at the end of each paragraph for the text it was drawn from. Thus:

    [Definition: Every instance of the data model is a sequence. XDM]

    Where XDM is in a different color for each source.

    Proofing all these definitions across four (4) specifications (XQueryX has no additions definitions, aside from unnecessarily restating RFC 2119) is no trivial matter. Which is why I have extracted them and will be producing a deduped and sorted version.

    When you have long or complicated standards to proof, it helps to break them down in to smaller parts. Especially if the parts are out of their normal reading context. That helps avoid simply nodding along because you have read the material so many times.

    FYI, comments on errors most welcome! Producing the lists was trivial. Proofing the headers, footers, license language, etc. took longer than the lists.

    Enjoy!

    January 13, 2015

    More on Definitions in XPath/XQuery/XDM 3.1

    Filed under: Standards,XPath,XQuery — Patrick Durusau @ 5:29 pm

    I was thinking about the definitions I extracted from XPath 3.1 Definitions Here! Definitions There! Definitions Everywhere! XPath/XQuery 3.1 and since the XPath 3.1 draft says:

    Because these languages are so closely related, their grammars and language descriptions are generated from a common source to ensure consistency, and the editors of these specifications work together closely.

    We are very likely to find that the material contained in definitions and the paragraphs containing definitions are in fact the same.

    To make the best use of your time then, what is needed is a single set of the definitions from XPath 3.1, XQuery 3.1, XQueryX 3.1, XQuery and XPath Data Model 3.1, and XQuery Functions and Operators 3.1.

    I say that, but then on inspecting some of the definitions in XQuery and XPath Data Model 3.1, I read:

    [Definition: An atomic value is a value in
    the value space of an atomic type and is labeled with the name of
    that atomic type.]

    [Definition: An atomic type is a primitive
    simple type
    or a type derived by restriction from another
    atomic type.] (Types derived by list or union are not atomic.)

    But in the file of definitions from XPath 3.1, I read:

    [Definition: An atomic value is a value in the value space of an atomic type, as defined in [XML Schema 1.0] or [XML Schema 1.1].]

    Not the same are they?

    What happened to:

    and is labeled with the name of that atomic type.

    That seems rather important. Yes?

    The phrase “atomic type” occurs forty-six (46) times in the XPath 3.1 draft, none of which define “atomic type.”

    It does define “generalized atomic type:”

    [Definition: A generalized atomic type is a type which is either (a) an atomic type or (b) a pure union type ].

    Which would make you think it would have to define “atomic type” as well, to declare the intersection with “pure union type.” But it doesn’t.

    In case you are curious, XML Schema 1.1 doesn’t define “atomic type” either. Rather it defines “anyAtomicType.”

    In XML Schema 1.0 Part 1, the phrase “atomic type” is used once and only once in “3.14.1 (non-normative) The Simple Type Definition Schema Component,” saying:

    Each atomic type is ultimately a restriction of exactly one such built-in primitive datatype, which is its {primitive type definition}.

    There is no formal definition nor is there any further discussion of “atomic type” in XML Schema 1.0 Part 1.

    XML Schema Part 2 is completely free of any mention of “atomic type.”

    Summary of the example:

    At this point we have been told that XPath 3.1 relies on XQuery and XPath Data Model 3.1 but also XML Schema 1 and XML Schema 1.1, which have inconsistent definitions of “atomic type,” when it exists at all.

    Moreover, XPath 3.1 relies upon undefined term (atomic value) to define another term (generalized atomic type), which is surely an error in any reading.

    This is a good illustration of what happens when definitions are not referenced from other documents with specific and resolvable references. Anyone checking such a definition would have noticed it missing in the referenced location.

    Summary on next steps:

    I was going to say a deduped set of definitions would serve for proofing all the drafts and now, despite the “production from a common source,” I’m not so sure.

    Probably the best course is to simply extract all the definitions and check them for duplication rather than assuming it.

    The questions of what should be note material and other issues will remain to be explored.

    January 12, 2015

    Definitions Here! Definitions There! Definitions Everywhere! XPath/XQuery 3.1

    Filed under: Standards,XPath,XQuery — Patrick Durusau @ 4:24 pm

    Would you believe there are one hundred and forty-eight definitions embedded in XPath 3.1?

    What strikes me as odd is that the same one hundred and forty-eight definitions appear in a non-normative glossary, sans what looks like the note material that follows some definitions in the normative prose.

    The first issue is why have definitions in both normative and non-normative prose? Particularly when the versions in non-normative prose lack the note type material found in the main text.

    Speaking of normative, did you now that normatively, document order is defined as:

    Informally, document order is the order in which nodes appear in the XML serialization of a document.

    So we have formal definitions that are giving us informal definitions.

    That may sound like being picky but haven’t we seen definitions of “document order” before?

    Grepping the current XML specifications from the W3C, I found 147 mentions of “document order” outside of the current drafts.

    I really don’t think we have gotten this far with XML without a definition of “document order.”

    Or “node,” “implementation defined,” “implementation dependent,” “type,” “digit,” “literal,” “map,” “item,” “axis step,” in those words or ones very close to them.

    • My first puzzle is why redefine terms that already exist in XML?
    • My second puzzle is the one I mentioned above, why repeat shorter versions of the definitions in an explicitly non-normative appendix to the text?

    For a concrete example of the second puzzle:

    For example:

    [Definition: The built-in functions
    supported by XPath 3.1 are defined in [XQuery and XPath Functions and Operators
    3.1]
    .] Additional functions may be provided
    in the static
    context
    . XPath per se does not provide a way to declare named
    functions, but a host language may provide such a
    mechanism.

    First, you are never told what section of XQuery and XPath Functions and Operators 3.1 has this definition so we are back to the 5,000 x N problem.

    Second, what part of:

    XPath per se does not provide a way to declare named functions, but a host language may provide such a mechanism.

    Does not look like a note to you?

    Does it announce some normative requirement for XPath?

    Proofing is made more difficult because of the overlap of these definitions, verbatim, in XQuery 3.1. Whether it is a complete overlap or not I can’t say because I haven’t extracted all the definitions from XQuery 3.1. The XQuery draft reports one hundred and sixty-five (165) definitions, so it introduces additional definitions. Just spot checking, the overlap looks substantial. Add to that the same repetition of terms as shorter entries in the glossary.

    There is the accomplice XQuery and XPath Data Model 3.1, which is alleged to be the source of many definitions but not well known enough to specify particular sections. In truth, many of the things it defines have no identifiers so precise reference (read hyperlinking to a particular entry) may not even be possible.

    I make that to be at least six sets of definitions, mostly repeated because one draft won’t or can’t refer to prior XML definitions of the same terms or the lack of anchors in these drafts, prevents cross-referencing by section number for the convenience of the reader.

    I can ease your burden to some extent, I have created an HTML file with all the definitions in XPath 3.1, the full definitions, for your use in proofing these drafts.

    I make no warranty about the quality of the text as I am a solo shop so have no one to proof copy other than myself. If you spot errors, please give a shout.


    I will see what I can do about extracting other material for your review.

    What we actually need is a concordance of all these materials, sans the digrams and syntax productions. KWIC concordances don’t do so well with syntax productions. Or tables. Still, it might be worth the effort.

    January 9, 2015

    Structural Issues in XPath/XQuery/XPath-XQuery F&O Drafts

    Filed under: Standards,W3C,XML,XPath,XQuery — Patrick Durusau @ 1:02 pm

    Apologies as I thought I was going to be further along in demonstrating some proofing techniques for XPath 3.1, XQuery 3.1, XPath and XQuery Functions and Operations 3.1 by today.

    Instead, I encountered structural issues that are common to all three drafts that I didn’t anticipate but that need to be noted before going further with proofing. I will be using sample material to illustrate the problems and will not always have a sample from all three drafts or even note every occurrence of the issues. They are too numerous for that treatment and it would be repetition for repetition’s sake.

    First, consider these passages from XPath 3.1, 1 Introduction:

    [Definition: XPath 3.1 operates on the abstract, logical structure of an XML document, rather than its surface syntax. This logical structure, known as the data model, is defined in [XQuery and XPath Data Model (XDM) 3.1].]

    [Definition: An XPath 3.0 Processor processes a query according to the XPath 3.0 specification.] [Definition: An XPath 2.0 Processor processes a query according to the XPath 2.0 specification.] [Definition: An XPath 1.0 Processor processes a query according to the XPath 1.0 specification.]

    1. Unnumbered Definitions – Unidentified Cross-References

    The first structural issue that you will note with the “[Definition…” material is that all such definitions are unnumbered and appear throughout all three texts. The lack of numbering means that it is difficult to refer with any precision to a particular definition. How would I draw your attention to the third definition of the second grouping? Searching for XPath 1.0 turns up 79 occurrences in XPath 3.1 so that doesn’t sound satisfactory. (FYI, “Definition” turns up 193 instances.)

    While the “Definitions” have anchors that allow them to be addressed by cross-references, you should note that the cross-references are text hyperlinks that have no identifier by which a reader can find the definition without using the hyperlink. That is to say when I see:

    A lexical QName with a prefix can be converted into an expanded QName by resolving its namespace prefix to a namespace URI, using the statically known namespaces. [These are fake links to draw your attention to the text in question.]

    The hyperlinks in the original will take me to various parts of the document where these definitions occur, but if I have printed the document, I have no clue where to look for these definitions.

    The better practice is to number all the definitions and since they are all self-contained, to put them in a single location. Additionally, all interlinear references to those definitions (or other internal cross-references) should have a visible reference that enables a reader to find the definition or cross-reference, without use of an internal hyperlink.

    Example:

    A lexical QName Def-21 with a prefix can be converted into an expanded QName Def-19 by resolving its namespace prefix to a namespace URI, using the statically known namespaces. Def-99 [These are fake links to draw your attention to the text in question. The Def numbers are fictitious in this example. Actual references would have the visible definition numbers assigned to the appropriate definition.]

    2. Vague references – $N versus 5000 x $N

    Another problem I encountered was what I call “vague references,” or less generously, $N versus 5,000 x $N.

    For example:

    [Definition: An atomic value is a value in the value space of an atomic type, as defined in [XML Schema 1.0] or [XML Schema 1.1].] [Definition: A node is an instance of one of the node kinds defined in [XQuery and XPath Data Model (XDM) 3.1].

    Contrary to popular opinion, standards don’t write themselves and every jot and tittle was placed in a draft at the expense of someone’s time and resources. Let’s call that $N.

    In the example, you and I both know somewhere in XML Schema 1.0 and XML Schema 1.1 that the “value space of the atomic type” is defined. The same is true for nodes and XQuery and XPath Data Model (XDM) 3.1. But where? The authors of these specifications could insert that information at a cost of $N.

    What is the cost of not inserting that information in the current drafts? I estimate the number of people interested in reading these drafts to be 5,000. So each of those person will have to find the same information omitted from these specifications, which is a cost of 5,000 x $N. In terms of convenience to readers and reducing their costs of reading these specifications, references to exact locations in other materials are a necessity.

    In full disclosure, I have no more or less reason to think 5,000 people are interested in these drafts than the United States has for positing the existence of approximately 5,000 terrorists in the world. I suspect the number of people interested in XML is actually higher but the number works to make the point. Editors can either convenience themselves or their readers.

    Vague references are also problematic in terms of users finding the correct reference. The citation above, [XML Schema 1.0] for “value space of an atomic type,” refers to all three parts of XML Schema 1.0.

    Part 1, at 3.14.1 (non-normative) The Simple Type Definition Schema Component, has the only reference to “atomic type.”

    Part 2, actually has “0” hits for “atomic type.” True enough, “2.5.1.1 Atomic datatypes” is likely the intended reference but that isn’t what the specification says to look for.

    Bottom line is that any external reference needs to include in the inline citation the precise internal reference in the work being cited. If you want to inconvenience readers by pointing to internal bibliographies rather than online HTML documents, where available, that’s an editorial choice. But in any event, for every external reference, give the internal reference in the work being cited.

    Your readers will appreciate it and it could make your work more accurate as well.

    3. Normative vs. Non-Normative Text

    Another structural issue which is important for proofing is the distinction between normative and non-normative text.

    In XPath 3.1, still in the Introduction we read:

    This document normatively defines the static and dynamic semantics of XPath 3.1. In this document, examples and material labeled as “Note” are provided for explanatory purposes and are not normative.

    OK, and under 2.2.3.1 Static Analysis Phase (XPath 3.1), we find:

    Examples of inferred static types might be:

    Which is followed by a list so at least we know where the examples end.

    However, there are numerous cases of:

    For example, with the expression substring($a, $b, $c), $a must be of type xs:string (or something that can be converted to xs:string by the function calling rules), while $b and $c must be of type xs:double. [also in 2.2.3.1 Static Analysis Phase (XPath 3.1)]

    So, is that a non-normative example? If so, what is the nature of the “must” that occurs in it? Is that normative?

    Moreover, the examples (XPath 3.1 has 283 occurrences of that term, XQuery has 455 occurrences of that term, XPath and XQuery Functions and Operators have 537 occurrences of that term) are unnumbered, which makes referencing the examples by other materials very imprecise and wordy. For the use of authors creating secondary literature on these materials, to promote adoption, etc., number of all examples should be the default case.

    Oh, before anyone protests that XPath and XQuery Functions and Operators has separated its examples into lists, that is true but only partially. There remain 199 occurrences of “for example” which do not occur in lists. Where lists are used, converting to numbered examples should be trivial. The elimination of “for example” material may be more difficult. Hard to say without a good sampling of the cases.

    Conclusion:

    As I said at the outset, apologies for not reaching more substantive proofing techniques but structural issues are important for the readability and usability of specifications for readers. Being correct and unreadable isn’t a useful goal.

    It may seem like some of the changes I suggest are a big “ask” this late in the processing of these specifications. If this were a hand edited document, I would quickly agree with you. But it’s not. Or at least it shouldn’t be. I don’t know where the source is held but the HTML you read is an generated artifact.

    Gathering and numbering the definitions and inserting those numbers into the internal cross-references are a matter of applying a different style sheet to the source. Fixing the vague references and unnumbered example texts would take more editorial work but readers would greatly benefit from precise references and a clear separation of normative from non-normative text.

    I will try again over the weekend to reach aids for substantive proofing on these drafts. With luck, I will return to these drafts on Monday of next week (12 January 2014).

    January 7, 2015

    MUST in XPath 3.1/XQuery 3.1/XQueryX 3.1

    Filed under: Standards,XPath,XQuery — Patrick Durusau @ 12:13 pm

    I mentioned the problems with redefining may and must in XPath and XQuery Functions and Operators 3.1 in Redefining RFC 2119? Danger! Danger! Will Robinson! last Monday.

    Requirements language is one of the first things to check for any specification so I thought I should round that issue out by looking at the requirement language in XPath 3.1, XQuery 3.1, and, XQueryX 3.1.

    XPath 3.1

    XPath 3.1 includes RFC 2119 as a normative reference but then never cites RFC 2119 in the document or use the uppercase MUST.

    I suspect that is the case because of Appendix F Conformance:

    XPath is intended primarily as a component that can be used by other specifications. Therefore, XPath relies on specifications that use it (such as [XPointer] and [XSL Transformations (XSLT) Version 3.0]) to specify conformance criteria for XPath in their respective environments. Specifications that set conformance criteria for their use of XPath must not change the syntactic or semantic definitions of XPath as given in this specification, except by subsetting and/or compatible extensions.

    The specification of such a language may describe it as an extension of XPath provided that every expression that conforms to the XPath grammar behaves as described in this specification. (Edited on include the actual links to XPointer and XSLT, pointing internally to a bibliography defeats the purpose of hyperlinking.)

    Personally I would simply remove the RFC 2119 reference since XPath 3.1 is a set of definitions to which conformance is mandated or not, by other specifications.

    XQuery 3.1 and XQueryX 3.1

    XQuery 3.1 5 Conformance reads in part:

    This section defines the conformance criteria for an XQuery processor. In this section, the following terms are used to indicate the requirement levels defined in [RFC 2119]. [Definition: MUST means that the item is an absolute requirement of the specification.] [Definition: MUST NOT means that the item isan absolute prohibition of the specification.] [Definition: MAY means that an item is truly optional.] [Definition: SHOULD means that there may exist valid reasons in particular circumstances to ignore a particular item, but the full implications must be understood and carefully weighed before choosing a different course.] (Emphasis in the original)

    XQueryX 3.1 5 Conformance reads in part:

    This section defines the conformance criteria for an XQueryX
    processor (see Figure 1, “Processing Model Overview”, in [XQuery 3.1: An XML Query Language] , Section 2.2 Processing Model XQ31.

    In this section, the following terms are used to indicate the requirement levels defined in [RFC 2119]. [Definition: MUST means that the item is an absolute requirement of the specification.] [Definition: SHOULD means that there may exist valid reasons in particular circumstances to ignore a particular item, but the full implications must be understood and carefully weighed before choosing a different course.] [Definition: MAY means that an item is truly optional.]

    First, the better practice is not to repeat definitions found elsewhere (a source of error and misstatement) but to cite RFC 2119 as follows:

    The key words “MUST”, “MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”, “RECOMMENDED”, “MAY”, and “OPTIONAL” in this document are to be interpreted as described in [RFC2119].

    Second, the bolding found in XQuery 3.1 of MUST, etc., is unnecessary, particularly when not then followed by bolding in the use of MUST in the conformance clauses. Best practice to simply use UPPERCASE in both cases.

    Third, and really my principal reason for mentioning XQuery 3.1 and XQueryX 3.1 is to call attention to their use of RFC 2119 keywords. That is to say you will find the keywords in the conformance clauses and not any where else in the specification.

    Both use the word “must” in their texts but only as would normally appear in prose and implementers don’t have to pour through a sprinkling of MUST as you see in some drafts, which makes for stilted writing and traps for the unwary.

    The usage of RFC 2119 keywords in XQuery 3.1 and XQueryX 3.1 make the job of writing in declarative prose easier, eliminates the need to distinguish MUST and must in the normative text, and gives clear guidance to implementers as to the requirements to be met for conformance.

    I was quick to point out an error in my last post so it is only proper that I be quick to point out a best practice in XQuery 3.1 and XQueryX 3.1 as well.

    This coming Friday, 9 January 2015, I will have a post on proofing content proper for this bundle of specifications.

    PS: I am encouraging you to take on this venture into proofing specifications because this particular bundle of W3C specification work is important for pointing into data. If we don’t have reliable and consistent pointing, your topic maps will suffer.

    January 5, 2015

    Redefining RFC 2119? Danger! Danger! Will Robinson!

    Filed under: Standards,W3C,XML,XPath,XQuery — Patrick Durusau @ 3:43 pm

    I’m lagging behind in reading XQuery 3.1: An XML Query Language, XML Path Language (XPath) 3.1, and, XPath and XQuery Functions and Operators 3.1 in order to comment by 13 February 2015.

    In order to catch up this past weekend I started trying to tease these candidate recommendations apart to make them easier to proof. One of the things I always do I check for key word conformance language and that means, outside of ISO, RFC 2119.

    I was reading XPath and XQuery Functions and Operators 3.1 (herein Functions and Operators) when I saw:

    1.1 Conformance

    The Functions and Operators specification is intended primarily as a component that can be used by other specifications. Therefore, Functions and Operators relies on specifications that use it (such as [XML Path Language (XPath) 3.1], [XQuery 3.1: An XML Query Language], and potentially future versions of XSLT) to specify conformance criteria for their respective environments.

    That works. You have a normative document of definitions, etc., and some other standard cites those definitions and supplies the must,should, may according to RFC 2119. Not common but that works.

    But then I started running scripts for usage of key words and I found in Functions and Operators:

    1.6.3 Conformance terminology

    [Definition] may

    Conforming documents and processors are permitted to, but need not, behave as described.

    [Definition] must

    Conforming documents and processors are required to behave as described; otherwise, they are either non-conformant or else in error.

    Thus the title: Redefining RFC 2119? Danger! Danger! Will Robinson!

    RFC 2119 reads in part:

    1. MUST This word, or the terms “REQUIRED” or “SHALL”, mean that the definition is an absolute requirement of the specification.

    5. MAY This word, or the adjective “OPTIONAL”, mean that an item is truly optional. One vendor may choose to include the item because a particular marketplace requires it or because the vendor feels that it enhances the product while another vendor may omit the same item. An implementation which does not include a particular option MUST be prepared to interoperate with another implementation which does include the option, though perhaps with reduced functionality. In the same vein an implementation which does include a particular option MUST be prepared to interoperate with another implementation which does not include the option (except, of course, for the feature the option provides.)

    6. Guidance in the use of these Imperatives

    Imperatives of the type defined in this memo must be used with care and sparingly. In particular, they MUST only be used where it is actually required for interoperation or to limit behavior which has potential for causing harm (e.g., limiting retransmisssions) For example, they must not be used to try to impose a particular method on implementors where the method is not required for interoperability.

    First, the referencing of RFC 2119 is standard practice at the W3C, at least with regard to XML specifications. I wanted to have more than personal experience to cite so I collected the fifty-eight current XML specifications and summarize them in the list at the end of this post.

    Of the fifty-nine (59) current XML specifications (there may be others, the W3C has abandoned simply listing its work without extraneous groupings), fifty-two of the standards cite and follow RFC 2119. Three of the remaining seven (7) fail to cite RFC due to errors in editing.

    The final four (4) as it were that don’t cite RFC 2119 are a good illustration of how errors get perpetuated from one standard to another.

    The first W3C XML specification to not cite RFC 2119 was: Extensible Markup Language (XML) 1.0 (Second Edition) where it reads in part:

    1.2 Terminology

    may

    [Definition: Conforming documents and XML processors are permitted to but need not behave as described.]

    must

    [Definition: Conforming documents and XML processors are required to behave as described; otherwise they are in error. ]

    The definitions of must and may were ABANDONED in Extensible Markup Language (XML) 1.0 (Third Edition), which simply dropped those definitions and instead reads in part:

    1.2 Terminology

    The terminology used to describe XML documents is defined in the body of this specification. The key words must, must not, required, shall, shall not, should, should not, recommended, may, and optional, when emphasized, are to be interpreted as described in [IETF RFC 2119].

    The exclusive use of RFC 2119 continues through Extensible Markup Language (XML) 1.0 (Fourth Edition) to the current Extensible Markup Language (XML) 1.0 (Fifth Edition)

    However, as is often said, whatever good editing we do is interred with us and any errors we make live on.

    Before the abandonment of attempts to define may and must appeared in XML 3rd edition, XML Schema Part 1: Structures Second Edition and XML Schema Part 2: Datatypes Second Edition cite XML 2nd edition as their rationale for defining may and must. That error has never been corrected.

    Which brings us to W3C XML Schema Definition Language (XSD) 1.1 Part 2: Datatypes which is the last W3C XML specification to not cite RFC 2119.

    XSD 1.1 Part 2 reads in part, under Appendix I Changes since version 1.0, I.4 Other Changes:

    The definitions of must, must not, and ·error· have been changed to specify that processors must detect and report errors in schemas and schema documents (although the quality and level of detail in the error report is not constrained).

    The problem being XML Schema Part 2: Datatypes Second Edition

    relies upon XML Schema Part 2: Datatypes Second Edition which cites Extensible Markup Language (XML) 1.0 (Second Edition) as the reason for redefining the terms may and must.

    The redefining of may and must relies upon language in a superceded version of the XML standard. Language that was deleted ten (10) years ago from the XML standard.

    If you have read this far, you have a pretty good guess that I am going to suggest that XPath and XQuery Functions and Operators 3.1 drop the attempt to redefine terms that appear in RFC 2119.

    First, redefining widely used terms for conformance is clearly a bad idea. Do you mean RFC2119 must or do you mean and F&O must? Clearly different. If a requirement has an RFC2119 must, my application either conforms or fails. If a requirement has an F&O must, my application may simple be in error. All the time. Is that useful?

    Second, by redefining must, we lose the interoperability aspects as define by RFC2119 for all uses of must. Surely interoperability is a goal of Functions and Operators. Yes?

    Third, the history of redefining may and must at the W3C shows (to me) the perpetuation of an error long beyond its correction date. It’s time to put an end to redefining may and must.

    PS: Before you decide you “know” the difference in upper and lower case key words from RFC 2119, take a look at: RFC Editorial Guidelines and Procedures, Normative References to RFC 2119. Summary, UPPER CASE is normative, lower case is “a necessary logical relationship.”

    PPS: Tracking this error down took longer than expected so it will be later this week before I have anything that may help with proofing the specifications.


    XML Standards Consulted in preparation of this post. Y = Cites RFC 2119, N = Does not cite RFC 2119.

    January 3, 2015

    JSONiq & XQuery Package for Atom

    Filed under: Editor,XQuery — Patrick Durusau @ 2:08 pm

    William Candillon tweeted today:

    JSONiq & XQuery support for @AtomEditor, powered by XQLint: https://atom.io/packages/language-jsoniq

    From the Atom homepage:

    At GitHub, we’re building the text editor we’ve always wanted. A tool you can customize to do anything, but also use productively on the first day without ever touching a config file. Atom is modern, approachable, and hackable to the core. We can’t wait to see what you build with it.

    It’s always good to see people not reusing current names in technology that might cause confusion.

    If you have ever wondered about the source of semantic ambiguity in any language, find a mirror. It’s us. Every attempt to cure that ambiguity either creates more by re-use of current terminology with more precise meanings or by making up new a terminology, which never fully displaces the old.

    December 19, 2014

    XQuery, XPath, XQuery/XPath Functions and Operators 3.1

    Filed under: XML,XPath,XQuery — Patrick Durusau @ 11:56 am

    XQuery, XPath, XQuery/XPath Functions and Operators 3.1 were published on 18 December 2014 as a call for implementation of these specifications.

    The changes most often noted were the addition of capabilities for maps and arrays. “Support for JSON” means sections 17.4 and 17.5 of XPath and XQuery Functions and Operators 3.1.

    XQuery 3.1 and XPath 3.1 depend on XPath and XQuery Functions and Operators 3.1 for JSON support. (Is there no acronym for XPath and XQuery Functions and Operators? Suggest XF&O.)

    For your reading pleasure:

    XQuery 3.1: An XML Query Language

      3.10.1 Maps.

      3.10.2 Arrays.

    XML Path Language (XPath) 3.1

    1. 3.11.1 Maps
    2. 3.11.2 Arrays

    XPath and XQuery Functions and Operators 3.1

    1. 17.1 Functions that Operate on Maps
    2. 17.3 Functions that Operate on Arrays
    3. 17.4 Conversion to and from JSON
    4. 17.5 Functions on JSON Data

    Hoping that your holiday gifts include a large box of highlighters and/or a box of red pencils!

    Oh, these specifications will “…remain as Candidate Recommendation(s) until at least 13 February 2015. (emphasis added)”

    Less than two months so read quickly and carefully.

    Enjoy!

    I first saw this in a tweet by Jonathan Robie.

    October 10, 2014

    Last Call: XQuery 3.1 and XQueryX 3.1; and additional supporting documents

    Filed under: JSON,XPath,XQuery,XSLT — Patrick Durusau @ 9:02 am

    Last Call: XQuery 3.1 and XQueryX 3.1; and additional supporting documents

    From the post:

    Today the XQuery Working Group published a Last Call Working Draft of XQuery 3.1 and XQueryX 3.1. Additional supporting documents were published jointly with the XSLT Working Group: a Last Call Working Draft of XPath 3.1, together with XPath Functions and Operators, XQuery and XPath Data Model, and XSLT and XQuery Serialization. XQuery 3.1 and XPath 3.1 introduce improved support for working with JSON data with map and array data structures as well as loading and serializing JSON; additional support for HTML class attributes, HTTP dates, scientific notation, cross-scaling between XSLT and XQuery and more. Comments are welcome through 7 November 2014. Learn more about the XML Activity.

    How closely do you read?

    To answer that question, read all the mentioned documents by 7 November 2014, keeping a list of errors you spot.

    Submit your list to the XQuery Working Group by by 7 November 2014 and score your reading based on the number of “errors” accepted by the working group.

    What is your W3C Proofing Number? (Average number of accepted “errors” divided by the number of W3C drafts where “errors” were submitted.)

    July 15, 2014

    CSV on the Web

    Filed under: CSV,Standards,XQuery — Patrick Durusau @ 2:56 pm

    CSV on the Web – What’s Happening in the W3C Working Group by Jeni Tennison.

    After seeing Software Carpentry: Lessons Learned yesterday, I have a new appreciation for documenting the semantics of data as used by its users.

    Not to say we don’t need specialized semantic syntaxes and technologies, but if we expect market share, then we need to follow the software and data users are using.

    How important is CSV?

    Jeni gives that stats as:

    • >90% open data is tabular
    • 2/3rds “CSV” files on data.gov.uk aren’t machine readable

    Which means people use customized solutions (read vendor lockin).

    A good overview of the CSV WG’s work so far with a request for your assistance:

    I need to start following this workgroup. Curious to see if they reuse XQuery addressing to annotate CSV files, columns, rows, cells.

    PS: If you don’t see arrows in the presentation, I didn’t, use your space bar to change slides and Esc to see all the slides.

    April 25, 2014

    7 First Public Working Drafts of XQuery and XPath 3.1

    Filed under: XML,XPath,XQuery,XSLT — Patrick Durusau @ 8:14 pm

    7 First Public Working Drafts of XQuery and XPath 3.1

    From the post:

    Today the XML Query Working Group and the XSLT Working Group have published seven First Public Working Drafts, four of which are jointly developed and three are from the XQuery Working Group.

    The joint documents are:

    • XML Path Language (XPath) 3.1. XPath is a powerful expression language that allows the processing of values conforming to the data model defined in the XQuery and XPath Data Model. The main features of XPath 3.1 are maps and arrays.
    • XPath and XQuery Functions and Operators 3.1. This specification defines a library of functions available for use in XPath, XQuery, XSLT and other languages.
    • XQuery and XPath Data Model 3.1. This specification defines the data model on which all operations of XPath 3.1, XQuery 3.1, and XSLT 3.1 operate.
    • XSLT and XQuery Serialization 3.1. This document defines serialization of an instance of the XQuery and XPath Data model Data Model into a sequence of octets, such as into XML, text, HTML, JSON.

    The three XML Query Working Group documents are:

    • XQuery 3.1 Requirements and Use Cases, which describes the reasons for producing XQuery 3.1, and gives examples.
    • XQuery 3.1: An XML Query Language. XQuery is a versatile query and application development language, capable of processing the information content of diverse data sources including structured and semi-structured documents, relational databases and tree-bases databases. The XQuery language is designed to support powerful optimizations and pre-compilation leading to very efficient searches over large amounts of data, including over so-called XML-native databases that read and write XML but have an efficient internal storage. The 3.1 version adds support for features such as arrays and maps primarily to facilitate processing of JSON and other structures.
    • XQueryX 3.1, which defines an XML syntax for XQuery 3.1.

    Learn more about the XML Activity.

    To show you how far behind I am on my reading, I haven’t even ordered Michael Kay‘s XSLT 3.0 and XPath 3.0 book and the W3C is already working on 3.1 for both. 😉

    I am hopeful that Michael will duplicate his success with XSLT 2.0 and XPath 2.0. This time though, I am going to get the Kindle edition. 😉

    April 10, 2014

    The X’s Are In Town

    Filed under: HyTime,W3C,XML,XPath,XQuery — Patrick Durusau @ 6:53 pm

    XQuery 3.0, XPath 3.0, XQueryX 3.0, XDM 3.0, Serialization 3.0, Functions and Operators 3.0 are now W3C Recommendations

    From the post:

    The XML Query Working Group published XQuery 3.0: An XML Query Language, along with XQueryX, an XML representation for XQuery, both as W3C Recommendations, as well as the XQuery 3.0 Use Cases and Requirements as final Working Group Notes. XQuery extends the XPath language to provide efficient search and manipulation of information represented as trees from a variety of sources.

    The XML Query Working Group and XSLT Working Group also jointly published W3C Recommendations of XML Path Language (XPath) 3.0, a widely-used language for searching and pointing into tree-based structures, together with XQuery and XPath Data Model 3.0 which defines those structures, XPath and XQuery Functions and Operators 3.0 which provides facilities for use in XPath, XQuery, XSLT and a number of other languages, and finally the XSLT and XQuery Serialization 3.0 specification giving a way to turn values and XDM instances into text, HTML or XML.

    Read about the XML Activity.

    I was wondering what I was going to have to read this coming weekend. 😉

    It may just be me but the “…provide efficient search and manipulation of information represented as trees from a variety of sources…” sounds a lot like groves to me.

    You?

    March 18, 2014

    Balisage Papers Due 18 April 2014

    Filed under: Conferences,XML,XML Schema,XPath,XQuery,XSLT — Patrick Durusau @ 2:21 pm

    Unlike the rolling dates for Obamacare, Balisage Papers are due 18 April 2014. (That’s this year for health care wonks.)

    From the website:

    Balisage is an annual conference devoted to the theory and practice of descriptive markup and related technologies for structuring and managing information.

    Are you interested in open information, reusable documents, and vendor and application independence? Then you need descriptive markup, and Balisage is the conference you should attend. Balisage brings together document architects, librarians, archivists, computer scientists, XML wizards, XSLT and XQuery programmers, implementers of XSLT and XQuery engines and other markup-related software, Topic-Map enthusiasts, semantic-Web evangelists, standards developers, academics, industrial researchers, government and NGO staff, industrial developers, practitioners, consultants, and the world’s greatest concentration of markup theorists. Some participants are busy designing replacements for XML while other still use SGML (and know why they do). Discussion is open, candid, and unashamedly technical. Content-free marketing spiels are unwelcome and ineffective.

    I can summarize that for you:

    There are conferences on the latest IT buzz.

    There are conferences on last year’s IT buzz.

    Then there are conferences on information as power, which decides who will sup and who will serve.

    Balisage is about information as power. How you use it, well, that’s up to you.

    March 15, 2014

    Saxon/C

    Filed under: Saxon,XML,XQuery,XSLT — Patrick Durusau @ 9:41 pm

    Saxon/C by Michael Kay.

    From the webpage:

    Saxon/C is an alpha release of Saxon-HE on the C/C++ programming platform. APIs are offered currently to run XSLT 2.0 and XQuery 1.0 from C/C++ or PHP applications.

    BTW, Micheal’s Why XSLT and XQuery? page reports that Saxon is passing more than 25,000 tests for XQuery 3.0.

    If you are unfamiliar with either Saxon or Michael Kay, you need to change to a department that is using XML.

    January 30, 2014

    XQueryX 3.0 Proposed Recommendation Published

    Filed under: XML,XQuery — Patrick Durusau @ 10:27 am

    XQueryX 3.0 Proposed Recommendation Published

    From the post:

    The XML Query Working Group has published a Proposed Recommendation of XQueryX 3.0. XQueryX is an XML representation of an XQuery. It was created by mapping the productions of the XQuery grammar into XML productions. The result is not particularly convenient for humans to read and write, but it is easy for programs to parse, and because XQueryX is represented in XML, standard XML tools can be used to create, interpret, or modify queries. Comments are welcome through 25 February 2014.

    Be mindful of the 25 February 2014 deadline for comments and enjoy!

    January 14, 2014

    Balisage 2014: Near the Belly of the Beast

    Filed under: Conferences,HyTime,XML,XML Schema,XPath,XQuery,XSLT — Patrick Durusau @ 7:29 pm

    Balisage: The Markup Conference 2014 Bethesda North Marriott Hotel & Conference Center, just outside Washington, DC

    Key dates:
    – 28 March 2014 — Peer review applications due
    – 18 April 2014 — Paper submissions due
    – 18 April 2014 — Applications for student support awards due
    – 20 May 2014 — Speakers notified
    – 11 July 2014 — Final papers due
    – 4 August 2014 — Pre-conference Symposium
    – 5–8 August 2014 — Balisage: The Markup Conference

    From the call for participation:

    Balisage is the premier conference on the theory, practice, design, development, and application of markup. We solicit papers on any aspect of markup and its uses; topics include but are not limited to:

    • Cutting-edge applications of XML and related technologies
    • Integration of XML with other technologies (e.g., content management, XSLT, XQuery)
    • Performance issues in parsing, XML database retrieval, or XSLT processing
    • Development of angle-bracket-free user interfaces for non-technical users
    • Deployment of XML systems for enterprise data
    • Design and implementation of XML vocabularies
    • Case studies of the use of XML for publishing, interchange, or archving
    • Alternatives to XML
    • Expressive power and application adequacy of XSD, Relax NG, DTDs, Schematron, and other schema languages

    Detailed Call for Participation: http://balisage.net/Call4Participation.html
    About Balisage: http://balisage.net/Call4Participation.html
    Instructions for authors: http://balisage.net/authorinstructions.html

    For more information: info@balisage.net or +1 301 315 9631

    I checked, from the conference hotel you are anywhere from 25.6 to 27.9 miles by car from the NSA Visitor Center at Fort Meade.

    Take appropriate security measures.

    When I heard Balisage was going to be in Bethesda, the first song that came to mind was: Back in the U.S.S.R.. Followed quickly by Leonard Cohen’s Democracy Is Coming to the U.S.A..

    I don’t know where the equivalent of St. Catherine Street of Montreal is in Bethesda. But when I find out, you will be the first to know!

    Balisage is simply the best markup technology conference. (full stop) Start working on your manager now to get time to write a paper and to attend Balisage.

    When the time comes for “big data” to make sense, markup will be there to answer the call. You should be too.

    December 11, 2013

    Semantic Web Rides Into the Sunset

    Filed under: CSV,Data,XQuery — Patrick Durusau @ 8:16 pm

    W3C’s Semantic Web Activity Folds Into New Data Activity by Jennifer Zaino.

    From the post:

    The World Wide Web Consortium has headline news today: The Semantic Web, as well as eGovernment, Activities are being merged and superseded by the Data Activity, where Phil Archer serves as Lead. Two new workgroups also have been chartered: CSV on the Web and Data on the Web Best Practices.

    The new CSV on the Web Working Group is an important step in that direction, following on the heels of efforts such as R2RML. It’s about providing metadata about CSV files, such as column headings, data types, and annotations, and, with it, making it easily possible to convert CSV into RDF (or other formats), easing data integration. “The working group will define a metadata vocabulary and then a protocol for how to link data to metadata (presumably using HTTP Link headers) or embed the metadata directly. Since the links between data and metadata can work in either direction, the data can come from an API that returns tabular data just as easily as it can a static file,” says Archer. “It doesn’t take much imagination to string together a tool chain that allows you to run SPARQL queries against ’5 Star Data’ that’s actually published as a CSV exported from a spreadsheet.”

    The Data on the Web Best Practices working group, he explains, will not define any new technologies but will guide data publishers (government, research scientists, cultural heritage organizations) to better use the Web as a data platform. Additionally, the Data Activity, as well as the new Digital Publishing Activity that will be lead by former Semantic Web Activity Lead Ivan Herman, are now in a new domain called the Information and Knowledge Domain (INK), led by Ralph Swick.

    I will spare you all the tedious justification by Phil Archer of the Semantic Web venture.

    The W3C is also the home of XSLT, XPath, XQuery, and other standards that require no defense or justification.

    Maybe we will all get lucky and the CSV on the Web and Data on the Web Best Practices activities will be successful activities at the W3C.

    « Newer PostsOlder Posts »

    Powered by WordPress