I hesitate to say this, but I believe at the time Web developers just weren't really developers. Attempts to bring grown-up development approaches to the Web had to fail because they pushed beyond the capabilities of most. Ironically, the longer-term result was JavaScript of great complexity, so that much of computer science has been reinvented -- but in JavaScript, and Web development has become astoundingly complicated.

XML is hard to read and write for humans and not efficient for machines, while the tools are complex.

The benefits mentioned above are due to schemas, and not the serialization format or tool scope, all of which could be improved independently.

But even if an excellent combo dropped from the sky getting everyone to use it would be very hard due to inertia.

That said, some folks with demanding needs use protocol buffers or thrift, etc. And have for a while.

Don't get me wrong, both formats have their place. I personally find neither to be terribly difficult to read or write, but maybe that's just me. Having used XSD and JSON schema, XSD is a far more complete solution that takes advantage if XML's more sophisticated syntax. I'm not sure how you'd make JSON Schema more expressive without making it hideously difficult to use.

I'm not advocating for universal XML use, nor am I advocating for universal JSON use. I'm advocating for standing back and asking yourself "what am I trying to accomplish?" then choosing the right tool for the job.

As for protobuf: I've seen entire companies built on it. It's amazing what your engineers can do when they don't spend half their time twiddling bits or arguing about data formats. It's a godsend for embedded developers (like me), because JSON, XML, et al are non-starters in that space.

If you’re a developer type, they aren’t too bad. But IT and even some business folks could be trusted with editing ini files.

Others won’t even try to edit xml/json and constitute the great majority of humans.

json is better but the lack of trailing commas dooms it as a more general format.

The tools like XSLT and Xpath are actually very satisfying to use and astoundingly capable, especially when streaming. However, they require deeper learning than most busy Web devs may be comfortable with.

XML is brittle which makes it hard to work with. One tiny syntax error somewhere and your whole XML pipeline fails.

XSLT is powerful but harder to get right than just reshaping JSON.

Because it's ugly and verbose

It really depends on what you are using it for. The hierarchical semantics of XML makes hierarchal data so much easier to read, write, and query than anything you are likely to come up with in json. I’d go as far to argue that the whole reason we don’t have a modern equivalent of Flash is because composability is busted because of the inadequate hierarchical semantics of json.