Generating JSON data using string interpolation or templating is clearly wildly insane, right? You don’t do it.

Maybe for some config file generation scenarios you might just run a template JSON file through a token substitution or env var interpolation or something. But you’d feel bad about it, because it’s so easy to NOT do it that way. And even then you’re not interpolating in JSON fragments like ‘“age”: 25’ - you’d have the decency to only interpolate in values like ‘25’.

In the node ecosystem it’s so easy to switch from a .json file to a .js file, too, if you want to build the json dynamically.

For some reason people feel more willing to attempt it with YAML. And then regret it when they realize how significant indenting has screwed them.

And then with HTML people just give up and go ‘yup, it’s all text, even the angle brackets’

I'm sorry to report that I've seen a lot of JSON generated by string concatenation and templating, in different projects.

Often using 'printf' or 'echo' in various languages. Sometimes using whatever's used for HTML string templating if the JSON is embedded in HTML or served as a resource similar to HTML.

Yes, its horrible and breaks if fed variable values that have characters like quotation marks in. People do it anyway.

Even in languages that have perfectly good data structures and JSON libraries.

I've seen a fair amount of parsing values out of JSON using regexes too, assuming specific formatting of the supplied JSON.

It's less common, because JSON is simpler, so the tradeoff point for using a grammar is lower, but it still makes sense in things like shell scripts, and other cases where the equivalent of `print(obj)` (or `eval(totally_not_rce)`, but let's pretend that's not available anyway) doesn't happen to produce (or consume) valid JSON by coincidence.

  # Using:
  grep -oP '(?<="bar": ")[^"]+' foo.json
  # and
  printf("{\"count\": %i, \"type\": \"%s\"}\n",nfoo,tfoo);

See also various discussions under the heading "Worse is Better". Whether it's the right thing or the wrong thing, it very clearly is a thing.

I think everyone agrees that those approaches with JSON are bad.

This file generates a feed of events (rehearsals for my high school play) to be rendered by the FullCalendar JS plugin. FullCalendar required a particular data schema that didn't match the format of my MySQL table, which meant I couldn't just json_encode() the MySQL results. I guess I just didn't conceptualize that I could create a new object that matched the FullCalendar format, and then call json_encode(). So, I generated JSON with strings.

Honestly it's a toss-up whether the JSON generation is the worst thing about this file. It looks like I also made a separate database query for every single row to get the username, because I apparently didn't know how to do joins. Could probably spend an hour listing some of the other little nuggets of awful in there. But hey, it got the job done! :)

All is fair in love, war, and programming.

Taking the opportunity to ask for more sane alternatives. What do the crowd here use for manifest templating?

But I'd never try to implement my own parser or output deeply nested JSON.

Takes all the tree and hierarchy management away, makes it so ordering doesn’t matter.

If I’m generating JSON from batch scripts it’s my preferred tool (easier than fighting jq for many tasks)

It knows when to do escaping and how. It also can detect, though dynamically, when fragments have been combined into an illegal sequence which would be rejected by the full grammar. It can not however guarantee that the result will parse only that it can not detect that it would fail.

The ugly quasiquoting seems unfortunate (I’ve a half-serious suspicion the reason Template Haskell never got popular is that it looks so bad), and the GLR sledgehammer precludes ever having a lightweight implementation, but otherwise it seems like a interesting entry in the extensible languages story.

5 - 2(3 - 1) - 5 = ?

Also, respectfully, it doesn’t matter. Not having learned maths in English, I don’t know the mnemonic, I don’t care to know it, and I find even the concept of it completely asinine. (For eighteenth-century mathematicians, addition and subtraction bound tighter than multiplication and division, and they could calculate perfectly fine.) You can look up the precedence table if you need to—as long as you need to understood the idea of precedence (and not order of operations, for goodness’ sake). You won’t then be able to calculate fluently, but fluency is a different problem with a tedious and time-consuming solution, and given the time crunch I’d rather talk about some actual Maths as She Is Spoke instead.

6 / 2 (1 + 2) = ?

I approach the problem the same as I would 6 / 2(x + y). When the multiplication is missing 2(x + y) is a single term. The implicit multiplication is part of the parenthesis and reduces the problem to 6 / 6. People who argue that you have to strictly use PEDMAS left-to-right will divide 6 / 2 first and get 9.

Neither way is wrong as long as you can explain the process but everyone wants to argue and have there be a single answer.

A test question like "6 / 2 (1 + 2) = ?" is not asking for the mathematical meaning of those symbols it is asking for "Guess what I as thinking when I wrote this".

(Unless it is a programming class and you are learning how the compiler reads your code)

My older relatives are the ones I see repost these inane order-of-operation tests, getting the answer consistently wrong.

   ÷ x 

     1
   * —
     x

For example in arithmetic

   x + y

The failure of teaching to explain that you’re moving on to use those symbols to do something fundamentally different is, I think, one of the things that leaves some kids behind and dooms them to always annoy their relatives in Facebook comment threads about operator precedence.