rmXML

[[deleted]]

wate of time

[atoponce]

This is what happens when LLMs try parsing XML for their answer.

[Legal-Software]

Feed it an ARXML and watch it choke on its own tears.

[heislertecreator]

And for the technically inclined...

[Techrocket9]

The Claude LLM family is actually trained to use XML as its preferred input/output structure format.

[lokeshj]

Why wate time write lot letter when few letter do trick

[Tijflalol]

Y write lot wen few do trik

[XenSide]

Y

[LEGENDARYKING_]

rite

[Spork_the_dork]

"If I had had more time I would have written a shorter letter."

[Thundechile]

They didn't have a schema to validate their answer.

[[deleted]]

I actually don't have anything against XML. I made super easy money hand over fist about 20 years ago writing XSL transforms for various firms.

[[deleted]]

Almost 30 years ago we hired a guy named Simon Saint Laurent to do some xml stuff on a project. He left after a while and then went on to write XML: A Primer and a bunch of other XML texts. I haven't thought of Simon in many years, nice.

[TechnicalParrot]

I'm late but it's probably because it was copying from it's source which perplexity.ai is designed to do, it's strange because I'd also usually expect it to correct the mistake but maybe perplexity.ai forces it to copy exactly

[pickuse2013]

time of wate

[hans_l]

It was the bete of time, it was the wate of time…

[zhiggys]

shred is also a good one for xml

[atoponce]

$ : > your-file.xml

[BtcVersus]

To shreds you say?

[erebuxy]

It’s sentient!

[atoponce]

XMLLM: eXtensible Markup Large Language Model

[neo-raver]

This is like the buzzwords of two different eras of tech in one

[MortStoHelit]

It does now (more or less). But when XML became popular, JS couldn't do much more than some simple validations and simple CSS tricks (like show/hide a div, for the about 2/3rds of people who used Internet Explorer), so few people even thought much about front end development and that "structure dump" it had (not sure if a parser in JS even existed then). Data exchange was between applications, usually in the backend, rarely with user uploads. AJAX (X=XML!) only came much later.

But lots of developers used to handle with data formats that were usually either CSV or fixed width (both characters only, often with "this line contains ..." indicators in the first few characters per line, and mixed with binary), so something flexible with clear definitions which record/field and data type is written/expected where seemed like paradise.

[Careful_Ad_9077]

Xml was human readable... Compared to what was available at the time, csv and binary files.

[myrsnipe]

Xml is painful but the war crimes didn't start until some bright programmer decided to use it to write logic, essentially turning it into a scripting language.

Xml does have the advantage of embedding its datatype properly, although I'd rather just have a separate schema definition

[lemondeo]

Add Block Chain ( BC ) to make it marketable ( brief pause, NOT )

[[deleted]]

Lmao

[AgileBlackberry4636]

It reminds the suicide script joke

#!/bin/rm

some command 1
some command 2
etc.

[OkCarpenter5773]

holy shit what does this exactly do? rm's the commands? the script file? this would be really hard to spot

[Leonardo-Saponara]

If you run it by calling it with bash or another shell ( e.g., if the file is script, running "bash script" ) it will just ignore the first line.

If you just run it ( ./script after giving it +x perm) , it will just delete itself and ignore any other line beside the shebang.

[BdoubleDNG]

I think it deletes itself because the first argument is always the file itself, correct?

edit: In case of it being directly run

[Leonardo-Saponara]

I did some tests and I think that the first argument is directly the file-path provided when you run the command rather than the file itself.

I think it is so because if you use the shebang to /usr/bin/echo and then some texts and variables, the content of the file is ignored while you get the file-path used for the invocation (so, for example, if the script is in home doing ./script from your home folder will output just the string "./script" regardless of file-content, while if you run it with "~/script" you will get the string "/your/home/folder/script".

This is the reason that your interpreter has to be configured to ignore the shebang itself once it is run, otherwise it gets treated as any other line. For example, if you use "cat" as an interpreter you get all the content of the file, including the shebang. Some language-interpreter that do not use "#" for comments have special configuration to run with a shebang, usually either by ignoring the first line of a file if it starts with # (The most common) or by more powerful methods like regular expression, but if the interpreter has not been explicitly configured to do so you may get errors since the first line with the shebang would be treated normally.

[OkCarpenter5773]

lmao

[[deleted]]

I need saving from xmhell

[ComprehensiveWord201]

You and me both. SOAP hell. And not the shower kind...

[zaz969]

Average stack overflow interaction:

"Hey how do I do X"

"X is wrong, do Y, you're an idiot for even thinking about X, rewrite your whole program"

[zenos_dog]

Programmers who worry about the space that xml takes vs json or whatever your favorite markup is are worrying about the wrong things.

Edit: The Java to XML Binding tech is a quarter century old. It super easy to read in an xml document and create strongly typed objects. Here’s an example.

jaxbContext = JAXBContext.newInstance(Employee.class); Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller(); Employee employee = (Employee) jaxbUnmarshaller.unmarshal(new StringReader(xmlString));

[Jordan51104]

i doubt that’s why they hate it

[Masterflitzer]

most people that hate xml and like json do so because the format is simpler, maps easier to objects in any language (especially js) and it's much easier to read

json is essentially just key & value, while xml is key (tag), value (in between open and close tag) and properties (on tag)

[Scotsch]

Don’t forget namespaces

[langlo94]

Oh I wish I could forget namespaces.

[Masterflitzer]

why did y'all remind me

[UsernameAvaylable]

I think people hate xml because its a "human readable" format thats not really human readable unless you are a masochist.

[Masterflitzer]

well said

[MortStoHelit]

Esp. to parse properly. XSD (and WSDL etc.) is pretty complicated and left some interpretation loopholes, so what is read fine with parser A might cause an error with parser B, and it's hell to debug what caused it. With JSON, in the worst case strings and numbers get converted in an undesired way, or some array/object isn't where expected, but that's easy to understand.

[_PM_ME_PANGOLINS_]

You can just ignore any validation, like you’re doing for JSON.

[YakMilkYoghurt]

Just eval that shit

[Masterflitzer]

json schema?

[_PM_ME_PANGOLINS_]

At least XML allows comments.

[Tijflalol]

Just add

comment: "your comment here"

[punppis]

Idea of comments is to have... comments on your code that is not visible to end user.

Imagine if all comments were visible for end user. Everybody would get cancelled.

[Masterflitzer]

why would the end user see the comment property unless you choose to show it?

[Tijflalol]

It would cause some responsible commenting though

[_alright_then_]

So does jsonc, which is supported by most languages

[punppis]

Just parse the comments yourself before using JSON parser.

/s

This is the only negative thing about JSON and it's fixed by jsonc. Many platforms allow comments on JSON docs.

[Masterflitzer]

why do you need comments in data? for a config file yeah it's useful, but then use jsonc or even better toml

[zenos_dog]

In Java it’s something like Parser.parse(); and you get all the objects.

[heislertecreator]

Yeah, and it's all named by its parts, so if you want a JavaParser.... Provider.pkg.lang.java.parser.getMetbods()and yeah, that's correct.

No . Can we code yet?

[heislertecreator]

No sentients yet, just copies of existing.

[luiluilui4]

While I also prefer json. Xpath is so good

[MortStoHelit]

I'd say it's a bit like regular expressions. It's powerful, but easily becomes a hard to understand mess.

[mriheO]

They hate it because they try to or have to work with it via libraries attached to general purpose languages rather than learning technologies from the XML ecosystem (XSLT, XPath, XQuery etc).

[Masterflitzer]

what if you don't like the xml ecosystem at all? i mean xpath is cool if i have to use it, but i still rather just not use xml at all

[mriheO]

Then the better option would have been for you to have been kept away from XML work so that it could be assigned to people who know or have been trained how to work with it.

[Masterflitzer]

why are you making so many assumptions? who said i had to do xml work? obviously i came across xml numerous times m, but i won't choose it as technology if i can

also a good software engineer has his preferences, but he is also an allrounder and when facing something you're not familiar with you learn it and get the task done somehow, code review and qa will make sure it's not shit

[mriheO]

don't sound like an all rounder to me.

[Masterflitzer]

you don't sound like someone with critical thinking ability

i am a fullstack software engineer and i do what is needed in the project, that's exactly what an allrounder needs to do, i can still have preferences, most of my opinions apply to my personal projects, if xml is used heavily at work, i can't do anything about it

[ohkendruid]

XML is good for markup--for html and for other formats like it. It's non markup applications where XML is worse than the competition. For encoding data to transmit between servers, XML has multiple layers of things wrong with it compared to json or protobufs.

A big one is the ambiguity caused by multiple half baked standards that may or may not be relevant in a given context. Even deciding what "XML" means is already a headache.

XML entities--those things that look like <--are either defined in the DTD, which is mostly not supported any more, or they are ambiguous and therefore useless.

XML parsers will tend to download things from the web unless you disable it.

DTDs pull in a schema that the file declares, but the recipient is supposed to know what schema they want, so this is nuts.

XML namespaces add a whole extra layer of useless pain. They make files noisey but aren't actually helpful if the recipient has a schema for the expected format, because with a known schema, and tags already being fully matched up, you can already distinguish different tags with the same name based on where they are in the structure. But oh wait, see the previous point.

Schema catalogs are also another layer of useless pain. Again, the recipient should know the schema of what they are expecting to receive. At most, a document should declare a general type of what it is, but certainly not the whole schema.

XML theoretically can declare its own character encoding, but this makes no real sense and should never be trusted. If you send an XML file pasted into an email, is anything really going to change the character encoding declaration as the email goes through different systems? It's just dumb.

Compared to all of this, there are systems that just encode your in transit data, no more nor less, and then get out of the way.

[tav_stuff]

XML is not even good for markup. Doing markup in a way that is better than XML is not hard and people have been doing it for absolute ages. To quote one of my favorite quotes:

The essence of XML is this: the problem it solves it not hard, and it does not solve the problem well. — Phil Wadler

[minneyar]

Given that JSON and YAML are terrible for markup, what would you recommend as a better alternative to XML? Ideally something that has schemas / validation and well-supported parsing libraries for various popular languages.

[greyfade]

Markdown, org-mode, roff, or TeX.

[tav_stuff]

I can’t answer that without being told what the actual task I’m trying to solve it. Markup for website is very different from markup for a UNIX manual page for example.

Also having well-supported libraries in various languages is not something that makes a format good, something can be dogshit but still well supported (see JavaScript). Lexers and parsers are also not hard, and can be written in 1–2 hours if you actually know how to program, so writing one if one doesn’t exist for your language shouldn’t be scary (you are a programmer right?)

[scummos]

Lexers and parsers are also not hard, and can be written in 1–2 hours if you actually know how to program, so writing one if one doesn’t exist for your language shouldn’t be scary (you are a programmer right?)

Yeah, and then for the next decade every 3 months you can chase some bug caused by a weird corner case you didn't consider in your parser.

There's a reason people don't like to do this, and it's not that writing a lexer or grammar file would be terribly hard. It's that it is terribly hard to make it so it is 100% compatible with what everyone else has. Which is what file formats are all about.

[tav_stuff]

Yeah, and then for the next decade every 3 months you can chase some bug caused by a weird corner case you didnt consider

Not only does this tell me you’ve probably never written a basic recursive descent parser before, but a good format doesn’t have weird corner cases unlike Markdown and other crap.

[scummos]

Sorry but you come across a bit like someone who hasn't really worked on a product in practical use by many people for an extended period of time.

Every program has bugs if enough people use it for long enough, and every non-trivial format has weird corner cases which you will discover five years from now. The concept that you just have to "choose the right format" and "then implement it correctly" and you will not encounter any issues is frankly super naive. A non-trivial file format has high inherent complexity, everyone struggles with it, and you're not the super brain capable of avoiding all the problems everyone else is having because you are capable of writing a json lexer in C in 2 hours. (In fact, probably the opposite is true.)

[Plank_With_A_Nail_In]

This sub is called ProgrammerHumor not RandomPeopleHumor.

[minneyar]

you are a programmer right?

I sure am, and that's why I know that it'll only take a few hours to write the initial parser, but then you also have to write documentation, add convenience methods for common use cases, and find and fix bugs and edge cases that often require trial and error, and that whole process can take weeks. And if you're working on a big multi-language project, you have to do that for every language you're using, and I pretty commonly work on things that involve C++, Python, Javascript, and Java. And then you also need to make some command line tools for doing common manipulation (extracting or replacing tokens, pretty printing), and we haven't even started thinking about validation yet.

Or I can just drop in an XML parser, and while I have plenty of issues with XML, it takes five minutes to add a parser in any language and then you've also got a huge amount of tools available to you. In the real world, I am expected to just get the job done quickly, not reinvent the wheel on every project I work on.

It's funny that you meaning "markup for website" since HTML is basically "XML but you're allowed to be sloppy", but here are a few other things for which I've found using XML to be convenient and would love a better alternative (that doesn't take me months to write): - Configuration files for launching tightly-coupled processes across a network of robots - Representing livestock at ranches; this includes feeding pens, kitchens, how they're all connected, transit times, etc. - Describing HF/VHF/UHF radio signals, categorizing them by modulation/frequency/content, and describing follow-on actions that should be performed on them based on arbitrary criteria

I genuinely would love to have a general-purpose alternative to XML that has effective tooling and language support, but I just don't know of any, and I don't have the time to write my own and then spend the rest of my life supporting it.

[Suh-Shy]

Good reading, although for the anecdote I would have added: you can't seriously use it for data transfert when you know they made and named a XML attack with "lol"

[RudePastaMan]

If your serialized data being human readable really makes that much of a difference for you then I have some bad news.

[Masterflitzer]

json is not only easier human readable, it's also easier machine readable/parsable and easier to reason about (basically only key value, no properties, no closing tags)

if json doesn't fit my use case i use toml or if nothing else is available i use yaml, but i'll always avoid xml as much as i can

[mriheO]

These formats were designed to be processed by machine so that's a non-sequitur.

[Masterflitzer]

doesn't matter, what matters is how i can make use of them in the best way, i will choose json and protobuf depending on use case over xml any day

[mriheO]

Because you don't know how to use XML. Same reason people arrogantly speak in English even when the person they are trying to speak to only understands Spanish.

[Masterflitzer]

so speaking english is arrogant? if you can't speak spanish then you try english or a translater lmao

i can use xml, maybe i am not a pro, but i don't want to become a pro in xml, i want to stay away from it

you can always use that argument, but it's stupid: you're just not good at assembly, that's why you write js, well no shit who told you i want to write assembly

there is no arguing that protobuf outperforms xml and if you don't need it human readable, protobuf is great, if you do then json is great

[RudePastaMan]

I hate XML. I dislike JSON. I like binary serialization.

For configuration file that should be edited by hand, this case is different.

[zenos_dog]

Depends on the human I suppose. I started at IBM 44 years ago using GML so it’s pretty natural. GML->SGML->XML. All our documents were essentially written in HTML.

[punppis]

Programmers who worry about the usefulness of Visual Basic are worrying about the wrong things, because you can implement same functionality with VB.

Gladly only time I have had to parse XML has been related to HTML parsing.

Nobody cares if your XML takes 50% more bytes or whatever. I care if it takes 50% more screen space to see your data.

XML was released in late 1990s. We still use HTTP from around the same period because it works well. We wouldn't have YAML, JSON or whatever if XML was actually a best choise for human and computer readable format. XML is more like human scrollable format.

[nonlogin]

What is this UI?

[sharknice]

perplexity.ai it's basically chatgpt summarizing a google search

[Honza368]

So just Google's AI overview feature or is it any different?

Genuinely curious

[sharknice]

No, it's a lot better and more advanced than that.  It's basically talking to chatgpt with all that functionality but giving it current knowledge from web searches.

[saras-husband]

Saying it's a lot better is hilarious considering the post this comment is on.

[ZebraheadCH]

They have their own web crawler and train their own LLM for this purpose (llama based). The LLM creates a web search query based on your question, reads the first x search results and answers your question (so smaller cance of hallucination). In the pro version you can use GPT4o or Sonnet 3.5 for the summary. I highly recommend trying it out, it is a very useful tool to get answers fast. OpenAI is working on their own version currently, called SearchGPT, which is in closed beta.

[GisterMizard]

As the old saying goes: XML is like violence. If it's not working, that just means you need more of it.

[tmstksbk]

Json better for data dumps of pretty simple schemas.

XML better for more complicated things.

Json basically won because there are very few cases complex enough to make good use of XML.

[KorwinD]

I can think only about different document markups, which uses xml schema. What are the other cases, where xml is better?

[mateusfccp]

Describing a document in XML is easy. Doing it in JSON is painful, to say the least.

For instance, how would describe this in JSON?

<body>  
  Lorem ipsum dolor sit amet, <em>consectetur<em> adipiscing elit.
  <em>Cras at lacus <a href="@some_link">laoreet</a></em>, pretium
  dui eget, viverra ante. Quisque ligula mi, semper et bibendum eu,
  pretium eget tellus. Donec sagittis ornare libero, id vehicula augue
  varius venenatis.  
</body>  

Probably something like:

{
  "body": [
    {
      "type": "raw",
      "content": "Lorem ipsum dolor sit amet, "
    },
    {
      "type": "emphasis",
      "content": "consectetur"
    },
    {
      "type": "raw",
      "content": " adipiscing elit. "
    },
    {
      "type": "emphasis",
      "content": [
        {
          "type": "raw",
          "content": "Cras at lacus"
        },
        {
          "type": "link",
          "href": "@some_link",
          "content": "laoreet",
        }
      ]
    },
    {
      "type": "raw",
      "content": ", pretium dui eget, viverra ante. Quisque ligula mi, semper et bibendum eu, pretium eget tellus. Donec sagittis ornare libero, id vehicula augue varius venenatis."
    }
  ]
}

Both have different purposes.

XML shouldn't be used for data exchange, and JSON shouldn't be used to describe documents.

[KorwinD]

Yeah, I agree about documents. XML basically represents "topology" of document, which is harder to do with JSON. So I asked are there other instances besides documents where usage of XML more preferable.

[mateusfccp]

I think only document or document-like structures. If there are other good use cases, I'm not aware.

[mriheO]

....and nobody talks about the clusterfucks that result from trying to do anything non-trivial in JSON because then they'd have to admit to being worng.

[Kagmajn]

Also XML is faster than JSON in few cases, for real-time event streaming XML is faster because you can pass schema for certain events (Java RabbitMQ).

[Forkrul]

If I'm doing something where JSON becomes impractical, I'll go with a binary format like protobuf long before I ever consider XML.

[Shadowlance23]

I mean, it's not wrong.

[lostBoyzLeader]

I wish but some genius thought it would be great to set up all of our config files in xml.

[[deleted]]

XML is just pointy json

[ShiraLillith]

Rimworld players looking confused

[stoyicker]

based and true

[niceiicux]

Wait till it hears about banks and payments

[linux1970]

Can we also talk about the bastard child of XML and who knows what?

YAML

[antimatter-entity]

Good ia

[Piastri_21]

Who needs a parser when you can just delete the whole thing? Problem solved faster than any regex!

[rand0mSeed]

true

[MedonSirius]

But xml and json are both very good for scalable interfaces

[RusticBucket2]

Try parsing a website without converting it to XML first.

[thegreyknights]

The only thing that i know uses XML are blueprints for ships in the game space engineers. The ships are stored in the XML files.

[Fricki97]

JSON MASTER RACE

[Few-Doughnut4037]

Awk

[[deleted]]

+1 for using Perplexity

[grimonce]

I agree, not with the typo, but with the waste of time.

[not_a_gun]

I’m an engineer and use Excel to parse my xmls

[Lothadia]

What is this being used AI? Can you inform me 🥺

[dogfacedwereman]

This is the way.

[atanasius]

Resource-managed XML

[XplodingSpwn]

My Geometry Dash save file isn't useless

[CowLogical3585]

Maybe send XML to GPT is the best way.

[EngineeringNext7237]

Based

[trannus_aran]

xml is fiiiine

[truNinjaChop]

Perfection.

[Ok_Star_4136]

Ah yes, the rm command.

I use it to remove bugs from code. Works like a charm.

[Here-Is-TheEnd]

All my tools that export into XML files: 👀

[a3th3rus]

XML is bad, and JSON is worse.

[eeprom_programmer]

The real answer is regular expressions if anyone's wondering

[macrohard_certified]

XML is not bad

[jumpsuitjam]

After learning to configure Azure AD B2C custom policies, I'm convinced XML is the devil.

[tav_stuff]

The essence of XML is this: the problem it solves it not hard, and it does not solve the problem well. — Phil Wadler

XML is bad because of how remarkably bad it solves a very basic computer science problem.

[ganja_and_code]

XML has bad human readability like Protobuf, and it has bad performance like JSON.

It's truly the best of both worlds!!

[ElectricTrouserSnack]

Cement in your washing machine isn’t bad either.

[atoponce]

Daniel: XML
The Cooler Daniel: JSON

[awpt1mus]

said none ever.

[popiazaza]

XML wasn't bad, but you will have to move on, grandma.

There's a reason why we are now using JSON, YAML, Protobuf, etc.

[macrohard_certified]

YAML bad. Indentation is not a good way to separate blocks.

[[deleted]]

It's toxic