3 ms·

I am afraid you are still mixing two unrelated things. The document format and potential libraries. Yes, XML libraries tend to be unnecessarily complex (partic

I am afraid you are still mixing two unrelated things. The document format and potential libraries. Yes, XML libraries tend to be unnecessarily complex (particularly with Java) and are often a drag, but this is not about about the format. Even the bureaucracy you mentioned is not inherent to XML itself. You can perfectly use XML without schema insanity, just like JSON. XML is quite more verbose (which might help in a rebuild you mentioned) but is generally quite alike to JSON. Even the performance and memory issues you mentioned are not specific to XML but rather to libraries which went bananas. My point is JSON is not more popular these days because it is inherently superior. JSON is more popular because it was the default choice in a JavaScript environment and - probably - because those who implemented JSON libraries were a tad more sane than their XML counterparts.

rs23296008n1 7y ago
If the spec produces bad implementations often enough then the spec itself becomes suspect. It implies too many misunderstandings are occurring. I find XML tooling far more bulky than that for JSON. For data interchange between C++, python and lua plenty of support for JSON makes this clean and painless. The files are relatively clean and easy to maintain and fast to read/write. I'd not even suggest XML now since initial prototyping showed it too inconvenient for what we do.
- datalist 7y ago
  I dont think we need to go down the where there is smoke there is fire route. These implementations are bad for a variety of reasons but not because XML is bad itself. As I said, XML on Java is often a hassle but that is neither XML's fault nor Java's but the responsibility of those developers who thought going bananas on interfaces, factories, and alike is actually a good idea. As for XML, its syntax is somewhat more verbose than JSON's but thats about it. ----- Just to provide one very basic example XML <people> <person> <name>John Doe</name> <dob>2000-01-01</dob> </person> <person> <name>Peter Smith</name> <dob>2001-01-01</dob> </person> </people> JSON [ { "name": "John Doe", "dob": "2000-01-01" }, { "name": "Peter Smith", "dob": "2001-01-01" } ] Apart from XML being more verbose (but also providing more context), these two documents are virtually identical, they even have the same number of lines. And if one used XML actually idiomatically the example would slim down by a lot <people> <person name="John Doe" dob="2000-01-01" /> <person name="Peter Smith" dob="2001-01-01" /> </people>
  - deleted 7y ago
    [deleted]
  - rs23296008n1 7y ago
    In the first example you show simple but verbose XML. Then you show typical JSON. Then you show concise XML; this last example shows the parsing overhead when XML is being concise. Suddenly you go from just tags with content between them to key=value pairs and a flag to skip a check for the closing tag. Parser complexity creeps in on that last example in particular. The first example was probably in the form the (possibly) easiest of all three examples to parse. This all shows XML needing to support at least two different but related mechanisms. I'm not saying any of this is bad or that it makes parsing impossible: its just a source of complexity. JSON has key value syntax as well. XML has this flexibility but it quickly adds up. This is not a fault - it's the whole point of XML. I'm not sure what your goal here is. I've got hard data for the work I'm doing showing XML doesn't provide significant benefits in exchange for its added complexity. Others likely have done similar for their purposes. Matching the solution to the problem is generally a good idea. Are you perhaps too biased towards a single solution without considering the alternatives? I don't/can't know. Something to consider. (I don't consider XML as useful now because it has shown itself no longer a match for the types of problems I'm solving YMMV)
    - datalist 7y ago
      I provided exactly one example and that was a comparison between XML and JSON. The follow up was just an additional remark that idiomatic XML would be even shorter. I am afraid I cannot follow your argument about complexity as any parser worth its money WILL BE ABLE to parse XML without any significant overhead and - as I mentioned numerous times - issues do not stem from how an XML document is built but from the fact that (mostly) Java parsers attempted to implement about each possible OOP pattern instead of going for KISS. The code over-engineering is the issue, not the document structure. I am really not sure what point you are trying to make and why you are diverting from the actual topic I addressed. I am slightly surprised about your bias remark, as it seems to be you who is strongly biased towards JSON despite my initial comments as well as the "significant benefits" as I never made any such claim, on the contrary it is you once again who seems to make such about JSON. Maybe you can post the "hard data" you referred to. Bottom line (once again), XML and JSON are extremely similar and saying one is better than the other simply shows lack of experience. Then of course, if you parse 70 kilobyte JSON documents with a lean parser, but parse 12 megabyte XML documents with a typical Java parser, nobody needs to be surprised the latter will perform abysmally compared to the former, but that would be a whole different subject.

rs23296008n1 7y ago

If the spec produces bad implementations often enough then the spec itself becomes suspect. It implies too many misunderstandings are occurring. I find XML tooling far more bulky than that for JSON. For data interchange between C++, python and lua plenty of support for JSON makes this clean and painless. The files are relatively clean and easy to maintain and fast to read/write. I'd not even suggest XML now since initial prototyping showed it too inconvenient for what we do.

datalist 7y ago
I dont think we need to go down the where there is smoke there is fire route. These implementations are bad for a variety of reasons but not because XML is bad itself. As I said, XML on Java is often a hassle but that is neither XML's fault nor Java's but the responsibility of those developers who thought going bananas on interfaces, factories, and alike is actually a good idea. As for XML, its syntax is somewhat more verbose than JSON's but thats about it. ----- Just to provide one very basic example XML <people> <person> <name>John Doe</name> <dob>2000-01-01</dob> </person> <person> <name>Peter Smith</name> <dob>2001-01-01</dob> </person> </people> JSON [ { "name": "John Doe", "dob": "2000-01-01" }, { "name": "Peter Smith", "dob": "2001-01-01" } ] Apart from XML being more verbose (but also providing more context), these two documents are virtually identical, they even have the same number of lines. And if one used XML actually idiomatically the example would slim down by a lot <people> <person name="John Doe" dob="2000-01-01" /> <person name="Peter Smith" dob="2001-01-01" /> </people>
- deleted 7y ago
  [deleted]
- rs23296008n1 7y ago
  In the first example you show simple but verbose XML. Then you show typical JSON. Then you show concise XML; this last example shows the parsing overhead when XML is being concise. Suddenly you go from just tags with content between them to key=value pairs and a flag to skip a check for the closing tag. Parser complexity creeps in on that last example in particular. The first example was probably in the form the (possibly) easiest of all three examples to parse. This all shows XML needing to support at least two different but related mechanisms. I'm not saying any of this is bad or that it makes parsing impossible: its just a source of complexity. JSON has key value syntax as well. XML has this flexibility but it quickly adds up. This is not a fault - it's the whole point of XML. I'm not sure what your goal here is. I've got hard data for the work I'm doing showing XML doesn't provide significant benefits in exchange for its added complexity. Others likely have done similar for their purposes. Matching the solution to the problem is generally a good idea. Are you perhaps too biased towards a single solution without considering the alternatives? I don't/can't know. Something to consider. (I don't consider XML as useful now because it has shown itself no longer a match for the types of problems I'm solving YMMV)
  - datalist 7y ago
    I provided exactly one example and that was a comparison between XML and JSON. The follow up was just an additional remark that idiomatic XML would be even shorter. I am afraid I cannot follow your argument about complexity as any parser worth its money WILL BE ABLE to parse XML without any significant overhead and - as I mentioned numerous times - issues do not stem from how an XML document is built but from the fact that (mostly) Java parsers attempted to implement about each possible OOP pattern instead of going for KISS. The code over-engineering is the issue, not the document structure. I am really not sure what point you are trying to make and why you are diverting from the actual topic I addressed. I am slightly surprised about your bias remark, as it seems to be you who is strongly biased towards JSON despite my initial comments as well as the "significant benefits" as I never made any such claim, on the contrary it is you once again who seems to make such about JSON. Maybe you can post the "hard data" you referred to. Bottom line (once again), XML and JSON are extremely similar and saying one is better than the other simply shows lack of experience. Then of course, if you parse 70 kilobyte JSON documents with a lean parser, but parse 12 megabyte XML documents with a typical Java parser, nobody needs to be surprised the latter will perform abysmally compared to the former, but that would be a whole different subject.