Comment by nithril

12 hours ago

XSLT/XPath have evolved since XSLT 1.0.

Features are now available like key (index) to greatly speedup the processing. Good XSLT implementation like Saxon definitively helps as well on the perf aspect.

When it comes to transform XML to something else, XSLT is quite handy by structuring the logic.

18 comments

nithril

Reply
sam_lowry_  11 hours ago

Keys were a thing in XSLT 1.x already.

XSLT 2+ was more about side effects.

I never really grokked later XSLT and XPath standards though.

XSLT 1.0 had a steep learning curve, but it was elegant in a way poetry is elegant because of extra restrictions imposed on it compared to prose. You really had to stretch your mind to do useful stuff with it. Anyone remembers Muenchian grouping? It was gorgeous.

Newer standards lost elegance and kept the ugly syntax.

No wonder they lost mindshare.

  • jerf  9 hours ago

    "Newer standards lost elegance and kept the ugly syntax."

    My biggest problem with XSLT is that I've never encountered a problem that I wouldn't rather solve with an XPath library and literally any other general purpose programming language.

    When XSLT was the only thing with XPath you could rely on, maybe it had an edge, but once everyone has an XPath library what's left is a very quirky and restrictive language that I really don't like. And I speak Haskell, so the critic reaching for the reply button can take a pass on the "Oh you must not like functional programming" routine... no, Haskell is included in that set of "literally any other general purpose programming language" above.

    • yoz  6 hours ago

      Serious question: would it be worth the effort to treat XSLT as a compilation target for a friendlier language, either extant or new?

      There's clearly value in XSLT's near-universal support as a web-native system. It provides templating out of the box without invoking JavaScript, and there's demand for that[1]. But it still lacks decent in-browser debugging which JS has in spades.

      [1] https://justinfagnani.com/2025/06/26/the-time-is-right-for-a...

      2 replies →

    • smrtinsert  3 hours ago

      Pretty true. I created a simplified XPath layer to a stax parser back in the day and it was a break through in xml usability.

echelon  9 hours ago

XSLT just needs a different, non-XML serialization.

XML (the data structure) needs a non-XML serialization.

Similar to how Semantic Web's Owl has four different serializations, only one of them being the XML serialization. (eg. Owl can be represented in Functional, Turtle, Manchester, Json, and N-triples syntaxes.)

  • int_19h  3 hours ago

    XQuery is pretty close to "XSLT with sane syntax", if that's what you mean.

    But the fundamental problem here is the same: no matter what new things are added to the spec, the best you can hope for in browsers is XSLT 1.0, even though we've had XSLT 3.0 for 8 years now.

  • marcosdumay  5 hours ago

    > XML (the data structure) needs a non-XML serialization.

    KDL is a very interesting attempt, but my impression is that people are already trying to shove way too much unnecessary complexity into it.

    IMO, the KDL's document transformation is not a really good example of a better XSLT, tough. I mean, it's better, but it probably can still be improved a lot.

  • alganet  9 hours ago

    > XML (the data structure) needs a non-XML serialization.

    That's YAML, and it is arguibly worse. Here's a sample YAML 1.2 document straight from their spec:

        %TAG !e! tag:example.com,2000:app/
    ---
    - !local foo
    - !!str bar
    - !e!tag%21 baz

    Nightmare fuel. Just by looking at it, can you tell what it does?

    --

    Some notes:

    - SemWeb also has JSON-LD serialization. It's a good compromise that fits modern tooling nicely.

    - XML is still a damn good compromise between human readable and machine readable. Not perfect, but what is perfect anyway?

    - HTML5 is now more complex than XHTML ever was (all sorts of historical caveats in this claim, I know, don't worry).

    - Markup beauty is relative, we should accept that.

  • j45  2 hours ago

    This is very understandable, where I get left at is the remaining gap between XML and XSLTs and where JSON or another format can cover.

    Trying to close the gap often ends up creating more complexity than intended, or maybe even more than XML in some hands.

    It definitely would be an interesting piece.

thechao  10 hours ago

Can you name a non-Saxon XSLT processor? I'd really like one. Preferably, open-source.