[chubot]

I think Steve Yegge (in another post) said it surprisingly well, and simply. Paraphrasing:

If you have more data than text, use JSON. If you have more text than data, use XML/HTML.

Imagine HTML documents encoded in JSON -- in that case JSON would be ugly and annoying to edit. Now imagine (the more common situation of) structured data serialized as XML. That is ugly and annoying to edit.

Use the right tool for the right job. :)

[ygra]

The two are not interchangeable, though. XML allows mixed content, i.e. something like

    <Foo>Some text <Bar>more text</Bar></Foo>

while JSON does not. So there isn't a 1:1 mapping, at least not in the direction XML → JSON (and the other direction only works if you have a schema that defines data types for the document).

[ingenter]

One can make a 1:1 mapping from XML to JSON, but it is going to be verbose.

    {
       'tag': 'Foo',
       'children': [
           'Some text',
           {
               'tag': 'Bar',
               'children': ['more text']
           }
       ]
    }

or (hello, LISP)

    ['Foo', ['Some text', ['Bar', ['more text']]]]

[jerf]

Yes, that's what I mean. Both XML and JSON can ultimately encode everything, but they both do indeed have strengths over the other. The problem with XML isn't that it is a "bad thing" that should never be used, the problem is that it become trendy and people started using it for all sorts of things it shouldn't have been, combined with a healthy dose of it being used by a lot of people who didn't even understand XML. (XML isn't that complicated, but there's more to it that "tags, attributes, and text".) When you're in a domain where XML really should be used, you're going to regret trying to jam JSON into that domain.

Also, side observation, that Lisp-like encoding is pretty icky as-is (deciding if something is a tag or text by how deep the array is?), and gets worse if the XML uses attributes.

[tel]

I think the various XML Schema-ifications don't help either. XML is fairly poorly defined while JSON is pretty precise. This has more to do with a heavy industry of poorly defined, implied semantics atop XML than anything about the raw format, though.

[jwdunne]

Correct me if I'm wrong but I think you could get away with:

I don't think your second example is much at all like Lisp and I think to actually achieve something lispy, JSON would need some kind of symbol type, so you can do:

  ['Foo, ['Some Text', ['Bar, 'more text']]]

Though, mix in attributes, and it's just a nightmare.

After all, it's not like:

  '(Foo "Some text" (Bar "more text"))

Or with an admittedly not-very-well-thought-out attribute:

  '(Foo "Some text" (Bar ([] (name "Baz")) "more text"))

For:

  <Foo>Some text <Bar name="Baz">more text</Bar></Foo>

Though there may be a better way of representing attributes....

[lisper]

That's Python. In Lisp it looks like:

'(foo "Some text" (bar "more text"))

[sipior]

Thanks, chubot, I think I see the point now.