[vbezhenar]

XML is fundamentally incompatible with commonly used programming data structures, namely lists/arrays and structs/maps. That fundamental mismatch caused a lot of friction when people use XML for data exchange between programs. JSON is clear winner here.

XML is absolutely fine for data that maps naturally to it. For example text markup. While HTML technically is not XML, it's very close to it and XHTML still is a thing. Probably most people wouldn't enjoy using JSON to encode HTML pages.

[embedding-shape]

> Probably most people wouldn't enjoy using JSON to encode HTML pages.

Probably yeah, but also, people don't know how enjoyable it is to just use lists and elements within it to represent HTML. Hiccup is a great example of this where you can do something like:

  [:h1 "Hey"
    [:strong
      {:style {:color "red"}}
      "there"]]

And it just makes sense. I'm sure we've yet to find the best way of writing HTML.

[cess11]

"XML is fundamentally incompatible with commonly used programming data structures, namely lists/arrays and structs/maps. That fundamental mismatch caused a lot of friction when people use XML for data exchange between programs. JSON is clear winner here."

I'm not so sure about this. When you have a schema it becomes possible to generate your object code, and then your only immediate interface with the XML file is a rather simple instruction to unmarshal it, the rest of the time you're dabbling within your programming language of choice.

[tannhaeuser]

> XML is fundamentally incompatible with commonly used programming data structures, namely lists/arrays and structs/maps.

Another way to say this is XML is a grammar formalism that deals purely with serialisation rather than higher-level structures that might be serialised such as co-inductive data structures.

> While HTML technically is not XML, it's very close to it and XHTML still is a thing.

XML and HTML-as-serialisation-format are both subsets of SGML.

[hnlmorg]

It isn’t incompatible. It’s just a massive superset of what is needed.

JSON offers simplicity

YAML offers readability

XML offers a massive feature set.

For what we need 99% of the time, simplicity and/or readability is a much higher requirement.

As for TOML, I honestly don’t understand why anyone likes that.

[dvdkon]

I don't think it's a superset. You can represent any structs-and-arrays data in XML, but you have to make non-trivial mappings to make it work.

The obvious way is to use elements for everything, but then you're mapping both structs and their fields (very different concepts in e.g. C) to elements. Attributes map nicely to struct fields, but they only admit string values.

[hnlmorg]

That’s why it’s a superset ;)

You can map anything to it but that flexibility means you then need to define schemas et al to ensure compliance

The schema thing isn’t actually unique to XML either. you can do the same thing with JSON and YAML too. But in my opinion, if you get into the realm of needing schemas in JSON then you’re at the point where you shouldn’t be using JSON any longer since you’re now violating the “simplicity” argument which is JSONs only real advantage over other formats.

[dvdkon]

Eh, XML is as much of a superset of JSON as the Turing machine is a superset of context-free grammars. The former has all the _power_ of the latter and more, but the mapping between them is non-trivial, far from an embedding.

I think it's fine to say C#'s data model is a superset of Java's or Rust's a superset of C's, but XML and JSON is too far for me, personally.

[hnlmorg]

I didn’t say XML a superset of JSON. I said it’s a superset of common programming abstractions like lists and maps.

This was in response to a comment that said XML was incompatible with such abstractions.

[lolive]

Watch how dict2xml or xml2dict handle JSON to XML automatic mapping. Both format carry 99% of the same structural infos in their respective serialization.

[tclancy]

Huh? I always felt some of the failure/ bad reputation of XML was how it got tortured by devs who did not understand database normalization. If you “get” 3rd form normalization, xml works fine for the relations you describe, unless I am missing something.

To be clear, I am not being snide and would be interested in the cases you’re thinking of.