Don’t drink the JSON coolaid. XML is fine. Better, in many cases, because XML files actually support comments.
In the modern programming world, XML is just JSON before JSON was cool. There was a whole hype about XML for a few years, which is why old programming tools are full of XML.
It’s funny but sad to see the JSON ecosystem scramble to invent all of the features that XML already had. Even ActivityPub runs on “external entities but stored as general purpose strings”, and don’t get me started on the incompatible, incomplete standards for describing a JSON schema.
It’s not just XML either, now there’s cap’n proto and protobuf and bson which are all just ASN.1 but “cool”.
IMHO: XML is a file format, JSON is a data transfer format. Reinventing things like RSS or SVG to use JSON wouldn’t be helpful, but using XML to communicate between your app’s frontend and backend wouldn’t be either.
Most web frameworks contain code to exchange JSON over
XMLHttpRequestfor a reason. XML is and always has been a data transfer format as well as a file format. JSON is, too. The amount ofconfig.jsons I’ve had to mess with…but using XML to communicate between your app’s frontend and backend wouldn’t be either
I don’t see why not? The entrypoint of web frontends is sent as HTML already. I guess that’s based on SGML, XML’s weird and broken cousin. Outputting XML is just a matter of configuring whatever model serialiser from JSON to XML.
There are a few good arguments against XML, but those also work against JSON.
Of course you can use XML that way, but it is unnecessarily verbose and complex because you have to make decisions, like, whether to store things as attributes or as nested elements.
I stand by my statement that if you’re saving things to a file you should probably use XML, if you’re transferring data over a network you should probably use JSON.
Of course you can use XML that way, but it is unnecessarily verbose and complex because you have to make decisions, like, whether to store things as attributes or as nested elements.
That’s a rather annoying shortcoming of XML, I agree. Then again, the choice is pretty inconsequential and the XSD for your data exchange format will lift any ambiguity anyway.
The choice between XML and JSON are a matter of preference, nothing more. XML is much more powerful than JSON and it’s usually a better choice in my opinion, but if you’re writing your applications well, you may as well be sending your data as pixels in a PNG because your serialiser/deserialiser should be dealing with the file format anyway.
The amount of
config.jsons I’ve had to mess with…Yeah, json is not a good config format. As much as xml is not. Please use something like YAML or TOML.
I never moved away from ini I’ve just been sititng back watching you all re-invent the wheel over and over and over and over and over.
It’s a wheel, it’s supposed to turn over and over and over ad infinitum!
/S (because it’s big sarcasm instead of small.)
We were using XML for that before JSON.
Yes and it is a good thing we don’t anymore.
Why? JSON hasn’t given us anything XML hasn’t, except maybe a bit of terseness.
I do agree SOAP is a bit over engineered, though, but that’s not the fault of XML.
XML is much more annoying to read/write by hand
As a pentester, if I see XML in HTTP I start crying.
And there are some truly magic tools.
XSDs are far from perfect, but waaay more powerful than json schema.
XSLT has its problems, but completely transforming a document to a completely different structure with just a bit of text is awesome. I had to rewrite a relatively simple XSLT in Java and it was something like 10 times more lines.
And don’t forget about namespaces. Look at formats like HAL and ODATA that try to add HATEOAS onto JSON.
XSD and XSLT files alone can replace half the JSON applications I’ve seen. I can see why it’s easier to take the barebones JSON notation and reinvent the wheel, but those tiny programs are the “Excel+VBA” of web applications.
That’s my biggest peev about JSON actually. No comments!! WTH!
On one hand I agree, on the other hand I just know that some people would immediately abuse it and put relevant data into comments.
do they do that in xml? never seen that
I have actually seen it in an XML file in the wild. Never quite understood why they did it. Anything they encoded into there, they could have just added a node for.
But it was an XML format that was widely used in a big company, so presumably somewhere someone wrote a shitty XML parser that can’t deal with additional nodes. Or they were just scared of touching the existing structure, I don’t know.
This is why there are none, but I still think it’s dumb. Parsers can’t see comments anyways.
That’s assuming people actually use a parser and don’t build their own “parser” to read values manually.
And before anyone asks: Yes, I’ve known people who did exactly that and to this day I’m still traumatized by that discovery.
But yes, comments would’ve been nice.
There’s comments in the specs and a bunch of parsers that actually inore //
I don’t see comments in the spec?
json spec draft 7
I came into the industry right when XML fever had peaked as was beginning to fall back. But in MS land, it never really went away, just being slowly cannibalize by JSON.
You’re right though, there was some cool stuff being done with xml when it was assumed that it would be the future of all data formats. Being able to apply standard tools like XLT transforms, XSS styling, schemas to validate, and XPath to search/query and you had some very powerful generic tools.
JSON has barely caught up to that with schemes and transforms. JQ lets you query json but I don’t really find it more readable or usable than XPath. I’m sure something like XLT exists, but there’s no standardization or attempt to rally around shared tools like with XML.
That to me is the saddest thing. VC/MBA-backed companies have driven everyone into the worst cases of NIHS ever. Now there’s no standards, no attempts to share work or unify around reliable technology. Its every company for themselves and getting other people suckered into using (and freely maintaining) your tools as a prelude to locking them into your ecosystem is the norm now.
{ "key": "six", "value": 6, "comment": "6 is a bad number. Use five." }That’s not a comment, that’s a field. There’s a reason
var comment = "Increments i by 1"isn’t how you comment in any programs.Yes, it’s a field. Specifically, a field containing human-readable information about what is going on in adjacent fields, much like a comment. I see no issue with putting such information in a json file.
As for “you don’t comment by putting information in variables”: In Python, your objects have the
__doc__attribute, which is specifically used for this purpose.
Please don’t. If you need something like json but with comments, then use YAML or TOML. Those formats are designed to be human-readable by default, json is better suited for interchanging information between different pieces of software. And if you really need comments inside JSON, then find a parser that supports
//or/* */syntax.
People may hate on SOAP but I’ve never had issues with setting up a SOAP client
SOAP requires reading a manual before you get started, but so do the frameworks that try to replace it. APIs are APIs, you rarely need to manually access any of the endpoints unless the backend doesn’t stick to the rules (and what good do any alternatives provide if that happens?) or your language of choice somehow still lacks code generators for WSDL files.
OpenAPI/Swagger is just SOAP reincarnate. The code generators seem to be a bit more modern, but that’s about it really.
RSS/ATOM has to be the best thing to come out of XML
a wate of time
I mean, it’s not wrong…
Wishful thinking
Disagree. I prefer XML for config files where the efficiency of disk size doesn’t matter at all. Layers of XML are much easier to read than layers of Json. Json is generally better where efficiency matters.
TOML or bust
yes.
Aren’t most XML parsers faster than JSON parsers anyway?
It’s not a waste of time… it’s a waste of space. But it does allow you to “enforce” some schema. Which, very few people use that way and so, as a data store using JSON works better.
Or… we could go back to old school records where you store structs with certain defined lengths in a file.
You know what? XML isn’t looking so bad now.
If you want to break the AI ask instead what regex you should use to parse HTML.
Had to work with a fixed string format years ago. Absolute hell.
Something like 200 variables, all encoded in fixed length strings concatenated together. The output was the same.
…and some genius before me used + instead of stringbuilders or anything dignified, so it ran about as good as lt. Dan.
Oof. That sounds horrible
stuff like this is how reddit found out their users comments were being used 😂
I’m sorry which LLM is this? What are its settings? How’d you get that out of it?
And how did it give sources?
I’m sorry which LLM is this?
It’s perplexity.ai. I like it because it doesn’t require an account and because it can search the internet. It’s like microsoft’s bing but slightly less cringe.
How’d you get that out of it?
The screenshot is fake. I used Inspect Element.
Never knew that ddg had an LLM, will check it out. Thanks!
It’s a proxy for a number of LLMs of choice, prompts anonymised before they’re sent. A bit like how their search engine is anonymised Bing, or how their maps are anonymised Apple Maps. I’m happy with the service!
The answer is not real. The tool, on the other hand, is called Perplexity. It “understands” your question, searches the web, and gives you a summary, citing all the relevant sources.
AI is starting to get really smart
I’m starting to like this AI thing…
I hate writing xml with a passion
If you are writing it then you are doing it wrong.
I hate writing a serialized format
I mean, that’s why it’s serialized. It’s not supposed to be written by hand, that’s why you have a deserializer. 🤦
What about writing in xml without any passion ?
This is fine.
Balisage Paper: Fat Markup: Trimming the Fat Markup Myth one calorie at a time
https://www.balisage.net/Proceedings/vol10/html/Lee01/BalisageVol10-Lee01.html
XML is a fine format in comparison to JSON.
I hate writing and reading xml compared to json, I don’t really care if one is slightly leaner than the other. If your concern is the size or speed you should probably be rethinking how you serialize the data anyway (orotobuff/DB)
Listen we all know deep down the solution is to try to parse it with regex
finally accurate ai
Except for obvious typos
XML is fine. Namespaces have a special place in hell though
It is very cool, specifically as a human readable mark down / data format.
The fact that you can make anything a tag and it’s going to be valid and you can nest stuff, is amazing.
But with a niche use case.
Clearly the tags waste space if you’re actually saving them all the time.
Good format to compress though…
YAML for human-written files, JSON for back-to-front and protobuf for back-to-back. XML is an abomination.
YAML is good for files that have a very flexible structure or need to define a series of steps. Like github workflows or docker-compose files. For traditional config files with a more or less fixed structure, TOML is better I think
I don’t mind xml as long as I don’t have to read or write it. The only real thing I hate about xml is that an array of one object can mistaken for a property of the parent instead of a list
I disagree, with a passion.
It is soooo cluttered, so much useless redundant tags everywhere. Just give JSON or YAML or anything really but XML…
But to each their own i guess.
I think we did a thread about XML before, but I have more questions. What exactly do you mean by “anything can be a tag”?
It seems to me that this:
<address> <street_address>21 2nd Street</street_address> <city>New York</city> <state>NY</state> <postal_code>10021-3100</postal_code> </address>Is pretty much the same as this:
"address": { "street_address": "21 2nd Street", "city": "New York", "state": "NY", "postal_code": "10021-3100" },If it branches really quickly the XML style is easier to mentally scope than brackets, though, I’ll give it that.
I’m not sure now that I think about it, but I find this more explicit and somehow more free than json. Which can’t be true, since you can just
{"anything you want":{...}}But still, this:
<my_custom_tag> <this> <that> <roflmao> ...is all valid.
You can more closely approximate the logical structure of whatever you’re doing without leaving the internal logic of the… syntax?
<car> <tyre> air, <valve>closed</valve> </tyre> <tyre> air, <valve>closed</valve> </tyre> <tyre> <valve>open</valve> </tyre> <tyre> air, <valve>closed</valve> </tyre> </car>Maybe I just like the idea of a closing tag being very specific about what it is that is being closed (?). I guess I’m really not sure, but it does feel nicer to my brain to have starting and closing tags and distinguishing between what is structure, what is data, what is inside where.
My peeve with json is that… it doesn’t properly distinguish between strings that happen to be a number and “numbers” resulting in:
myinput = {"1":"Hello",1:"Hello"} tempjson = json.dumps(myinput) output = json.loads(tempjson) print(output) >>>{'1': 'Hello'}in python.
I actually don’t like the attributes in xml, I think it would be better if it was mandatory that they were also just more tagged elements inside the others, and that the “validity” of a piece of xml being a certain object would depend entirely on parsing correctly or not.
I particularly hate the idea of attributes in svg, and even more particularly the way they defined paths.
https://developer.mozilla.org/en-US/docs/Web/SVG/Tutorial/Paths#curve_commands
It works, but I consider that truly ugly. And also I don’t understand because it would have been trivial to do something like this:
<path><element>data</element><element>data</element></path>Maybe I just like the idea of a closing tag being very specific about what it is that is being closed (?).
That’s kind of what I was getting at with the mental scoping.
My peeve with json is that… it doesn’t properly distinguish between strings that happen to be a number and “numbers"
Is that implementation-specific, or did they bake JavaScript type awfulness into the standard? Or are numbers even supported - it’s all binary at the machine level, so I could see an argument that every (tree) node value should be a string, and actual types should be left to higher levels of abstraction.
I actually don’t like the attributes in xml, I think it would be better if it was mandatory that they were also just more tagged elements inside the others, and that the “validity” of a piece of xml being a certain object would depend entirely on parsing correctly or not.
I particularly hate the idea of attributes in svg, and even more particularly the way they defined paths.
I agree. The latter isn’t even a matter of taste, they’re just implementing their own homebrew syntax inside a tag, circumventing the actual format, WTF.
Since XML can have attributes and children, it’s not as easy to convert to JSON.
Your JSON example is more akin to:
<address street_address="21 2nd Street" city="New York" ...></address>Hmm, so in tree terms, each node has two distinct types of children, only one of which can have their own children. That sounds more ambiguity-introducing than helpful to me, but that’s just a matter of taste. Can you do lists in XML as well?
No arrays are not allowed. Attributes can only be strings. But the children are kind of an array.
XML has its strengths as a markdown format. My own formatted text format ETML is based on XML, as I could recycle old HTML conventions (still has stylesheet as an option), and I can store multiple text blocks in an XML file. It’s not something my main choice of human readable format SDL excels at, which itself has its own issues (I’m writing my own extensions/refinements for it by the name XDL, with hexadecimal numbers, ISO dates, etc.).
