yeah, the point isn't so much to make it readable, but to allow you to write JSON (as a python dev I love the interoperability with JSON) and then use the capabilities of the DataPower to do stuff with it.
I expect many people were doing this by hand since JSON has replaced XML in a lot of peoples minds, and IBM has created a way to standardize it to make it easier to work with other teams.
That doesn't make this mess any saner, if the point was to apply XML tools to JSON, why not convert to an existing XML dialect with equivalent expressive power, e.g. XMLRPC's serialisation format (which provides a strict superset of JSON capabilities (if you include the nil extension))?
I'm not sure what you're trying to say. The source of the data is irrelevant, XMLRPC w/ nil (and other pre-existing formats I'm sure) are strict supersets of JSON, any JSON document can be converted back and forth between XMLRPC and JSON without data loss. So XMLRPC (or something else with similar capabilities) would give you exactly the same ability to apply XML tools to "JSON sources".
Yep. The rest of it is, well, xml, and it's not going to be as clean looking as json , but why do I need to see the word json at the start and stop of every element? It could at least be abbreviated to just 'j'?
On the plus side I bet the output gzip's up rather nicely in transit assuming you're HTTP GET'ting this data....
Of course not, it's either embedded in a CDATA section or the characters are escaped to the relevant entities: http://www.w3.org/TR/xml/#syntax
> The ampersand character (&) and the left angle bracket (<) must not appear in their literal form, except when used as markup delimiters, or within a comment, a processing instruction, or a CDATA section. If they are needed elsewhere, they must be escaped using either numeric character references or the strings " & " and " < " respectively. The right angle bracket (>) may be represented using the string " > ", and must, for compatibility, be escaped using either " > " or a character reference when it appears in the string " ]]> " in content, when that string is not marking the end of a CDATA section.
I don't really understand why you are being down voted for a technical question. It seems like answering it without giving a downvote as a snarky "ISN'T IT OBVIOUS?" would be sufficient.
I always liked its tungsten cowhide casing [0], but the newer retroencabulator's removal of the expensive to dispose tetraethyliodohexamine greatly cuts down on the recurring maintenance costs.
Because there are already tool chains to handle XML with features not (widely) available for JSON, for example validation (XSD) and transformation (XSLT).
Same reason as SOAP/WSDL: there's good money in consulting so it would be stupid to do something that to simple, people might be able to solve their own problems.
Honestly I get that there an advantage in respect to tooling and this might ease integration into existing system, but I can't help feel that this is introducing an extra level of complexity that you would only find acceptable if you at IBM customer level scale.
The ability to introduce at least some type safety seems nice though.
To use existing XML 1.0 tools on data that comes in as JSON.
It may be somewhat problematic that it doesn't actually support all JSON, because the characters that are permitted (even with escapes) in XML 1.0 text do not include all characters that can appear in JSON values, so if you use it on legal JSON that isn't constrained to be XML 1.0 compatible, it will do something wrong (the docs aren't clear on whether it will fail or just drop the offending characters), so the only place that it seems safe to use is in a constrained internal environment where you control "JSON" to mean "JSON using XML-1.0-safe characters".
This. I'm not claiming it is a good idea... But, DataPower is a highly optimized data processing network appliance for XML. It provides transform speeds with minimal latency, etc. So, to extend its capabilities to a new popular data format (JSON), they transform JSON to XML.
Wait, this can't be right for purely technical reasons: what would this to do a string containing vertical tab characters?
Such strings are illegal in XML. I see nothing in the "JSONx Conversion Rules" that addresses the problem that the strings representable in XML are a smaller set than those in JSON.
[edit] Yup, confirmed. The documentation says: "The \b (backspace) and the \f (form feed) characters are not supported in XML and, subsequently, are not supported in JSONx." So not only does this JSON->XML thing seem obtuse, but it's partial.
> So not only does this JSON->XML thing seem obtuse, but it's partial.
If it wasn't partial, it would be useful -- allowing existing XML tools to easily consume and/or produce JSON tools by applying a JSON -> XML on input and/or XML -> JSON on output would be valuable.
But when the conversion is restricted to an XML-1.0-compatible-subset of JSON, the value drops considerably.
This is SO SO important. I've had to convert JSON to XML and vice versa so many times in order to transfer data to and from legacy code components. No, I don't think an ideal world involves any sort of communication where one side speaks JSON and the other speaks XML, but the current world very much needs a standardization like this.
Insofar as the world needs a JSON->XML conversion standard, it needs one that handles all legal JSON, which this doesn't (it could if it used the same approach to target XML 1.1 instead of XML 1.0, or it could if it used a slightly more complex representation of JSON strings in the XML 1.0, but instead it chose to be a conversion for a restricted XML-1.0-friendly subset of JSON.)
What, is this supposed to be funny? You try converting completely different formats into one another without a standard, and see the kinds of fucked up bug reports you get.
67 comments
[ 3.8 ms ] story [ 133 ms ] threadThe output syntax is even more glorious than you'd think:
<?xml version="1.0" encoding="UTF-8"?> <json:object xsi:schemaLocation="http://www.datapower.com/schemas/json jsonx.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:json="http://www.ibm.com/xmlns/prod/2009/jsonx"> <json:string name="name">John Smith</json:string> <json:object name="address"> <json:string name="streetAddress">21 2nd Street</json:string> <json:string name="city">New York</json:string> <json:string name="state">NY</json:string> <json:number name="postalCode">10021</json:number> </json:object> <json:array name="phoneNumbers"> <json:string>212 555-1111</json:string> <json:string>212 555-2222</json:string> </json:array> <json:null name="additionalInfo" /> <json:boolean name="remote">false</json:boolean> <json:number name="height">62.4</json:number> <json:string name="ficoScore"> > 640</json:string> </json:object>
...and no, I'm not joking, and don't call me Shirley.
I expect many people were doing this by hand since JSON has replaced XML in a lot of peoples minds, and IBM has created a way to standardize it to make it easier to work with other teams.
If you don't want it to be readable, make the darn thing binary and go for efficiency.
On the plus side I bet the output gzip's up rather nicely in transit assuming you're HTTP GET'ting this data....
The XML is 901 bytes, gzip yields 401 (44.5%)
Of course the original JSON is 303 bytes and JSON is already pretty compressible, to 215 bytes (71%) in this case.
Because of what I just mentioned. If they had set the root namespace directly you wouldn't have to declare the namespace prefix on every element.
> The ampersand character (&) and the left angle bracket (<) must not appear in their literal form, except when used as markup delimiters, or within a comment, a processing instruction, or a CDATA section. If they are needed elsewhere, they must be escaped using either numeric character references or the strings " & " and " < " respectively. The right angle bracket (>) may be represented using the string " > ", and must, for compatibility, be escaped using either " > " or a character reference when it appears in the string " ]]> " in content, when that string is not marking the end of a CDATA section.
[0] http://www.floobydust.com/turbo-encabulator/ge_turbo-encabul...
But I read the headline and threw up in my mouth a little.
Honestly I get that there an advantage in respect to tooling and this might ease integration into existing system, but I can't help feel that this is introducing an extra level of complexity that you would only find acceptable if you at IBM customer level scale.
The ability to introduce at least some type safety seems nice though.
It may be somewhat problematic that it doesn't actually support all JSON, because the characters that are permitted (even with escapes) in XML 1.0 text do not include all characters that can appear in JSON values, so if you use it on legal JSON that isn't constrained to be XML 1.0 compatible, it will do something wrong (the docs aren't clear on whether it will fail or just drop the offending characters), so the only place that it seems safe to use is in a constrained internal environment where you control "JSON" to mean "JSON using XML-1.0-safe characters".
Do you have an example of this? I'm curious what character you could have in JSON that you couldn't represent in XML using the '&#' syntax.
Edit: To answer my own question, backspace is an example of such a character.  is not valid XML.
buddy of mine made JSHOL on a whim which creates html from json
http://en.wikipedia.org/wiki/Turducken
Such strings are illegal in XML. I see nothing in the "JSONx Conversion Rules" that addresses the problem that the strings representable in XML are a smaller set than those in JSON.
[edit] Yup, confirmed. The documentation says: "The \b (backspace) and the \f (form feed) characters are not supported in XML and, subsequently, are not supported in JSONx." So not only does this JSON->XML thing seem obtuse, but it's partial.
I wrote a rant about this point a few days ago. Seems more well timed than I had hoped. https://plus.google.com/117593568781545916065/posts/ViNzo5Jj...
If it wasn't partial, it would be useful -- allowing existing XML tools to easily consume and/or produce JSON tools by applying a JSON -> XML on input and/or XML -> JSON on output would be valuable.
But when the conversion is restricted to an XML-1.0-compatible-subset of JSON, the value drops considerably.
XSLT really is the seventh circle of Hell.
I can hear the screams in my sleep.