11 ms·
Better Than JSON?
- rhabarba 6y agoS-expressions are the most logical representation of data structures. “CAR”/“CDR” are not a part of the expression syntax, so this argument against them won’t matter.
- tgb 6y agoI didn't read that as complaining about CAR/CDR, but rather it was making a joke: the section header is "Cons".
- rhabarba 6y agoAh. Too sophisticated...
- ben509 6y agoS-expressions are great once you've figured out functions, atoms, complex data types, etc. That's how Amazon's Ion[1] uses them: as a nice supplement to a serialization standard. > “CAR”/“CDR” are not a part of the expression syntax If you were implementing them for a serialization format, you'd leave out cons cells and car / cdr. But in late-binding LISPs, which is where they're typically used, (a . b) is part of the syntax. It's worth calling out for why you don't want it: it's badly typed since it could be a 2-tuple, or it could be a list depending on what 'b' is. [1]: https://amzn.github.io/ion-docs/docs/spec.html#sexp https://amzn.github.io/ion-docs/docs/spec.html#sexp
- fanf2 6y agoS-expressions lack a standard representation of maps/dictionaries. Even LISP is inconsistent: it has both alists (list of pairs) and plists (list of alternating keys and values). So S-expressions suffer a similar problem to XML: there is not a clear way to represent many data structures.
- velebak 6y agoEdn should be on this list
- nocman 6y agoIt sort of is, under "S-Expressions", but I think it should have been in its own section.
- papito 6y agoThere is no such thing and this is blasphemous - shut it down.
- karmakaze 6y agoIt would be nice to be able to represent 64-bit ints--and have comments.
- jandrese 6y agoAs for comments, I think JSON is only "human readable" by accident. It was never really meant to be read by humans, and was created in a way that implicitly discouraged people from trying to write or edit it by hand. Many parsers are picky about whitespace to discourage people from trying to create config files in JSON.
- icandoit 6y ago"comment-subject-author":"this is a comment, we dont need out of band communication, thats a bug, not a feature"
- phailhaus 6y agoAh, so now you're encoding out-of-band communication into your data? How is that not worse? This also completely breaks if your data is validated against a schema, or if your comment gets parsed as a data entry. For example, in Javascript projects you define your dependencies in package.json. I can't add a comment to explain why I had to add a strange dependency, because npm will interpret it as a dependency itself and then break.
- secondcoming 6y agoWhen is XML never not too verbose? (jk) Very interesting article and I like the style in which it was written. Another factor to consider is whether the serialisation code is intrusive or not. Being intrusive can be an issue for legacy codebases, and IMO is not paricularly welcome regardless.
- mikece 6y agoEveryone loves to hate on XML just because it can be verbose and some of the WS* protocols are complicated. But as a human-readable format it’s no harder to read or parse than JSON and legacy application support is orders of magnitude better than JSON. I’m not saying we should all use it but we shouldn’t be hating it either.
- zikzak 6y agoMake these people debug doyne old EDI documents and all of a sudden XML doesn't seem so bad.
- twunde 6y agowho doesn't love x12, especially with its loops and segments?
- dragontamer 6y agoThe issue with XML is that it was mostly pushed upon developers without any deeper understanding. So there's a ton of utterly crap XML applications out there with no rhyme or reason, and these crap XML enterprise apps are most developer's understanding of "real world XML". Similar to how terrible C++ code being all over the place is making people hate C++ the language. ------- XML can be used very well however: its use in Jabber / XMPP is clear and concise. XML Namespaces are needed due to the extensions of XMPP, and various programs can interact with the protocol. Specifications are clear, the ability to "stream" data is proven, different parser strategies have been implemented. Its clear that XML in this instance works, and works pretty well.
- karmakaze 6y agoAnything that lists BSON should include the fix: JSONB https://news.ycombinator.com/item?id=7457645 https://news.ycombinator.com/item?id=7457645
- FullyFunctional 6y agoIn my experience with BSON it's ridiculously wasteful compared to CBOR. I haven't compared with JSONB, but it seems unlike that it improves on CBOR.
- fanf2 6y agoJSONB is a private internal data representation in PostgreSQL, designed to be faster to index than textual JSON. As I understand it, it isn’t guaranteed to be stable, it isn’t exposed outside PostgreSQL, nor designed for data interchange.
- adkadskhj 6y agoWish the author would have checked out: https://borsh.io/ https://borsh.io/ I've been using it lately but i'm i'll qualified to review it to any meaningful degree. It's neat, (reportedly) fast, but has seeming zero traction and thus makes me uneasy. (I'm currently (configurably) using it in place of bincode, for a content addressed store. for some context)
- tlamponi 6y agoLooks pretty interesting, thanks for posting. We'd also have a use case where we think about using bincode, this seems worth to check out/compare as a possible alternative.
- karmakaze 6y agoThe list shouldn't mix those with a schema and those without. Anything using a schema that is agreed upon between participants isn't like JSON at all.
- jandrese 6y agoAll of them use schemas, the only difference is if the syntax is specified in the language and can be machine verified or if you're left to figure it out on your own. Actually the latter will be machine verified too, but the results of a mismatch is a core dump or an error in your own ad-hoc schema verification system.
- karmakaze 6y agoYes I obviously meant 'specified schema' which the post describes as 'schema-defined' with the alternative being 'self-describing'.
- tannhaeuser 6y ago> Not sure anyone really knows how XML happened. It’s basically the W3C’s fault, I think? Doesn't instill confidence in that content. fyi: XML was subset by W3C (the SGML "extended review board" specifically) from SGML to become the generic syntax for web vocabularies (replace HTML syntax by XTHML, and define new SVG, MathML vocabularies). Didn't work out on the web, though.
- outworlder 6y ago> Doesn't instill confidence in that content. It is pretty clear by the language used that it's all written tongue in cheek.
- jandrese 6y agoThere's also the joke that nobody wants to take the blame for inventing XML.
- GoblinSlayer 6y agoSVG did. XHTML is incompatible with traditionally lazy nature of webdev: broken markup happens regularly, XML would make it non-displayable, so HTML keeps accessibility of broken pages.
- dochtman 6y agoI liked this CBOR vs MsgPack article from a while back (which also talks about size on the wire, not just performance): https://diziet.dreamwidth.org/6568.html https://diziet.dreamwidth.org/6568.html SBE (Simple Binary Encoding) also makes some interesting performance claims. My pet peeve with both protobuf and capnp is the lack of an option type; they seem to be designed for languages with type systems that include null, rather than more modern languages like Rust or Kotlin.
- FullyFunctional 6y agoAnother vote for CBOR. I had actually designed my own binary JSON encoding out of frustration with BSON (which nobody should use IMO). My format was focused on compactness, but I dropped it when I found CBOR which was very similar and even slightly better in places. One notably thing about CBOR is the support for both Indefinite and Definite-Length Arrays and Maps (typically streaming generators need the former whereas parsing the latter can be more efficient).
- stinos 6y agoInterestng read, didn't know most of this. Not that it matters in the end: at one point we just needed something simple which would just work and MessagePack does just that :) Btw JSON is often a popular choice, but although this is not explicitly mentioned in the main article as a con which is an oversight imo, the actual JSON standard does not support NaN/+-Inf for floating point. That's insane, which is why most implementations have an option to allow that anyway, but not all, which can be quite the showstopper.
- heavenlyblue 6y agoProtobuf has fields that may not be required (although it is advised not to use it). How is that different from Option?
- hcarvalhoalves 6y agoAlso worth looking are EDN [0] (mentioned briefly under S-Expressions), Transit [1] and Fressian [2][3]. [0] https://github.com/edn-format/edn https://github.com/edn-format/edn [1] https://github.com/cognitect/transit-format https://github.com/cognitect/transit-format [2] https://github.com/Datomic/fressian/wiki https://github.com/Datomic/fressian/wiki [3] https://www.youtube.com/watch?v=JArZqMqsaB0&ab_channel=ClojureTV https://www.youtube.com/watch?v=JArZqMqsaB0&ab_channel=Cloju...
- peatmoss 6y agoYeah, the author didn’t specify why he thought EDN wasn’t more than “a good start.” I’m curious what it’s missing!
- erikerikson 6y agoIf you follow the link, you'll see that there are no examples of data in the format and the README declares things like that it will provide a BNF when the specification ready. The context seems to imply that it is in an early implementation stage and not ready for non-enthusiast consumption. Also, last updated in 2014.
- jandrese 6y agoWhat's missing is major projects using it I think. Note how for every example he lists the big players keeping it alive.
- bjconlan 6y agoFrom recollection it’s the native data transmission format for Datomic (which is driven by Cognitect/Nubank). I think there is a little bit more to the bias’ of EDN (mostly driven by language preferences in this case).
- hcarvalhoalves 6y agoEDN has a few limitations regarding encoding custom types (tagged literals), and also performance in general. I understand both Transit and Fressian are possible evolutions addressing these points.
- bovermyer 6y ago> Apache is the tragic junkyard of open source projects This made me laugh more than it probably should have.
- emayljames 6y agoYeah, OpenOffice first springs to mind. Is like a retirement home.
- highmastdon 6y agoSomehow this made me feel happy that GraphQL is part of the Linux Foundation
- zelly 6y agoApache, GNU, Boost The kiss of death. It's a graveyard of things from a previous era, pure maintenance mode. I think library authors get tired of maintaining for free then hand it off to these life support organizations. The new way for open source software is a decentralized ecosystem where people fix software they actually use, so the cream rises to the top on its own and you don't need the sponsorship of these digital museums.
- deleted 6y ago[deleted]
- lxe 6y agoAfter half a decade of "better than JSON" mentality, fiddling with thrift, protobufs, custom serialization methods, I came to realize JSON/HTTP is usually the right tool for 90% of jobs.
- DJBunnies 6y agoAgree. Handful of cases where thrift or grpc helps with an interface or streaming, but they seem to be the edge cases.
- secondcoming 6y agoMaybe, if you're not paying for data transmission costs. Binary formats win for the following cases: - payload size - serialisation/deserialisation speed - simplicity of client / server code (e.g. replacing a full blown HTTP server with a simple ZeroMQ one) Sure, having payloads that are human readable is great for initial debugging/verification, but once things are put live it's just an unnecessary expense.
- t-writescode 6y agoDefinitely not for simplicity of server/client code. Using a Json serialization library basically means implementing a POJO at this point.
- secondcoming 6y agoI was more referring to the overkill nature of needing a HTTP server rather than the ease of integration of JSON parsing code.
- t-writescode 6y agoI remain confused. Many libraries support generic data contracts that enable both xml and json objects from the same objects.
- lxe 6y ago
- generalk 6y agoOn XML: > Not sure anyone really knows how XML happened. It’s > basically the W3C’s fault, I think? It’s okay for some > things but in the end I’m not sure it’s something anyone > actually wants to use, it’s just going to be one more of > those mistakes of the past. Look, I was doing web dev when XMLRPC was in. For simple API stuff, JSON ended up being worlds better. No fiddly XML preamble, no schemas, no envelopes, just enough structure to be able to quickly pull out a couple of fields and we're set. Beautiful. But let me tell you how much I appreciated XML and schema validation when we were working with fifteen different partners all using a standardized XML format with a schema. These are cats who were putting XSDs into their IDEs, clicking generate to get a class, and then just not caring. So when our integrations broke because they were sending XML payloads that failed schema validation, our conversations were so easy. Before you say "yes but technically you could have done the same with $OTHER_THING" -- sure it's possible, but XML is ubiquitous. Shit, our tools were in Ruby. XML can be a bear, but sometimes you need a bear.
- richm31415 6y ago"Sometimes you eat the bear, and sometimes the bear eats you."
- derision 6y agoYou only need to serialize faster than the guy next to you, or something
- lemmsjid 6y agoMuch agreement here, and from the exact same usecase. Probably the easiest B2B API integration scenario I worked with in the past was XML + XML Schema validation. And I still think XML is more readable in many cases than JSON, because while verbose the hierarchical structure is very easy to grasp, sometimes I misread an entire JSON document at first because I missed a quick "[" or "[{" (yes I have also misread XML documents because of the sheer weight of text you are presented with, so I'll call that one a wash). I do agree with the XML criticisms around writability and complexity, though I think if you made a Venn diagram of the actual complexities inherent in managing a multi-client document-exchange system and the complexities of XML+Schema, you'd find that they're similar--and that many people who start building such an exchange with JSON documents end up stumbling into the same amount of complexity except in an ad hoc fashion. It's funny, I wonder if other people have the same surreal experience: as the mass zeitgeist moved away from XML I was more or less like, okay, gotta go with it, as the driftwood goes with the currents. It's interesting how the zeitgeist functions. You can tell it's happening when people look at your functional system and are like, "Uhh, why aren't you using X...?" as though it's self-evident that you should drop everything and rewrite. Where X was, over the years (dating myself) {"Java", "PHP", "Node", "Rails", "Jquery", "REST", "Angular", "React", "Thrift", "NoSQL", "Protobuf", "Hadoop"}. Some of which I quite happily used, BTW, so the interesting part is the penetrative nature of the conversation, e.g. how the quite-functional-but-not-hot technology becomes the sick gazelle falling behind the herd, even as it is not empirically sick.
- aceBacker 6y agoThe only problem with json is that you can't do comments with the default implementation.
- hajile 6y agoNo trailing commas and multi-line strings are my other two big complaints. The ability to leave keys unquoted if they don't have any spaces would also be nice. The best part is that these are a superset of JSON and could easily be added if there would just be more buy-in (lots of unofficial support already exists).
- slaymaker1907 6y agoThe author does mention JSON5 which implements all of those features.
- aphx 6y agoEvernote's API also uses Thrift, fwiw https://dev.evernote.com/doc/reference/ https://dev.evernote.com/doc/reference/
- pachico 6y agoI would have expected some mention to https://jsonnet.org/ https://jsonnet.org/ too, which after a bit of practice can be brilliant.
- ekimekim 6y agoI'm a huge fan of jsonnet, but this article is specifically about data serialization formats, not configuration languages. It could've been a worthwhile mention though.
- pachico 6y agoYou are right but I mean it since jsonnet has also function as data type, which is not a trivial matter.
- lsb 6y agoArrow is rapidly become a data interchange format for Pandas and GPU compute, didn't see that on there
- vlmutolo 6y agoGood point, though I think Arrow is optimized for larger amounts of data. Not sure how it would hold up for small messages. Still, lots of people use JSON, etc. to store large amounts of data, so Arrow (or maybe more accurately, Parquet) is a fair comparison here.
- jrochkind1 6y agoThere are a bunch more possible entries in the human-readable category, one of the more popular contenders is TOML. https://github.com/toml-lang/toml https://github.com/toml-lang/toml . There are more. I don't know if java dot-properties file is worth including.
- andreareina 6y agoThe speaks to the context of serialization formats, which TOML isn't.
- jrochkind1 6y agoHm. Would you call YAML a "serialization format" but not TOML? I'm not sure where to draw the lines of what is a "serialization format" (you can serialize to both yaml and toml, no?) but YAML and TOML feel to me like they are in the same space, human-readable representations of hash/array json-like data, ie serializations; not to you?
- yk42bb 6y agoIt should mention canonical s-expressions[0]. [0]: https://en.wikipedia.org/wiki/Canonical_S-expressions https://en.wikipedia.org/wiki/Canonical_S-expressions
- slaymaker1907 6y agoOne key element that I think is missing in this analysis is whether the format supports cyclic data out of the box. This is an important feature for many languages since it most languages besides Rust make it very difficult to determine if the data may contain cycles or not and handling cycles can be very expensive in terms of both time and memory for serialization.
- kstenerud 6y agoAlso https://concise-encoding.org/ https://concise-encoding.org/ It's both binary and text, and supports all the common data types, and doesn't require a schema or extra compilation steps.
- mugwort13 6y agoAuthor: "I’ve never gotten schemas and validation to actually work in practice” Reality: Author somehow overlooked the fact that MS Office documents are all bundled xml files behaving exactly as intended Lesson: One guy’s experience is not enough to decide which languages you use or how you build software
- avmich 6y agoIn some sense JSON is unimprovable, because some properties of JSON are reached their limits. The idea of JSON is to offer two important ways to aggregate, which are different enough that they deserve separate treatment - ordered array and associative array. They are economically represented, with [] and {}, and internal structure is also made with small costs - commas (,) between elements and colons (:) for keys in associative array. We can argue that both of those features are required. Chosen primitives - numbers, strings, booleans and null - are also selected from what's regularly and consistently used, and the choice is supported by two decades of JSON application. Roots of this selection are in design of JavaScript, which in turn relied on common practice for basic primitives. If JSON is considered as what I think it is, structure out of basic primitives, it's at the optimal point. Crockford's decision to avoid JSON versioning makes a good sense. Applications of JSON - human-readable texts, performance-optimized communications - can suffer from e.g. lack of built-in comments, non-extensible "type system", non-optimal bandwidth usage (if direct ASCII or even UTF-8 is used for JSON encoding, not some other compressed approach). They however can be fixed by building on top of JSON. For example, parties can agree upon reserved keys and compression schemas, constraints in form of grammars (JSON-Schema). This flexibility stems from the fact that JSON is at the very foundation of data structures, so "better than JSON" is to an extent like "better than two's complement number representation".
- earthboundkid 6y agoI think https://github.com/rentzsch/lich https://github.com/rentzsch/lich gets the basic primitives right as well, and in a binary-friendly format, but it has never been pushed by any organization, so it’s essentially unknown.
- deleted 6y ago[deleted]
- cbsmith 6y agoAgain, I think this is based on some starting assumptions about what is an ideal state, and a lot of people would argue they are flawed assumptions. It's easy to get trapped into a context when considering what the ideal solution would look like. People forget this, but ASCII (and therefore UTF-8) already has characters in it for field/record/etc. separation. One increases complexity significantly (and introduces inefficiency) by overloading other characters with their semantics. There are much more simple & efficient ways to demarcate ordered arrays in particular (e.g. simple length prefixed structures). Nulls are highly problematic for any number of reasons that are widely documented, and JSON unfortunately compounds this by having two ways of representing them (explicitly and by omission). One might quibble with the notion that a format that didn't even exist in 2000 doesn't really have two decades worth of applications working on it, but setting that aside, the design constraints of JavaScript and the challenges that have emerged from it are far from ideal. The work arounds that have emerged (the whole Number fiasco, the "standardizing" on UTF-8 while using UTF-16 when escaping, line terminators, the backslash escapign of control characters, the inconsistencies between JSON & JSONP, the binary64 "good interoperability" rule, and comments being disallowed, and of course the various JSON Schema efforts). While I agree that an ideal serialization standard would not have versioning, and Crockford's decision to avoid JSON versioning might consequently seem to make good sense... in practice this has lead to significant inconsistencies between implementations, many of which lead to interoperability problems that could at least be somewhat mitigated by versioning. (http://seriot.ch/parsing_json.php http://seriot.ch/parsing_json.php) "Fixing" a bad abstraction by layering on a bad abstraction is a common house of cards meme. It is highly problematic to say the least. It's how "simple" JSON rapidly evolves to be at least as complex (and at least as error prone) as ASN.1.
- leafmeal 6y agoTo weigh in on the XML vs JSON debate, this article https://engineering.instawork.com/when-xml-beats-json-ui-layouts-53c7f1d3fdb7 https://engineering.instawork.com/when-xml-beats-json-ui-lay... has been posted before and shows JSON and XML's strengths with different kinds of data, i.e. lists vs trees.
- jstrong 6y agoif you are sending data to "yourself" and performance is important, defining your own binary protocol can be very effective. every time I go to grok protobuf, thrift, et al. I end up just rolling my own format because it's so much simpler and I can take all the tradeoffs that benefit what I'm doing instead of what anyone might possibly do with it. this doesn't apply in many situations (i.e. sending data to outside parties) but I've experienced a lot of success with it that seems at odds with conventional wisdom on the subject.
- petre 6y agoWe only do that on embedded platforms, meaning MCUs. Anything that runs Linux is better off with CBOR or MessagePack or even ProtoBuf. Dunno about FreeRTOS et all. I've only seen libraries for JSON. ESP32 and Cortex M4 are powerful enough for serialization formats but at the expense of wasting cycles, so you're probably better off with a custom binary protocol most of the time. But if you want to sell your product to integrators use a well supported serialization format. Nobody is going to write decoders for your custom binary format today.
- fortran77 6y agoThere's a widely-used Erlang ETF and BERT See: http://erlang.org/doc/apps/erts/erl_ext_dist.html http://erlang.org/doc/apps/erts/erl_ext_dist.html and for an overview: https://medium.com/@niamtokik/serialization-series-do-you-speak-erlang-etf-or-bert-part-1-ff70096b50c0 https://medium.com/@niamtokik/serialization-series-do-you-sp...
- RedShift1 6y agoI find it curious that serialization formats like JSON get hit on for not having a native date/time format. Just use a UNIX timestamp and be done with it.
- bryanlarsen 6y agohttps://tools.ietf.org/html/rfc7493 https://tools.ietf.org/html/rfc7493 says to use an ISO 8601/RFC 3339 timestamp, uppercase, with timezone, with seconds. IOW, Javascript's toISOString() or equivalent.
- petre 6y agoYou need to parse that. For graphs with thousands of data points just use Unix time plus a timezone or use the browser's timezone. ISO 8601 would leave your graphs churning for seconds.
- bryanlarsen 6y agoIf parse time is a significant concern, why are you using JSON?
- petre 6y agoBecause we feed the data to Js. No need for additional overhead parsing string based timestamps. Unix epoch is just an int. We don't need pre 1970 timestamps.
- prideout 6y agoJSON5 looks pretty great to me, I'm surprised it doesn't get more attention in the write-up. Take JSON and add trailing commas, multi-line strings, and comments. Done and done!
- skrtskrt 6y agoIs that what VSCode does for the settings.json and similar settings files? I haven't tried multiline strings but it allows comments and trailing commas
- edsiper2 6y agomsgpack users: - Fluentd & Fluent Bit - Microsoft SignalR https://docs.microsoft.com/en-us/aspnet/core/signalr/messagepackhubprotocol?view=aspnetcore-3.1 https://docs.microsoft.com/en-us/aspnet/core/signalr/message...
- miked85 6y agoThis post seems to be conflating various things such as configuration files, client side message configuration, and wire format. I am not sure what the takeaway is from it aside from the author's personal opinions on various technologies
- Anka33 6y agoXml! NEXT!
- blastonico 6y agobetter than JSON is JSOFF.
- nly 6y agoAvro never gets any love, which is a real shame given its extremely powerful schema resolution rules[0] You don't have to worry about maintaining numeric field tags, can remove fields, can make previously required fields optional (by promoting them to unions with null), or even change their type (by promoting them to unions of <old type> and <new type>) You need to pass your schema around with your data somehow, but there's a file format specified for that, and you can still just dump to JSON if you can't be bothered. The schemas are specified in JSON too... which in my view makes it more robust than the JSON + JSON-Schema combo [0] https://avro.apache.org/docs/current/spec.html#Schema+Resolution https://avro.apache.org/docs/current/spec.html#Schema+Resolu...
- bionhoward 6y agoJust to be a broken record: JavaScript is better than JSON because it has loops, conditionals, comments, modules, functional programs, typing, etc etc
- petre 6y agoWhich opens a lot of opportunities for potential attackers embedding malware into data and executing it remotely.
- winrid 6y agoDid a disservice to Thrift here. In my last job we had I think a hundred services communicating via Thrift. It's pretty fast, type definition is easy to read, has support for union types, and supports A TON of languages. We used the Java, Node, and PHP clients/servers...
- zelly 6y agoJSON is popular because of JS and web browsers. It's the native serialization format of the most popular platform, so naturally it is the most baby ducked. There are also pragmatic reasons such as browsers and various interpreters (Python) being faster at JSON than alternatives (thanks to years of hand optimization). From an aesthetic point-of-view, XML is ideal. It reads like S-expressions or Lisp but with enough features to be a robust serialization format or even represent code. Validation alone puts it ahead of JSON. Too verbose? What kind of editor are you using that can't add the closing tag automatically or show you validation errors as you go. If type checking is good, then XML is good. The main reason XML is hated now is that it's too difficult to learn. People that care about performance will use protobufs/capnproto, which has all the safety of XML and more. People that want something to work out of the box everywhere without too much thought will use JSON. There is no room for caring about correctness for its own sake.
- kokizzu2 6y agolemme piggyback ./'__')\ https://stackoverflow.com/questions/57470117/name-for-juniper-nginx-caddy-like-configuration-format https://stackoverflow.com/questions/57470117/name-for-junipe...
- rurban 6y agoI miss the security category. All of the mentioned formats are now insecure by default, because they deserialize objects. (Just msgpack not, which has other problems). Even JSON, the most secure format originally became insecure in its 1st update. All the binary JSON variants, like BSON went bonkers.
- nt2h9uh238h 6y agoI also hate XML, but there's actually one very fair use, where I'm really struggling with all other formats: User Interface Descriptions. HTML, Apple iOS (XCode), Windows Phone (XAML), and even Android XML (virtually all android apps) copied it for that exact reason, even though they could have started from scratch.