Home
FAQ
Feedback
Departments
Discussions
(new topic)
Language Evaluation
PL Courses
Research Papers
Design Docs
Quotations
Genealogical Diagrams
|
|
|
|
xml
| XSLT 2.0 in System.XML V2.0 ? |
|
However ultimately we made the decision that the non-XML syntax (or you could say more SQL like syntax) of XQuery was going to attract more developers in the long run, in the same way the developers on the whole find XPath an easier file-path like syntax to write.
And thus no, Microsoft isn't implementing XSLT 2.0 for the .Net framework, since XSLT 2.0, XQuery 1.0 and XPath 2.0 are just the same query language dressed up in different forms.
More discussion here.
Posted to xml by Ehud Lamm on 5/13/04; 4:36:52 PM
Discuss (2 responses)
|
|
| XQuery Normalizer and Static Analyzer (alphaWorks) |
|
Given an XQuery expression, the tool uses the normalization rules specified in the W3C XQuery Formal Semantics document to convert the given expression to an expression in a core grammar (a subset of the XQuery grammar). The tool also comes with a parser that gives an XML representation of the XQuery expression; this XML representation can be used for manipulating the expression.
Given a normalized expression, the tool again uses the static typing rules specified in the W3C XQuery Formal Semantics document to determine the output type of the expression. The normalized expression can be obtained from the Normalizer, and the static type of the expression can be obtained from the Static Analyzer. The Static Analyzer also checks for semantic errors (such as passing an empty expression to a function call where an integer argument is expected) and generates error messages whenever semantic errors are found during the static type checking.
Get it while it's hot...
Posted to xml by Ehud Lamm on 3/29/04; 10:53:01 PM
Discuss
|
|
| Drafting Legislation Using XML |
|
A well-written case study in XML usage. Connects to Ehud's recent questions about user-friendly XML.
The development of an XML authoring environment for drafting legislation has provided the opportunity to create a "smart" editing environment based on the context provided by the underlying XML structure. In addition, small changes in the drafting approach have provided opportunities for improved efficiencies. The goal for the new environment has been:
- Minimize drafters' attention to the typesetting product,
- Maximize drafters' consideration of the legislative language itself,
- Provide "just-in-time" knowledge support during the drafting process, and
- Provide all this within a WYSIWYG (non-Tags-On) environment.
These goals may seem difficult, if not impossible, to most of us who have been working with SGML and XML. Even XML evangelists don't seem to boast that XML will make life easier for authors. The advantages usually focus on the consumers of the underlying information (i.e., publishing to any device, content-format separation, improved searching) and long-term platform independence. Performing an Internet search for "advantages of authoring in XML" as a phrase produces disappointing results, but authoring itself can be improved when using XML as illustrated in this application. The following features of the application illustrate this point.
Posted to xml by Mark Evans on 1/29/04; 1:51:08 PM
Discuss (2 responses)
|
|
| Versioning XML Vocabularies |
|
XML is designed for the creation of languages based upon self-describing markup. The inevitable evolution of these languages is called versioning. Versioning means adding, deleting, or changing parts of the language. Making versioning work in practice is one of the most difficult problems in computing, with a long history of failed attempts.
General purpose programming language deseigners also face the versioning problem, and use a variety of dirty tricks, pragmas and warnings. Perhaps there's something to be learned from the XML approach, though I don't really see how it can be applied to full feldged programming languages with rich syntactic and semantic constructs.
Be that as it may, this work is relevant for those designing XML vocabularies, arguably the dominant form of DSLs nowadays.
More on XML versioning can be found in the TAG Finding.
Posted to xml by Ehud Lamm on 12/23/03; 1:07:46 AM
Discuss
|
|
| What is missing from or broken about XAML? |
|
Now when I say XAML in this context - i mean the markup format, not the Avalon elements or animations, etc....
The discussion so far isn't very exciting.
Still, some may find this interesting either because they are interested in Longhorn or from the markup language design angle.
Posted to xml by Ehud Lamm on 12/8/03; 2:50:27 PM
Discuss
|
|
| Web Architecture: Extensible Languages |
|
Perhaps this W3C Note dated February 1998 is well known, and it is certainly related to issues I mentioned here repeatedly in the past, but I don't recall seeing it before, and I don't think it was metioned on LtU. I think it merits a link, even if only as an historical data point.
A message should be considered an expression and, if one takes an analogy with programming languages, the analogy should be with an expression or program rather than with a function call. [Or, if considered a function call, strictly, the parameters have to be extended to allow other nested function calls]. In this case, there may be many functions identified, in many interfaces. In other words, don't think of an HTTP message or an HTML document as an RPC call, but rather as the transmission of a expression in some language.
Putting aside the analogy between Web documents/schemas and programs/programming languages, which is used throughout the essay, another reason why it should be of interest to LtU readers is that deals with the design of XML vocabularies. The infrastructure supporting XML vocabularies, including namespaces, schemas, the notion of 'well-formedness' etc. is given preliminary consideration.
Posted to xml by Ehud Lamm on 11/17/03; 3:14:22 PM
Discuss
|
|
| Programming with Rectangles, Triangles, and Circles |
|
This paper proposes extending popular object-oriented programming languages such as C#, VB or Java with native support for XML. In our approach XML documents or document fragments become first class citizens. This means that XML values can be constructed, loaded, passed, transformed and updated in a type-safe manner. The type system extensions, however, are not based on XML Schemas. We show that XSDs and the XML data model do not fit well with the class-based nominal type system and object graph representation of our target languages. Instead we propose to extend the C# type system with new structural types that model XSD sequences, choices, and all-groups. We also propose a number of extensions to the language itself that incorporate a simple but expressive query language that is influenced by XPath and SQL. We demonstrate our language and type system by translating a selection of the XQuery use cases.
Another one from Erik Meijer...
I think this is the first time the name Xen is mentioned here on LtU. Xen, is a hypothetical extension of C# with first-class XML support. The authors give details of the language and its type system, as well as a number of examples to illustrate its elegance and expressive power.
We are fond of discussing APIs vs. programming languages, so the following rule of thumb from the paper should be of interest:
we suggest that should one see an API that uses strings as a representation for some other important artifact, then this API requires re-designing and/or consideration for promotion to the programming language.
Posted to xml by Ehud Lamm on 10/15/03; 2:41:10 PM
Discuss (12 responses)
|
|
| XQuery 1.0 and XPath 2.0 Formal Semantics |
|
Working draft, dated 22 August 2003.
Two important design aspects of [XPath/XQuery] are that it is functional and that it is typed. These two aspects play an important role in the [XPath/XQuery] Formal Semantics.
Ever wanted to see the typing rules for XQuery in all their gory details? This document is for you (yes Wadler is on the editorial team). FLWR experessions and the rest are all there.
And if, on the other hand, the mere mention of formal semantics makes faint, don't worry: the document provides a very gentle introduction.
Posted to xml by Ehud Lamm on 8/28/03; 8:59:04 AM
Discuss (6 responses)
|
|
| Udell: Symbol grounding, XML, and RDF |
|
If the RDF folks have really solved the symbol grounding problem, I'm all ears. I'll never turn down a free lunch! If the claim is, more modestly, that RDF gives us a common processing model for content -- a Content Virtual Machine -- then I will assert a counter-claim. XML is a kind of Content Virtual Machine too, and XPath, XQuery, and SQL/XML are examples of unifying processing models.
Quite a few of our favorite topics appear in this long weblog item from Jon Udell. It is amusing (and vindicating) to see just how badly needed is programming language and linguistic insight for the debates going on in the XML world. And to think people assumed XML is going to free us from languages...
It would be especially interesting to here Patrick's recation Jon's comments, as well as his views on the general issues involved.
Posted to xml by Ehud Lamm on 8/11/03; 7:23:48 AM
Discuss (7 responses)
|
|
| XML and Data Binding |
|
Philip Wadler organized a one-day workshop about this subject, which was also discussed here at length several times.
The site contains the presentations given. Topics discussed include things like JAXB (from Sun), DOMO (IBM) and Xtatic.
Posted to xml by Ehud Lamm on 7/28/03; 8:01:50 AM
Discuss (1 response)
|
|
| Datatype Library Language (XML) |
|
This page describes some experiments that I've been doing with creating a declarative language that can describe datatype libraries for use in RELAX NG and XPath 2.0. It also might be interesting in terms of Part 5 (Datatypes) of DSDL...
Unlike XML Schema, RELAX NG doesn't provide a mechanism for users to define their own types. If they're not satisfied with the two built-in types of string and token, RELAX NG users have to create a datatype library, which they then refer to from the schema...
So the first motivation for putting together a language for datatype libraries is to enable RELAX NG users to construct their own datatypes without having to resort to a procedural programming language or having to learn how to use XML Schema, which might not be suited for their needs.
Another example of XML as language design. Some may even find the proposal of practical interest.
But for me, the attraction is that this just so meta, with XML used to desrcibe XML datatypes, XSLT producing XSLT and so on.
Posted to xml by Ehud Lamm on 7/19/03; 1:59:48 AM
Discuss
|
|
| SQLX |
|
In Oracle9i Database Release 2, Oracle included a new feature known as SQLX, or SQLXML. This is a collection of SQL operators added to the standard SQL library for creating XML from standard relational queries. Basically, you write a SQL statement, include a function call to one of the SQLX calls, and a piece of XML is created. Rocket science? ABSOLUTELY NOT! As a matter of fact, I'd say this approach is incredibly simple and VERY flexible.
This article presents an example of using SQLX to produce RSS feeds. You'll find links to the actual documentation at the bottom of the page.
From our perspective it is interesting to see (a) how SQL was extended and (b) how easy this process was, SQL being essentially a declerative language.
Posted to xml by Ehud Lamm on 7/12/03; 4:48:40 AM
Discuss (1 response)
|
|
| Web Services Federation Language (WS-Federation) |
|
By using the XML, SOAP and WSDL extensibility models, the WS* specifications are designed to be composed with each other to provide a rich Web services environment. WS-Federation by itself does not provide a complete security solution for Web services. WS-Federation is a building block that is used in conjunction with other Web service and application-specific protocols to accommodate a wide variety of security models.
I am consulting on web services security this week, and looks what comes along...
Once more an XML based "language" (or DSL). While it wouldn't be wise to confuse this sort of thing with full blown programming languages, I think the trend seen here is interesting.
Posted to xml by Ehud Lamm on 7/8/03; 11:07:05 AM
Discuss (2 responses)
|
|
| CDuce: a programming language adapted to the manipulation of XML documents |
|
Our point of view and our guideline for the design of CDuce is
that a programming language for XML should take XML types (
DTD, XML Schema, Relax-NG, ...) seriously. The benefit are the following: - static verifications
(e.g.: ensure that a transformation produces a valid document);
- in particular, we aim at smooth and safe compositions
of XML transformations, and incremental programming;
- static optimizations and efficient execution model
(knowing the type of a document is crucial to extract information
efficiently).
Some of CDuce peculiar features:
- XML objects can be manipulated as first-class citizen values:
elements, sequences, tags, characters and strings, attribute
sets; sequences of XML elements can be specified by
regular expressions, which also apply to
characters strings;
- functions themselves are first-class values, they
can be manipulated, stored in data structure, returned by
a function,...
- a powerful pattern matching operation can perform
complex extractions from sequences of XML elements;
- a rich type algebra, with recursive types and arbitrary
boolean combinations (union, intersection, complement) allows
precise definitions of data structures and XML types;
general purpose types and types constructors are taken seriously
(products, extensible records, arbitrary precision integers with interval
constraints, Unicode characters);
- polymorphism through a natural notion of subtyping,
and overloaded functions with dynamic dispatch;
- an highly-effective type-driven compilation schema.
Preliminary benchmarks suggest that despite the
overhead for static type verification, a CDuce
program can run faster (30% to 60%) than an equivalent XSLT
style-sheet (we performed benchmarks with
the xsltproc tools from the Gnome libxslt library).
Posted to xml by Ken Shan on 7/3/03; 4:46:27 PM
Discuss (10 responses)
|
|
| Why use RDF instead of just XML |
|
(via xmlhack)
One way to think about this: the Resource Description Framework (RDF)
is a family of XML applications who agree to make a certain tradeoff
for the sake of cross-compatibility. In exchange for accepting a number
of constraints on the way they use XML to write down claims about the world,
they gain the ability to have their data freely mixed with that of other
RDF applications.
Dan Brickley posted this message (ulitmately about the semantics of RDF) to the rdf-interest mailing list. As you'd have expected, the result is a very amusing thread...
Posted to xml by Ehud Lamm on 6/29/03; 8:55:34 AM
Discuss (1 response)
|
|
| RSS vs. Echo |
|
Not quit a PL issue, more of a data format issue, but none-the-less a big brouhaha in blogging circles (to which LtU belong): RSS vs. Echo.
As a side note, given that both are XML, and that they supposedly contain more-or-less the same data, what is the big deal? Couldn't I just create an XSLT, or something similar, that converts one to the other? Couldn't a Reader be made smart enough to pick the most appropriate feed? In other words, should I as a user, or even as a developer, care?
Posted to xml by Dan Shappir on 6/29/03; 5:08:28 AM
Discuss (9 responses)
|
|
| Infoworld: XML querying proposed as Java standard |
|
Oracle and IBM on Tuesday plan to announce a Java Specification Request (JSR) to define a Java API for invocations of queries written in the W3C standard XML query language, XQuery, according to an Oracle representative.
Sounds interesting. Does anyone here have more information?
Posted to xml by Ehud Lamm on 6/11/03; 8:20:54 AM
Discuss (1 response)
|
|
| What's Wrong with XML APIs |
|
Ostensibly this interview with Elliotte Rusty Harold is about library design, specifically the design of the standard XML APIs. However, as we well know, API design can be very programming language dependent. As a simple example consider the statement [i]n a tree-based API, an XML document is read by a parser, and the parser constructs an object model, typically around a tree with nodes for elements... The entire document is stored in memory. A tree based API in a lazy language wouldn't necessarily have to store the entire document in memory before further processing can be done.
Aside from being a nice source of examples of this sort showing the interaction between language features and library design, this interview is related to one of our recurring topics, namely whether programming languages should offer built in support for XML processing.
Posted to xml by Ehud Lamm on 5/29/03; 2:51:25 PM
Discuss (4 responses)
|
|
| EXSLT: Enhancing the Power of XSLT |
|
The System.Xml.Xsl.XslTransform class provides two primary mechanisms for creating user-defined functions. XSLT stylesheets can contain functions written in C#, Visual Basic .NET or JScript.NET within msxsl:script elements, which can then be invoked from within the stylesheet just as if they were regular XSLT functions. Another approach is to use XSLT extension objects. Extension objects are regular objects whose public methods are accessible from a stylesheet once the objects are added to the XslTransform class through the AddExtensionObject() method.
Yet another example of language extension.
The article gives examples showing the benefits of extending the language, prior to spending time on solving the specific problem at hand.
One quote that is sure to make many LtU readers happy:
One thing to note about creating extension functions is that XSLT was designed to be a functional programming language, meaning that function calls are not intended to have side effects. This means that to preserve the semantics of XSLT, one should avoid creating extension functions that cause side effects by modifying the state of either the arguments passed to it or other external objects. A good rule of thumb in designing XSLT extension functions is that the same input should always produce the same output.
Posted to xml by Ehud Lamm on 5/28/03; 5:38:45 AM
Discuss
|
|
| Tim Bray: The History of RDF |
|
Sometime in the mid-nineties, a guy named Ramanathan V. Guha (everyone calls him Guha because they're scared of “Ramanathan,” go figure) went to work for Apple Computer. He cooked up this metadata format named Meta Content Framework (MCF), and then they built a cool app called Hotsauce, driven by MCF, that represented web sites as little 3-D planetary systems and you could fly around them...
I like to point out from time to time (i.e., whenever I get the chance) that utilizing XML is all about language design. This essay provides some lessons culled Tim's experience with RDF. One of the major lessons Tim discusses, It's the Syntax, Stupid!, is likely to cause concern for some LtU regulars...
Posted to xml by Ehud Lamm on 5/22/03; 2:40:54 AM
Discuss (9 responses)
|
|
| Unifying Tables, Objects and Documents |
|
This paper proposes a number of type-system and language extensions to natively support relational and hierarchical data within a statically typed object-oriented setting. In our approach SQL tables and XML documents become first class citizens that benefit from the full range of features available in a modern programming language like C# or Java. This allows objects, tables and documents to be constructed, loaded, passed, transformed, updated, and queried in a unified and type-safe manner.
I've yet to read this article but it looks interesting.
Posted to xml by Dan Shappir on 4/29/03; 3:03:22 AM
Discuss (16 responses)
|
|
| XML Shallow Parsing with Regular Expressions |
|
(via Keith Devens)
The syntax of XML is simple enough that it is possible to parse an XML document into a list of its markup and text items using a single regular expression. Such a shallow parse of an XML document can be very useful for the construction of a variety of lightweight XML processing tools. However, complex regular expressions can be difficult to construct and even more difficult to read. Using a form of literate programming for regular expressions, this paper documents a set of XML shallow parsing expressions that can be used a basis for simple, correct, efficient, robust and language-independent XML shallow parsing. Complete shallow parser implementations of less than 50 lines each in Perl, JavaScript and Lex/Flex are also given.
Related to our on going "Native XML support" discussion.
Posted to xml by Ehud Lamm on 4/5/03; 4:33:13 AM
Discuss
|
|
| XML Is Too Hard For Programmers |
|
via Scripting News
One response has been a suggestion that we need a language whose semantics and native data model are optimized for XML. That premise is silly on the face of it
Certainly a statement I can live with. Tim Bray gives two technical reasons for this, I can think of one general reason - it's contrary to XML's intent a universal data exchange format.
The rest of the article explains why XML is too hard for programmers, but reads more like why XML is too hard for Perl programmers.
Posted to xml by Dan Shappir on 3/18/03; 1:49:19 PM
Discuss (25 responses)
|
|
| When Is it OK To Invent New Tags? |
|
One more item for my XML as DSL meme machine.
I came across this article via Jon Udell who writes:
The whole idea of language design is a bit odd, when you stop to think about it. We are of course linguistic animals, but we have no knowledge of the process that shaped our languages and not much awareness of their architecture. So I guess you could argue that language design is an unnatural act. I've committed a few such acts -- nothing fancy, but enough to have a sense of the tradeoffs Tim alludes to. I'd add that, even though transformation seems pretty easy, it also winds up being more costly than you'd think.
But I agree with Tim Bray who sparked this comment by saying that:
The cost of inventing a new language is lower than you might think, because it turns out to be fairly easy to transform XML to meet whatever your business needs are. On the other hand, it's higher than you might think, because language design is hard and easy to get wrong.
The hard part really is designing the language. Implementation was always the easy part.
Posted to xml by Ehud Lamm on 3/7/03; 11:09:47 AM
Discuss (1 response)
|
|
| CDuce |
|
CDuce extends XDuce with first-class and late-bound overloaded functions, and generalizes the boolean connectives (explicit union, intersection, negation types).
More info in the discussion group.
Posted to xml by Ehud Lamm on 3/4/03; 5:52:27 AM
Discuss
|
|
| SXSLT presentation, types, and XQuery |
|
I have just returned from PADL/POPL in New Orleans. [The] PADL
presentation SXSLT: Manipulation Language for XML is available online. Quite unexpectedly, the presentation stirred a lively debate on the eternal question of static vs. dynamic typing.
Somehow everything seems to be about typing these days...
Type are important in that they help us specify and verify computational properties of code. Deciding which properties are important to reason about is not as trivial as you may think. This discussion explores this issue, by asking how and why should XML be typed.
Editors, please find some links about topics other than typing. We are dying here...
Posted to xml by Ehud Lamm on 2/5/03; 6:45:17 AM
Discuss
|
|
| Microsoft 'X#' On Tap? |
|
A company official dropped hints at last week's XML 2002 conference in Baltimore that Microsoft is considering the potential for a language that would be optimized to handle data.
The article doesn't have any more details. I normally wouldn't post this sort of link, but we did discuss XML-oriented languages before, so I thought I'd mention this after all.
Posted to xml by Ehud Lamm on 12/17/02; 1:00:58 PM
Discuss
|
|
| What's Wrong With RDF? |
|
A nice summary of the discussions the last couple of days.
I think the major problem is that XML schemas, RDF, and various other meta-data initiatives require the kind of epistemological and ontological thinking most people are not adept for. Who is adept at such thinking? Philosophers, linguists, and - of course - programming language fanatics.
This is the essential difficulty. After that comes the syntax, lack of readable documentation and all the rest.
And oh, my foaf is here. I hope it's valid...
Posted to xml by Ehud Lamm on 11/19/02; 6:11:26 AM
Discuss (8 responses)
|
|
| UBF: Universal Binary Format |
|
Joe Armstrong's UBF is intended as a tasteful alternative to the XML family of standards. It has three layers:
- Transport format - binary format for tree-structured data. This lowest level includes elementary datatypes like symbols, numbers, lists, "BLOBs" and so on. Although a binary format, it tends to be human readable.
- Type system - type definitions for structured schemas/grammars.
- Contracts - formal client/server protocol descriptions, which can be automatically enforced so that protocol violations are never seen by applications.
Described best in the paper Getting Erlang to talk to the outside world from the recent ACM SIGPLAN Erlang Workshop.
A nice feature of UBF is that it is trivial to efficiently encode and decode: a parser can be written as a very neat stack machine, treating each input character as an instruction. It doesn't require any "parser stuff" like look-ahead, backtracking, etc.
Posted to xml by Luke Gorrie on 11/1/02; 1:50:38 AM
Discuss (3 responses)
|
|
| A Formal Model for an Expressive Fragment of XSLT |
|
A formal model of a subset of XSLT is analyzed with extensive examples.
From a "language theoretic point of view" XSLT is shown to
"correspond to tree-walking tree transducers with registers."
Four XSLT language features are the key to its expressiveness:
...Modes enable XSLT to act differently upon arrival at the same element types
...
Variables can be used...to perform joins between data values.
A less apparent application is to use them as a 'look-ahead'.
...we give a fragment of an XSLT program evaluating the truth value
of a binary tree which represents a Boolean circuit.
Essentially, the use of variables allows for a bottom-up
computation. In brief, when arriving at an or-labeled node, the program returns
the correct truth value based upon the truth values of the first and second subtree.
Passing of data values to other template rules can be crucial for performing joins
if the items to be joined do not occur at the same node. Moreover, when node IDs
are present in the XML document, we can use this mechanism to place 'pebbles'
on the input document which enables us to do complicated grouping operations...
XPath can also select siblings and ancestors.
Exactly these four features render XSLT into a quite
powerful transformation language.
(my emphasis)
A semantics of the sub-language is derived with rewrite relations
and several properties of XSLT are proven:
XSLT0 [the sub-language], and hence XSLT, is quite expressive in the sense that
it can simulate most other current XML query languages, and that it can express all join-
free MSO [Monadic Second Order Logic] patterns. The latter even implies that XSLT is strictly more expressive than
other XML query languages. On the negative side we obtain that deciding termination
is undecidable and that XSLT0 is not closed under composition.
Personally, I find that
concise mathematical descriptions
accompanied by examples like this,
that hone in on a language's key features,
provide more insight into how a language works
than verbose language specifications that are hard to grasp
as a whole.
[Neven's Publications,
Interesting survey papers]
(A Formal Model for an Expressive Fragment of XSLT,
Bex, Maneth, and Neven, 2000)
Posted to xml by jon fernquest on 10/17/02; 12:35:08 AM
Discuss (1 response)
|
|
| Xtatic: Native XML processing for C# |
|
Xtatic is a C# extension that further develops the ideas of
XDuce,
"a statically typed analog of XSLT" for writing tree transformers.
(XDuce influenced the design of XQuery's type system.)
In Xtatic "XML trees become built-in values of the language."
Leaves can be any host language object.
Xtatic has a tiny core calculus based on Featherweight Java
[1,
2,
3,
4]
and C# is modelled with a "functional core" that omits assignment.
Regular expression types are used in a pattern matching mechanism that
"includes all of ML-style 'algebraic pattern matching' as a special case"
and includes a statically typed "tree grep" capability.
Patterns are "just regular expression types decorated with variable bindings."
An example of a regular expression type is: "XML<person[name[String],(email
[String]|tel[String])*]>" which describes trees
"containing a name followed by arbitrarily many email
addresses and telephone numbers."
"Native" XML types vs. embeddings...
There have been "many proposals for embedding XML types
into conventional host language types
(algebraic types or class hierarchies).
(E.g., Sun data binding for Java,
HaXML)
These are good, but native XML types are more
natural...
no "impedance mismatch"
e.g., the subtype relation on regular expression
types is exactly inclusion between corresponding
sets of documents..
Posted to xml by jon fernquest on 10/8/02; 11:50:48 PM
Discuss (1 response)
|
|
| o:XML |
|
(via xmlhack)
o:XML is a fully featured object-oriented programming language, whose programs as well as output consists of pure XML.
Personally, I am more interested in human readable languages that support XML natively, than with languages with XML syntax. But anyway...
The language is supposed to have dynamic runtime typing, function overloading, function polymorphism and multiple inheritance.
Does anyone find this kind of language interesting?
Posted to xml by Ehud Lamm on 10/8/02; 1:44:02 AM
Discuss (8 responses)
|
|
| One tree isn't enough |
|
A well know issue for SGML developers, overlapping structures had been brought back to light in XML terms by Patrick Durusau at several conferences including XML Europe 2002 in May, and has given birth to several proposals at eXtreme Markup 2002 in August. Two of the complementary approaches are detailed in the papers announced by Patrick Durusau and Jeni Tenisson.
Just-In-Time-Trees (JITT) is based on dynamically building trees at run time. Layered Markup anNotation Language (LMNL) is non-XML, and is based on the notion of ranges, instead of elements.
Dealing with structured data is always an interesting exercise in abstraction building. The idea of a tree building API, a la the DOM, as proporsed for JITT, may result in more interesting apopraches for providing native XML support in programming languages.
Posted to xml by Ehud Lamm on 10/4/02; 4:41:05 AM
Discuss
|
|
| A formal semantics of patterns in XSLT |
|
Presents the mathematical foundations of an important practical subject
in an easy to understand way.
The author's intention is expressed in an epigram at the beginning of the paper:
"Semanticists should be obstetricians, not coroners of programming languages." (John
Reynolds).
An tutorial on sets, relations, and denotational semantics
is accompanied by a small XML data model similar to the XML DOM API.
The conciseness and lack of ambiguity helps one to understand DOM better.
An actual instance is given when the mathematical model
helped identified an ambiguity in XPATH and influenced language
definition committee decisions.
Instances are also given of when semantics
helps you add language restrictions for efficiency
or "prove equivalences between patterns."
Mathematical formulas are translated into plain English.
Reading like normal language definitions,
they clearly demonstrate that mathematics is compatible with existing
language definition practice.
The semantics was "developed and debugged by transliterating it into the functional language Haskell."
The code is available from the author.
(A formal semantics of patterns in XSLT,
Wadler, 2000)
[
Author's XML Papers]
Posted to xml by jon fernquest on 9/22/02; 1:47:38 AM
Discuss
|
|
| Native XML Scripting |
|
Adding native XML support to ECMAScript. Plus: Jon Udell's comments
Making XML a native datatype is something we discussed in the past. This seems like something that's actually going to happen.
Posted to xml by Ehud Lamm on 9/20/02; 2:34:57 PM
Discuss (7 responses)
|
|
| Wadler: XQuery, a typed functional language for querying XML |
|
XQuery, a typed functional language for querying XML. Philip Wadler. Lecture notes for the Summer School on Advanced Functional Programming, Oxford, August 2002.
Detailed and example driven.
Touches on various typing issues related to XML queries. Also gives insight into the meaning of the classic relational operators (e.g., join) in the context of hierarchical XML data.
Posted to xml by Ehud Lamm on 9/13/02; 7:47:02 AM
Discuss (1 response)
|
|
| The Essence of XML |
|
(via xmlhack)
The Essence of XML. Jerome Simeon and Philip Wadler. FLOPS 2002, Aizu, Japan, 15-17 September 2002 (invited talk).
This paper describes a formalization XML Schema. A formal semantics based on these ideas is part of the official XQuery and XPath specification, one of the first uses of formal methods by a standards body...
...this is the first work to study the relation between named types and structural types, and the relation between matching and validation.
Despite rumors to the contrary, this is not an xml weblog... Still, some serious people are working and writing papers on xml.
This paper gives a type theoretic point of view of schema validation. Subtyping is also discussed.
Posted to xml by Ehud Lamm on 7/22/02; 12:09:08 AM
Discuss (1 response)
|
|
| Extreme Markup Languages 2002 (conference program) |
|
(via xmlhack)
Several interesting talks. For example:
- Drawing inferences on the basis of markup (One useful approach to the semantics of markup is to consider the ‘meaning’ of some markup construct, e.g. a tag T, to be the set of things which are true because of T)
- Binary queries (Typically, queries match single nodes in the document; for k-ary queries, in contrast, each match identifies k locations in the document, connected via some specified relation)
- Comparing markup languages (A prototype Java application (the Comparer) evaluates two document instances that contain the same information and provides both a node-by-node comparison and an "overall similarity metric")
- Implementing the XQuery grammar: From BNF to parse tree to backend data structures (using JavaCC)
- The Layered Markup and Annotation Language (LMAL)
- A type-safe macro system for XML
- Human and machine sign systems
Posted to xml by Ehud Lamm on 7/20/02; 1:15:13 PM
Discuss
|
|
| XSH - An XML Editing Shell |
|
XML::XSH and the xsh executable provide a rich shell environment which makes performing common XML-related tasks as terse and straightforward as using a UNIX shells like bash or csh.
Many people are linking to this article, so I went over and took a look.
It is kind of cool to have an interactive shell where you can play with XML documents, but from our point of view the interesting thing is that you can create shell scripts that perfrom useful XML editing.
Kind of close to my (more specialized) idea of an RSS-AWK.
Posted to xml by Ehud Lamm on 7/12/02; 8:04:25 AM
Discuss (2 responses)
|
|
| Edge Side Includes (ESI) |
|
Edge Side Includes (ESI) is a simple markup language used to define Web page components for dynamic assembly and delivery of Web applications at the edge of the Internet.
Nice use of XML and a nice example of language design (KISS...)
And it looks like Pivia's ESI engine was written by one of the good guys (i.e., webloggers).
Posted to xml by Ehud Lamm on 6/30/02; 2:52:40 AM
Discuss (1 response)
|
|
| A flurry of activity on XQuery |
|
At XML Europe, W3C XML Query working group member Jonathan Robie gave a report on the family of specifications. This follows up on a flurry of recent specifications updates from the group, and from the XSL working group.
Talks about XSLT 2.0, XML Query Use Cases, XPath 2.0, XQuery, XQuery Data Model and XQuery Operators working drafts.
Posted to xml by Ehud Lamm on 5/30/02; 11:11:41 PM
Discuss
|
|
| Gregor, the next generation XSLT compiler |
|
(via xmlhack)
Gregor (and previously XSLTC: see my article) compiles XSLT stylesheets into binary Java classes that can be executed anywhere, stored in databases, collected in jar files, sent over the net, etc. An additional benefit (noticed by Ken Holman of Crane Softwrights Ltd.) is that stylesheet author's Intellectual Property is protected: stylesheets don't have to be distributed in source form...
Gregor's output, Java classes called 'translets' (the term I coined for my first presentation of XSLTC at WWW9 Conference in Amsterdam 2000), are just a regular Java classes of the form Java compilers produce.
Gregor will not be available for free. The web page provides a succinct discussion of the benefits of compiling XSLT, and the architecture of Gregor.
And what a great name for a transformation engine!
Posted to xml by Ehud Lamm on 5/14/02; 11:47:18 PM
Discuss
|
|
| Template Languages in XSLT |
|
(by and via Jason Diamond)
This article will show you how to implement your own specialized template languages by building up a simple example capable of transforming a music database in XML into any form of HTML.
From a software design point of view this is about MVC (separating data from presentation details). From a language design point of view it is about strartified language design, and about building domain specific languages. Also, obviously related to the variety of template engines mentioned here in the past, each having its own template description language.
Posted to xml by Ehud Lamm on 4/13/02; 1:41:44 PM
Discuss
|
|
| What's New in XSLT 2.0 |
|
Since November 16, 1999, when XSLT 1.0 became a recommendation, it has become
quite apparent that certain areas of missing functionality are due for inclusion
in the next version of the language. In this article, we'll show how XSLT 2.0
addresses four of these areas.
- Conversion of result tree fragments to node-sets
- Multiple output documents
- Built-in support for grouping
- User-defined functions (implemented in XSLT)
All issues we discussed here in the past.
Posted to xml by Ehud Lamm on 4/13/02; 10:55:46 AM
Discuss
|
|
| Simple Outline XML: SOX |
|
SOX is an alternative syntax for XML. It is useful for reading and creating XML content in a text editor. It is then easily transformed into proper XML.
To all who bitched about XSL's XML based syntax...
Example (from the web page):
stylesheet>
xmlns=http://www.w3.org/1999/XSL/Transform
version=1.0
template>
match=node()
copy>
apply-templates>
select=node()
Posted to xml by Ehud Lamm on 4/3/02; 2:50:11 AM
Discuss (5 responses)
|
|
| SVGgraphs |
|
This project is intended to build a robust graphing toolkit in Mozilla SVG and XBL.
I've been thinking about something similar so I find this real interesting. But I am not sure I understand the design.
Shouldn't it be enough to define graphing tags (as in the examples on the web site) and create XSLT to translate to SVG? Why make the design Mozilla specific?
Posted to xml by Ehud Lamm on 3/27/02; 7:38:39 AM
Discuss
|
|
| Dynamic Functions using FXSL |
|
Dynamic Functions using FXSL: Composition, Partial Applications and
Lambda Expressions.
This article is a follow-up from the recent publication The
Functional Programming Language XSLT. Provided here is the answer to a
FAQ about functional programming in XSLT: Can functions be created
dynamically during run-time and what are some general ways to achieve
this?. Using the XSLT functional programming library FXSL, examples are
given of performing functional composition, currying and partial
application of functions, as well as of dynamically creating a
function, which corresponds to a lambda expression.
The first article was discussed on LtU some time ago.
The conclusion of the article may influence you to read it.
Posted to xml by Ehud Lamm on 3/20/02; 3:41:34 AM
Discuss (1 response)
|
|
| OPML to SVG |
|
Well, everybody is linking to this, and we do have an xml department...
I've been thinking recently about using SVG to show graphs. There are many examples of this sort of use. It should be possible to design a universal XML format for data intended to be graphed, so that it would be easy to build the needed XSL to translate this format to SVG (with interactive graphs etc.) In this usage scenario instead of creating SVG you use the more natural description of the data, and graphing tools do the rest. Now that I think of it, maybe OPML is suitable for this job. Or maybe someone has already designed exaclty this thing?
Posted to xml by Ehud Lamm on 3/18/02; 8:01:07 AM
Discuss
|
|
| Web Services Conversation Language |
|
(via xmlhack)
WSCL is aimed to supplement interface definitions (e.g., WSDL) with behavioral contracts.
WSCL can be used to spcify Interactions, which are message exchanges, and Transitions, which describe allowed sequences of Interactions.
This is similar to Contracts (a la Holland and Helm, note the uppercase C).
Posted to xml by Ehud Lamm on 3/16/02; 3:55:28 AM
Discuss
|
|
| A Programming Paradox |
|
(via KeithBa's Blog)
...whole forests are dying to compensate for the XML community's one great failure - the lack of a decent programming model for manipulating XML.
Right on.
We are drowning in XML and web related stuff here. Please, someone, post some interesting theory!
Posted to xml by Ehud Lamm on 2/18/02; 1:54:40 PM
Discuss (2 responses)
|
|
| SVG - Open for Business |
|
A short tutorial about Scalable Vector Graphics.
Notice again the new approach for language design: instead of designing a new syntax, create an XML vocabulary. [But please don't forget that XML doesn't free you from having to think about language semantics  ]
In one of the meetings that I attended this week (while being away from LtU) the possibility of creating such a wrapper for an existing (in house) language was discussed. The proposal was to put the translation between the existing language and the XML input, inside the application server. I tried to explain that the translation must be aware of the structure of the language, and thus it is more logical to put it outside the application server code, and closer to the language processor itself [Note: the organization has more than one internal language, so this is not just a quibble]. This approach, of course, has organizational implications... (I was consulting to the group responsible for the application server, and they are being presssured into writing the translation code).
Posted to xml by Ehud Lamm on 2/14/02; 12:34:52 PM
Discuss (5 responses)
|
|
| Reading list on XML and Web Programming |
|
This reading list includes research related to XML and web programming in the context of functional programming languages, particularly Scheme, SML, and Haskell.
Some of these were mentioned on LtU, some await your insightful crticism...
Posted to xml by Ehud Lamm on 2/7/02; 10:59:11 AM
Discuss (1 response)
|
|
| Functional programming in XSLT |
|
(via the Haskell mailing list)
The purpose of this article is to demonstrate beyond any doubt that XSLT is a functional programming language in its own right. To achieve this goal, a reference XSLT implementation is provided of major FP concepts and functions. This article closely follows the contents and layout of John Hughes' article Why functional programming matters.
A proof by demonstration: go and see some XSLT code .
Of course, not everything that can be done should be done.. Anyway, demonstrations of this sort are always interesting.
Posted to xml by Ehud Lamm on 2/5/02; 4:45:13 AM
Discuss (8 responses)
|
|
| DIY Web Services with Radio 8 |
|
Another angle on the web services debate...
Dave shows how to write XML-RPC based web services in Radio Userland.
[It's about time we discussed Radio and UserTalk. Just to show we appreicate the free hosting provided for LtU by Userland. Some people are quite fond of this programming environment.]
Posted to xml by Ehud Lamm on 2/4/02; 11:30:51 AM
Discuss
|
|
| Extreme Markup Languages 2002 |
|
Not for beginners, nor the technically faint. This is the edge, the hard bits, the theory behind the practice, the practice that outstrips current theory -- the Extreme.
At Extreme Markup Languages software developers, markup theorists, philosophers of information, knowledge representers (and presenters!), and the kind of people who like hanging around with them devote the better part of a week to the unfettered pursuit of better understanding of problems of information management, knowledge systems, markup, formal languages, the search for a better parser interface, and the development of markup-related software.
The CFP is up. Sounds like fun (esp. if you are from Canada).
Posted to xml by Ehud Lamm on 2/3/02; 1:38:31 PM
Discuss
|
|
| Web services: Winer on WSDL |
|
Winer's claim that WSDL was invented in such a way that it will only work in Java and .Net environments and "can't work in a dynamic environment; it's a static interface," didn't go unnoticed. Sjoerd tries to explain.
Others think WSDL is the way of the future. We'll see.
By thw way, the other day someone wanted me to explain how XML-RPC is different than CORBA. I managed to say something, but it made XML-RPC and SOAP seem so uninteresting... Is there some online explanation that makes this comparison, and explains why web services should be interesting (from a theoretical, not economical, point of view)? Something like that may come handy next time I am asked about this sutff
Posted to xml by Ehud Lamm on 1/19/02; 2:05:10 AM
Discuss (8 responses)
|
|
| XPipe |
|
(via xmlhack)
XPipe is an approach to manageable, scaleable, robust XML processing based on the assembly line principle, common in many areas of manufacturing.
XPipe is a philosophy and a set of open-source software that implements in philosophy. The idea is that XPipe become the reference implementation of the architecture and also serve as a focal point for XPipe experimentation and discussion.
(Also check the XML-DEV announcement)
It is my feeling, for quite a while, that layering of schemas and pipelining XSLs are the future of XML processing.
A large part of XPipe is the effort to define the XComponent model. XComponents specify (in XML, naturally) how the processing components interact.
I found the website a bit confusing. A good starting point is the glossary.
Posted to xml by Ehud Lamm on 1/7/02; 2:41:15 PM
Discuss
|
|
| RDF query language interpreter |
|
(via xmlhack)
RQL is a typed language following a functional approach (a la ODMG-OQL) and supports generalized path expressions featuring variables on both labels for nodes (i.e., classes) and edges (i.e., properties). RQL relies on a formal graph model (as opposed to other triple-based RDF QLs ) that captures the RDF modeling primitives and permits the interpretation of superimposed resource descriptions by means of one or more schemas.
If you don't want to download RQL, you can play with the online demo
Posted to xml by Ehud Lamm on 11/24/01; 9:13:04 AM
Discuss (1 response)
|
|
| XSLT and XQuery: a difference of culture |
|
Mike Kay from Software AG gave a high level comparison between XSLT and XQuery at the fourth Forum XML, where he concluded that the main differences between the two languages were differences of culture and perspective, but also that XQuery was more ambitious than XSLT and would require more complex optimizations.
Posted to xml by Ehud Lamm on 11/22/01; 9:56:46 AM
Discuss
|
|
| James Clark: The Design of RELAX NG |
|
(via xmlhack)
RELAX NG is a schema language for XML, based on TREX and RELAX. At the time of writing, RELAX NG is being standardized in OASIS by the RELAX NG Technical Committee (TC). A tutorial and language specification have been published by the TC. This paper describes the thinking behind the design of RELAX NG. It represents the personal views of the author and is not the official position of the TC.
Posted to xml by Ehud Lamm on 11/18/01; 12:27:27 PM
Discuss (1 response)
|
|
| IBM XSL Formatting Objects Composer |
|
(via xmlhack)
XFC produces either an interactive onscreen display using Java2D or an output file using PDF. A single formatting engine drives both Java2D and PDF output through a common interface, making XFC the world's first output-independent processor of XSL FO. Other outputs are possible, and some are being developed.
I havem't played with this myself yet, but it seems this can be helpful if you want to build an authoring environment with preview capabilities.
I am not sure how the engine comapres to others. Any clues?
What I really want is some simple template langugae, or wysiwyg editor that can be used to specify formatting of XML data. The result can be an XSLT.
Seems like this should be easy enough to achieve using template engines (e.g., Velocity), tag libs, and other readily available tools.
Posted to xml by Ehud Lamm on 11/6/01; 2:20:30 PM
Discuss
|
|
| Web Services Inspection Language |
|
Service discovery defines a process for locating service providers and retrieving service description documents, and is a key component of the overall Web services model. Service discovery is a very broad concept, which means that it is unlikely to have one solution that addresses all of its requirements. The Universal Description, Discovery and Integration (UDDI) specification addresses a subset of the overall requirements by using a centralized service discovery model. This article will provide an overview of the Web Services Inspection Language (WS-Inspection), which is another related service discovery mechanism, but addresses a different subset of requirements using a distributed usage model. The WS-Inspection specification is designed around an XML-based model for building an aggregation of references to existing Web service descriptions, which are exposed using standard Web server technology.
Posted to xml by Ehud Lamm on 11/5/01; 10:06:28 AM
Discuss (4 responses)
|
|
| XQuery implementation demo |
|
(via xmlhack)
X-Hive has just created an online demo of its XQuery implementation. XQuery is the W3C's query language specifically designed to be used with XML data sources. XQuery provides flexible facilities to extract data from an XML document or a collection of XML documents.
Our XQuery demo works with XML documents stored in a native XML database (as opposed to a flat file system).
Posted to xml by Ehud Lamm on 10/27/01; 8:30:29 AM
Discuss
|
|
| XML Spy 4.0 Public Beta 3 ( XSLT Designer ) |
|
The XSLT Designer is also available as part of the XML Spy Suite 4.0b3
installation and allows you to create XSLT Stylesheets for use with the
Document Editor as well as any other XSLT processor. The unique graphical
design environment of the XSLT Designer provides you with a view of the
content model of your document, XML Schema, or DTD, and allows you to drag
elements and attributes to the design pane, where you can create tables,
paragraphs, and assign any other common style information, such as font and
color settings. This highly intuitive process greatly reduces the time
required to create XSLT Stylesheets - a truly daunting task without the help
of this software. The integrated Preview pane allows you to see your XML
document styled with the Stylesheet you are creating, which lets you preview
your results at any time during the design process.
Posted to xml by Ehud Lamm on 8/24/01; 11:31:42 PM
Discuss
|
|
| Dynamic Web Sites with XML, XSLT and JSP |
|
Your programmers and designers needn't be enemies just because your site uses dynamic data. One way to keep both camps happy is to use an XML based data structure delivered via Java Server Pages.
The approach recommended by this article is based on having designers use XSLT, the JSP is only used to invoke the XSLT engine.
One wonders if graphic designers would find XSLT a useful tool. Seems to me it is too complicated, requires programming skills, and can result in subtle bugs.
Posted to xml by Ehud Lamm on 8/20/01; 8:20:06 AM
Discuss (7 responses)
|
|
| Using XSLT for content management |
|
This is the first installment of Working XML, a column with companion project code that demonstrates the evolution of full-fledged XML applications. In this column, author and software consultant Benoît Marchal introduces XM (XSLT Make), a simple and affordable Web publishing content-management solution that takes advantage of XML and XSLT. Code samples show the development of a wrapper for the XSLT to make it easy for a nonprogrammer to use. XM project code is available by link.
The code itself is in Java.
Posted to xml by Ehud Lamm on 8/7/01; 10:31:20 PM
Discuss
|
|
| RDF Applications with Prolog (II) |
|
Check the first part of this series too.
Interesting highlights of this installment:
- Digs into SWI-Prolog's RDF libraries.
- Extended discussion of Definite Clause Grammars (DCGs) as a way
of generating HTML.
- Comparison of the DCG script with an equivalent XSLT script
(again, line by line), transforming RSS to HTML
Posted to xml by Ehud Lamm on 7/27/01; 12:45:46 AM
Discuss
|
|
| XML's Greatest Hits (And Misses) |
|
This MP3 keynote is very well presented. What caught my attention in what Tim Bray says is that basically we now have the same reuse problem with XML, we have with more traditional software.
So, is the reuse problem due to psychological rather than technological reasons?
Posted to xml by Ehud Lamm on 7/13/01; 2:15:32 AM
Discuss
|
|
| Processing XML with Java |
|
(via HtP)
Welcome to Processing XML with Java, a complete tutorial about writing Java programs that read and write XML documents. This is an approximately 700 page book that will be published by Addison-Wesley in Spring 2002.
Chapter drafts will appear on the site as they are being written. Currently you can view chapter 1.
Posted to xml by Ehud Lamm on 7/3/01; 12:58:12 AM
Discuss
|
|
| XHTML Events |
|
(via xmlhack)
From the new XHTML events draft:
This specification defines the XHTML Event Module, a module that provides XHTML host languages [XMOD] with the ability to uniformly integrate behaviors with Document Object Model (DOM) Level 2 event interfaces [DOM2].
This specification also defines the XHTML Basic Event Module, a module which subsets the XHTML Event Module for simpler applications and simpler client devices, and the XHTML Event Types Module, a module defining XHTML language event types.
The DOM event model is generic and allows registering event handlers. The DOM defines an event flow architecture. The working draft shows how to specify these things using XHTML.
Be careful however since the working draft explicitly states that 'we expect to change the name of this document from XHTML Events to a more inclusive name at the next iteration.'
Posted to xml by Ehud Lamm on 6/11/01; 11:53:54 AM
Discuss
|
|
| XDuce: A Typed XML Processing Language |
|
XDuce is a functional programming language designed to work as a statically typed XML Processing Language. As I gather, the language is intended to process XML input documents and generate XML documents as output. Similar in purpose to XSLT with the advantage of being a true programming language with static type checking.
I stumbled upon XDuce via a DDJ interview with James Clark - A Triumph of Simplicity which is worth reading in it's own right. Clark discusses why markup languages should strive to be as simple as possible. Of course, the fact that the more complex XMLSchema was adopted as the standard (and not Clark's TREX) makes me wonder whether simplicity has really triumphed in the XML world. Near as I can tell, the standards are becoming more and more complex (XSL, XSchema, XQuery, etc).
Posted to xml by Chris Rathman on 6/7/01; 4:22:11 PM
Discuss (1 response)
|
|
| IBM releases web-services flow language |
|
(via xmlhack)
Apparently the language is to be used to describe the composition of web services, which seem to be something like service combinators:
Composition comes in two types: The first type allows to specify the logic of a business process; the second type allows to define the mutual exploitation of Web services of participants in a business process. A brief concepts of composition sketch is provided in an introductory chapter of the document. A detailed discussion of the metamodel behind composition follows. The language proper is described and illustrated by code snippets, followed by an XML schema of the language.
I haven't been able to download the paper, so do let me know if it is any good.
Posted to xml by Ehud Lamm on 5/24/01; 9:42:37 AM
Discuss (1 response)
|
|
| RDF Applications in Prolog |
|
...the Semantic Web is an AI project, and we should be proud of that fact. Not only is it more honest, but it means that we can be clearer about what constitutes prior art, relevant research and literature, similar projects, and available technology.
This is suposed to be the first installment in a series of articles on RDF and Prolog.
The article gives a basic intro to Prolog and to RDF. So if you know one and not the other, it may be particularly useful.
Posted to xml by Ehud Lamm on 4/28/01; 12:46:56 AM
Discuss
|
|
| XML and Scheme (SXML) |
|
Several Scheme facilites for working with XML. Includes query and transformation facilities. Covers both the parsing of XML documents and the production of XML files by Scheme programs. Well worth checking out even if you don't plan on using Scheme.
The overview, focusing on creating high-order tags using Scheme, is also quite interesting.
Posted to xml by Ehud Lamm on 4/15/01; 10:51:33 AM
Discuss
|
|
| Haskell + Xml |
|
Nice paper on processing XML using Haskell. Compares translating DTDs to types with a more relaxed approach. Mentions the XML-like tools a few times too.
Apologies in advance to Irish readers
Posted to xml by andrew cooke on 4/8/01; 12:54:27 AM
Discuss
|
|
| Saxon: The Anatomy of an XSLT processor |
|
This article, by the author of Saxon, is useful for a couple of reasons. It gives some insights into XSLT, it puts some of the relevant Java APIs in context, and it gives some general Java performance tips.
I am great fan of reading source, and I find such overviews very enlightening.
The basic Saxon interpreter is based on the well known interpreter pattern (from the GOF book), but Saxon also uses many other techniques and components.
Posted to xml by Ehud Lamm on 3/12/01; 12:36:38 PM
Discuss
|
|
| RFC: A Little IDL |
|
(via Scripting News).
IDLs are an important part of what's needed for language neutral components, discussed here recently. This page discusses something a little more specific:
I've been staring with incomprehension at various Interface Definition Languages (or IDLs) for XML-over-HTTP protocols, and wondering why they're so complicated. I thought it might have something to do with the kinds of languages and editing environments they're designed for. To find out where the disconnect is, I decided to define a simple interface definition language in XML that's suitable for scripting environments, and see if people find holes in its functionality, or if it's useful, or something we want to do.
Anyway it is a nice example of XML, and the discussion seems pretty interesting (e.g., an XML structure for defining user interfaces).
Posted to xml by Ehud Lamm on 3/6/01; 1:23:35 PM
Discuss
|
|
| XSLT Extensions Revisited |
|
This gives a summary of the extensions being proposed in the next version of XSLT 1.1. Lots of good links in the article for anyone interested in figuring out where XSLT is headed in the future.
XSLT has seen quite a few extensions that are specific to the implementation and vendors, causing incompatibilities. Reminds me of HTML and CSS (with all their inconsitencies).
The main source of controversy cited is the introduction of the <xsl:script> tag. Personally, I'd rather have XSL promoted to a full fledged functional scripting language rather than have to fight the battle of embedded script within a script (the bane of ASP and JSP).
Posted to xml by Chris Rathman on 2/21/01; 6:59:23 AM
Discuss (6 responses)
|
|
| Quilt: an XML Query Language |
|
XML is an extremely versatile markup language, capable of labeling the information content of diverse data sources including structured and semi-structured documents, relational databases, and object repositories. A query language of similar versatility is needed to realize the potential of XML as a universal medium for data interchange.
Web databases and XML querying is a hot topic. I'd go so far as to say that an XQL is something essential. Indeed you can do a lot using XSL, but having a standard query language is crucial from an engineering perspective.
Posted to xml by Ehud Lamm on 2/5/01; 12:58:13 PM
Discuss (4 responses)
|
|
|
