> I'm assuming your statement would be meant to apply to other common languages without s-expressions, but maybe I've misunderstood.

It was meant for C specifically. Take a JSON document. Define it in C. Here's what I see on a random cJSON GitHub project:

https://github.com/DaveGamble/cJSON/blob/master/README.md#ex...

Now do that in JavaScript:

    const jsonDoc = { "name": "Awesome 4K" ... }

Now make the equivalent jsonDoc in Lisp with s-expressions:

    (define json-doc
      (hash "name" "Awesome 4K"
            "resolutions" (list (hash "width" 1280
                                      "height" 720)
                                (hash "width" 1920
                                      "height" 1080)
                                (hash "width" 3840
                                      "height" 2160))))

The C approach is the approach you'd similarly take in many languages where you create the HashMap, then create the Array, then populate them. Of course, you could "cheat" in many languages by first making a string and then calling the JSON library's `parse` on the string. But, this is different than JavaScript where you can directly create the JSON document. In Lisp, you are always writing s-expressions, both for data and code.

> What's something that is made significantly easier by an s-expression than by arrays/tables?

An s-expression is a form of syntax. Even though it is a "list", the s-expression (list 1 2 3) is an actual list. It's not like you're taking the idea of arrays and tables and replacing it with a list. It's like you're taking the idea:

    // Create a List in Java
    var l = new ArrayList();
    l.add(1);
    l.add(2);
    l.add(3);

    // Print the List in Java
    System.out.println(l);
    // Prints [1, 2, 3];

    // Can we construct a List from the String "[1, 2, 3]"? Is there a fromString() or similar for a Java Object?

And replacing it with the idea:

    // Create a List in Lisp
    (define l (list 1 2 3))

    // Print the List in Lisp
    (println l)
    // Prints (list 1 2 3)

    // Can we construct a List from the String "(list 1 2 3)"?
    (eval (read "(list 1 2 3)"))

What about dates? What if we want rationals? What if we want to use a binary-search-tree-map instead of a hash?

    // Create a Date in JavaScript
    const date = new Date()

    // Print the Date in JavaScript
    console.log(date);
    // Prints Wed Apr 16 2025 00:00:00 GMT ...

    // Can I JSON.parse that string and receive a date?

Lisp:

    // Create a Date in Lisp
    (define d (today))

    // Print the Date in Lisp
    (println d)
    // Prints (date 2025 4 16)

    // Construct a Date from the String "(date 2025 4 16)"
    (eval (read "(date 2025 4 16)"))

The Lisp examples are simplified, but that is the idea.

> To make s-expressions language-agnostic, wouldn't you need libraries in the languages to convert between the s-expression as it exists in some specification, and the language's native data structures?

Yes.

> This doesn't sound all that different from JSON at this point, or a much more complex specification that defines the representation of all kinds of types, like dates.

Correct. It would just be like JSON and whatever bits are standardized are what would be handled.