Oh yeah, immediately above that line:

> jq is written in C, which drags all intrinsic problems the language has dated its creation

And then to follow on the C++ claims:

> Main JSON engine/library does not have a single new operator, nor it has a single naked pointer acting as a resource holder/owner, thus jtc is guaranteed to be free of memory leaks (at least one class of the problems is off the table) - STL guaranty.

That's a lot more faith than I would be willing to put into C++ or C. Sure, that claim might be correct, but there's enough edge cases and undefined behavior in the language that I take it as a fairly bold claim unless it's also been thoroughly reviewed for any places some undefined behavior may be induced.

I mean, it's probably fine, but just the willingness to make such a bold claim in that way communicates the opposite of what the author likely intended for me.

> jq is written in C, which drags all intrinsic problems the language has dated its creation

I can't even parse this sentence. What does it mean?

FWIW jq was originally written in Haskell, then ported to C. The C source for the core parts is strikingly clean. I think, it's partly from this Haskell heritage that jq gets its nice composability.

However, TBF, I do find I must refresh jq syntax whenever I use it (pr only bc I don't process json often). It will be interesting to see what jtc does - though this foreshadowing does not bode well...

> "undefined behaviour"

Yeah, you don't know what you're talking about.

"Undefined behavior" simply means "stuff not covered by the ISO standard".

So Python and Rust are 100% UB, and people don't really care.

Undefined behavior can cause perfectly functioning code in one compiler version to be completely elided in a different version, as we've seen numerous times in the past. Review the article and comments here[1] for a good example of exactly this and discussion about the how and why, but the TL;DR is that a specific optimization in a specific compiler release determined that the adding of two variables, one of which a pointer, would result in an overflow which is undefined for pointers, and thus elided the check to see if the result was less than should be possible (overflowed), and the entire error handling case it resulted in. This caused the value to be used while invalid (as the error check and handling was elided), causing a segfault.

Perhaps the features used in this project protect against that, but my point is that undefined behavior and the way compilers deal with it is variable and problematic.

1: https://news.ycombinator.com/item?id=14163111

It's definitely problematic, but so is having your interpreter completely redefine language constructs on every point release. Or having different interpreter implementations act differently because there's no standard.

Somehow we make do in these cases and don't act like the sky is falling.

> Somehow we make do in these cases and don't act like the sky is falling.

I think "there's enough edge cases and undefined behavior in the language that I take it as a fairly bold claim unless it's also been thoroughly reviewed for any places some undefined behavior may be induced" was me acting like the sky is falling. I think that's a very sane push back against a claim that I think either wasn't well founded or wasn't well explained.

Ultimately it's up to you to decide whether to accept I'm expressing what my words actually say or whether I'm expressing what you presented me as in your straw man argument you originally replied with. At this point, there's not much else I can or am willing to waste any more time saying that I haven't already.

I do agree with the author that the learning investment required by jq (learning a full blown DSL) is total overkill for most simple JSON based tasks.

For those, I mostly use "jq ." to get all leaves on a single line and then feed the output to standard unix tools like grep cut awk and friends.

And for more complex tasks, python, perl, even C++ if speed is needed.

> For those, I mostly use "jq ." to get all leaves on a single line and then feed the output to standard unix tools like grep cut awk and friends.

There's a tool called `gron` designed for workflows like this, I've found it incredibly useful.

https://news.ycombinator.com/item?id=16727665 https://github.com/tomnomnom/gron/

> the learning investment required by jq (learning a full blown DSL) is total overkill for most simple JSON based tasks.

There's no reason why you would need to learn the whole DSL for simple tasks. Just learn what you need. For simple stuff, the DSL is also simple.

jtc also seems to have its own DSL by the way, and it doesn't really seem more intuitive than jq's:

  jtc -x'[0][:][name]<person>v [-1][children]<kids:false>f[0]<kids:true>v' -T'{"{person} has children":{kids}}' -r

That's apparently the equivalent of:

  jq '.Directory | map({"\(.name) has children": (.children | length == 0)}) | .[]'

There are some things that seem simpler on jtc, though, like searches of string values without regard to the json structure.

I’d really like a CLI tool which solves this problem using a syntax I already know. I struggle with jq because I use it quite infrequently.

IMO the ideal solution is something using pure JavaScript syntax, possibly with a library resembling jQuery for tree traversal.

Most of jq's syntax is just a mix of JavaScript and a typical shell's. Every expression has an input and output like a shell command's stdin and stdout. Functions work on arguments and their stdin to produce their stdout.

Here's an explanation of the syntax in the command I posted:

  jq '
    # output the value at "Directory" from input object
    .Directory
    # pipe to map (JavaScript also has map()). The argument of map works in
    # the context of each element in map's input array.
    | map(
      # Produce an object where the property name is a string that
      # interpolates the value of the "name" property of this element.
      # Instead of interpolating, we could have also used this more
      # JavaScript-ish (ES5) syntax:
      #
      #   {(.name + " has children"): ...
      # 
      # The property value is an expression that gets the value of the
      # "children" property and pipes it to the expression `length != 0`.
      # `length` (which JavaScript also has) outputs the length of the
      # piped input, and then we compare that with 0.
      {"\(.name) has children": (.children | length != 0)}
    )
    # map's output is a single record which is an array. We pipe that to
    # .[] to make multiple records, each an element of the array. The
    # syntax here is comprised of 2 parts: `.`, which is the input object,
    # and `[]` which is the subscript syntax without an index.
    | .[]
  '

> IMO the ideal solution is something using pure JavaScript syntax

The greatest advantage of the current syntax is the great balance it has between legibility and terseness. I don't think making it pure JavaScript would be better.

> possibly with a library resembling jQuery for tree traversal

Using jQuery in JavaScript to traverse JavaScript objects? I don't know what to say...

Something like this would do the same, if somebody implemented a tool called jsed:

    jsed '
        Object.fromEntries( 
            $("Directory").map( 
                x => [ 
                    x.name + " has children", 
                    x.children && x.children.length != 0
                ]
            )
        )'  

Interestingly enough there is already a tool called jsed which seems to kind of do this... https://www.npmjs.com/package/jsed

Edit: Note the jQuery part of it is for advanced cases like searching for specific nodes in the tree, then navigating back up to the parent. Basically the cases like "<Work>[-1][children]" from the jtc guide, I would write as: '$("Work").parent().find("children")'

That was supposed to be a `!=` instead of a `==`.

  jq '.Directory | map({"\(.name) has children": (.children | length != 0)}) | .[]'