<obj type="someobject">

<argument name="arg0" value="value"/>

<argument name="arg1" value="value"/>

<subobjects>

<obj type="subobjecttype">

<argument name="arg0" value="value"/>

</obj>

<obj type="subobjecttype">

<argument name="arg0" value="anothervalue"/>

</obj>

</subobjects>

</obj>

In YAML:

someobject:
  arg0: value
  arg1: value
  subobjects:
    - arg0: value
    - arg0: anothervalue

In JSON:

{ "someobject" : { "arg0": "value", "arg1": "value", "subobjects": [ { "arg0": "value" }, { "arg1": "anothervalue" } ] } }

And just to reinforce my point, in INI:

Just when I thought "maybe I should do the INI too!"

In YAML:

someobject:
  arg0: value
  arg1: value
  subobjects:
    - arg0: value
    - arg0: anothervalue

In JSON:

{ "someobject" : { "arg0": "value", "arg1": "value", "subobjects": [ { "arg0": "value" }, { "arg1": "anothervalue" } ] } }

Hm, that doesn't seem right. Shouldn't it be:

arguments:
  arg0: value
  arg1: value
subobjects:
  - arguments:
      arg0: value
  - arguments:
      arg0: anothervalue

Points about JSON > XML aside...

As a game developer, the big deal to me is that it's a flexible standardized text format which means:

• I don't have to create my own libraries to read, write, or navigate it.
• At least for the purposes of developing and debugging tools that use, generate, or convert it, it's human readable.
• It's diff-able and potentially merge-able, which to me makes it first-class revisionable.

^^ THIS!

It is a shame this is a Lounge post and we cannot upvote.

As a person who remembers the bad-old-days of the 90s and late 80's, I easily recall when most tools and technologies relied entirely on binary formats.

I don't care one bit if the language is XML, JSON, YAML, or Maya Ascii or Collada or anything else. That does not matter.

I absolutely care about factors like those above.

I absolutely care that as a developer I can understand and interpret the file without a binary-file parser. I can crack open a file, run a text search, and find the data I need. Even better, sometimes I can run find-and-replace on that file using simple tools.

I absolutely care that I can run diff against two versions of the file and see the difference. I can open a diff of two revisions with an artist sitting next to me, and we can both glance at the file and see that they moved a joint a little to the left.

I don't care about the exact format, but I strongly care that these human-readable, standardized, diff-able files are used. There was a time when storage space was expensive and everything needed to be encoded. We are past those days.

In YAML:
someobject:
arg0: value
arg1: value
subobjects:
- arg0: value
- arg0: anothervalue
In JSON:
{ "someobject" : { "arg0": "value", "arg1": "value", "subobjects": [ { "arg0": "value" }, { "arg1": "anothervalue" } ] } }

Yeah, and in XML, the sane definition would be:

<someobject arg0="value" arg1="value">

<subobject arg0="value"/>

<subobject arg0="anothervalue"/>

Honestly that's because most programmers are just lazy and would rather commit code as soon as the unit test bar turns green and receive their "most productive employee of the month" award than read over their code and spend some time reviewing it to see what could be made better.