Observations

So, if this is the data format exclusively for machines, why not use ASN.1 instead? Pretty compact. Or protobuffers, and the like.

No, the advantage of JSON is that a) it's readable; b) it's executable (but everybody's afraid to execute it).

Parsing JSON the way data are written as literals in JavaScript is not harder than interpreting JavaScript. Which is fast. So we could add comments, quoteless names, hanging commas, multiline string literals. It's not a big deal.

The disadvantage is that a bunch of dumb software would not understand it. But the software is already dumb. I remember pinging Crockford when I found his implementation of JSON has some kind of error, forgot what.

It's not a big deal to start understanding more.

What JSON is definitely not good for is storing data and searching data by the key. Any hierarchical structure is not good. To store, data should be flattened.

Now properties.

People use JSON (good, readable), YAML (good, readable), XML (stupid, unreadable, traditional), HOCON (better than YAML, readable).

Of course configs, written by humans, should better be in HOCON.
But JSON is definitely read by humans; and pretty often written by humans, too. So why not give more freedom to the people? Gradually, of course.

It's recursive. An array inside a map inside a map, etc. You need a context-free grammar to parse it.
But this can be fixed. See how.

1. You can convert array into a map, right? s"[[$i]]" -> arrayValue(i)

So, generally speaking, can have just maps.

2. If we ban (or escape) dots ('.') inside keys, we can "flatten" the map of maps of maps, just by merging keys.

{"a" -> {
  "key1" -> {
    "[[0]]" -> "value at a.key1[0]"
...
    }
  }
}

will be

{"a.key1.[[0]]" -> "value at a.key1[0]"
 ...
}

3. We ban or escape quotes in keys, and html-escape quotes in values, s/"\""/"""/g, we can get rid of quotes in keys and have only delimiting quotes in values.

What does it give us? We get Regular Language. That easy.

What's the point of having a regular language? Tons of them.

- You can keep it in SQL and match using regular SQL statements.
- You can check or extract data in shell scripts.
- You can parse it efficiently in your code, no need for parsers/combinators.

P.S. And fuck Crockford, he's an ignorant asshole anyway.

Spent like an hour trying to figure out how to serialize to json the object I build from json (to pass around the network); then it occurred to me it's immutable. Why not keep the source, eh. Like class files, they'd be happier if they just had the source code accompanying them naturally somewhere, eh.

So there. I just store the object's own source. Neat, eh.