Seems like it draws a lot of inspiration from EDN. Tagged literals, commas-as-whitespace (and optional), and anything-can-be-a-key are features I sorely miss when I have to go back to JSON.
Don't know how I feel about optional quotes around strings, that seems like a mistake. And having an immutable set literal would be nice as well.
Because I may not be the only one who was confused initially: I think EDN in this instance refers to the data serialization format (Extensible Data Notation) from the Clojure people, not to CBOR-EDN (Extended Diagnostic Notation), which also offers tagged literals and anything-can-be-a-key, IIRC.
Absolute slop. Interesting that the end result, the place where Claude ended up, is similar to a (human-authored, windmill-tilting) project of mine, https://preserves.dev/ . Though with a much prettier website and far, far, far more words.
I unfortunately agree, this reads heavily AI generated. I was not able to follow the reasoning, e.g. management of backward and forward compatibility seems broken.
I sometimes wonder if we as an industry should revisit XML for those use cases where painful JSON contortions are being used, now that LLM's can plausibly support writing the syntax for XML-adjacent languages like XSLT without as steep a learning and sustainment curve. My natural inclination is to design to accommodate as complex a space as the business requirements project for, because representation data structures and languages are so incredibly painful to change late in a product's maturity cycle.
So I've never rejected XML out of hand, but I've always been "show me" skeptical of calls for it and pushed for explanations on why the business requirements feel the justification to adopt XML. Sometimes I've seen it totally makes sense, but with the conceptual rigor it requires in those use cases, the skillset and expertise of the development team has to reach a higher than average bar. I'm cautiously hopeful LLM's might help with lowering that bar, but time will tell.
I think the industry has an XML-shaped hole for sure, but XML itself was still designed before about 30 years of hard-won knowledge about smart design of data languages.
you can just add schema to json why add new syntax now, especially for json I dont think it makes sense I honestly believe the war is over there won't be a xml to json moment unless we move to a new platform other than browsers which seem rather unlikely, json honestly is fine for something that's somewhat human readable...
What's the justification for being a superset of JSON? Being incompatible with most existing JSON tooling and interfaces is a big disadvantage, so there better be a tangible upside.
Also, I see mention of hashing, but no mention of canonicalization. Does fiddling with a schema's whitespace change its hash?
"superset" is just marketing mumbo jumbo that says: "I promise to embed an x86 virtual machine inside my spec that'll still parse whatever weird JSON you're currently handling and give it back to you as an object in your programming language"
$ echo '{ "Hello": "World" }' | tson --parse
ERROR: ...refusing to interoperate w/ JSON b/c we want to be different
...that's a non-starter. If they're trying to replace or supplement JSON (same way `uv` has been replacing / supplementing `pip`, and `deno` is doing the same with `node`), you've got to do the work of supporting the extant real-world use cases that are floating around but with a healthy layer of $BETTER sprinkled on top.
I've been explicitly trying to support `--json5` on some of my internal work tooling. Being very explicit that I'm not parsing `--json`, but instead using a slower (but more forgiving) `--json5` which would allow comments, trailing commas, whatever JSON5 claims to support.
This `--tson` feels like it's solving two problems in disguise:
1) It wants to be `--json6` (eg: `pi: !number 3.14`)
2) It wants to use it's own `--json6` (aka: `--tson`) to write "json-ish schemas" (eg: `foo: [text; 1..10]` for presumably a list of maximum of 10 elements?)
...JSON was a blessing because it existed naturally as an unambiguous "lists, dicts, values" representation that most programming languages treat as first-class citizens. Missing "sets" and things like "date" or "boolean" are certainly under-specified, but that's the real-world impact of JSON as lowest common denominator.
SCHEMA's don't have nearly as much natural, unambiguous representations across many programming languages. The closest thing I can think of is straight up Java + Constructors (ie: a full programming language for object initialization but w/o allowing interaction or behavior).
CalendarEvent x = new CalendarEvent( Date start, Date end, Boolean all_day, List<Invitee<...>>, ...etc... )
...where my mind has gone lately is doubling down on TypeScript's `*.d.ts` as a "naturally occurring, expressive schema language". It's hella-more-complicated to parse/validate than JSON, but there's tons of tooling around it, and it's relatively unambiguous that it can solve and express Real World(tm) engineering problems.
Using the query string to carry the sha256 hash but then saying the "hash parameter is verification metadata, not identity" doesn't make much sense. The ?query part of a URL is supposed to be sent to the server. If you want to add client-side (meta)data, you should use the #fragment part of a URL. See RFC 3986, sections 3.4 and 3.5: https://datatracker.ietf.org/doc/html/rfc3986#section-3.4
Fragments are useless outside a browser and lead to problems. A lot of command line and library HTTP agents ignore the fragment part of an URL, so you often might encounter everything after # stripped. Thus forcing you to invent yet another HTTP client/agent/URL library in a ton of languages.
Yes, this is just how fragments work; they're supposed to be stripped before sending the request to the server. This is exactly why, in the context of the thread, the fragment is the correct place to put the TSON hash parameter.
>> Ordering, consensus, and mutability policy are application concerns outside this series. [1]
Of course, immutable means as-is, but since you're not dealing with ordering etc (that's pretty big), I might as well use existing tech (JSON with a schema) and a policy (simple/naive: hash and compare lowercased data).
My thoughts exactly. I don't mind AI coding, but I'm not really sure on the viability of anyone using or even hearing of TSON. This is just not something you do without an RFC and adoption.
No comments means that one cannot use it for configuration. Properties repeat the XML mistake of the attribute/content dichotomy.
And trailing commas as a syntax error prevents easy sorting/appending/editing of arrays.
And it doesn't fix a ton of JSON problems like strings containing newlines, quotes and the like, while introducing a ton of new problems, like the dependency on obscure Unicode features to elide quotes. This will lead to TSON homoglyph attacks.
Schemas, etc. look a lot like JSON-LD. You would need to pin the schema only if you're worried someone might modify one. But it gives you a lot of options out of the box, while still being valid JSON.
I wonder where this should fit in?
It introduces itself as
> Data with an immutable schema.
But for what? I don't see a fit for APIs here, maybe config but there are already other languages that are perfectly suited for this job.
Also this feels more like some proposal than a serious attempt to build a new format. Java is widely used but I would at least expect such a new format to at least release with Java-/TypeScript, Go and Python libraries (personal perference: Rust too). But just a Java launch is at best a PoC.
> TSON (Typed Schema Object Notation) is a schema system with immutable, hash-pinned schemas whose definitions are themselves data. A document names its schema, the schema names its meta-schema; one hash verifies the whole chain. The finishing touch, TSON's data format is a Unicode-first superset of JSON you'll actually enjoy writing.
I'm not sure what problem this is solving?
I rarely have issues with JSON schema validation; and when I do, the failure patterns aren't something that I want to offload to a 3rd party library.
Basically, how my application fails with poorly formed JSON is part of how I define my application, which means that unexpected JSON needs to be handled on a case-by-case basis.
---
Anyway, the system smells like xsd, which when I used it, wasn't worth the effort.
myshapeprotocol | 6 hours ago
[OP] andrewjneumann | 6 hours ago
flanked-evergl | 6 hours ago
IncreasePosts | 6 hours ago
How do you add schema info to that?
crote | 6 hours ago
phailhaus | 6 hours ago
ltbarcly3 | 6 hours ago
hyperhello | 5 hours ago
inigyou | 5 hours ago
azatom | 6 hours ago
robto | 6 hours ago
Don't know how I feel about optional quotes around strings, that seems like a mistake. And having an immutable set literal would be nice as well.
waweic | 6 hours ago
Really unfortunate naming
esafak | 6 hours ago
tonyg | 6 hours ago
eska | 5 hours ago
hmokiguess | 6 hours ago
pyuser583 | 5 hours ago
yourapostasy | 5 hours ago
So I've never rejected XML out of hand, but I've always been "show me" skeptical of calls for it and pushed for explanations on why the business requirements feel the justification to adopt XML. Sometimes I've seen it totally makes sense, but with the conceptual rigor it requires in those use cases, the skillset and expertise of the development team has to reach a higher than average bar. I'm cautiously hopeful LLM's might help with lowering that bar, but time will tell.
conartist6 | 3 hours ago
If you want to know how I would approach designinga language to fill XML's market niche, check out https://docs.bablr.org/guides/cstml
minraws | 6 hours ago
kelseydh | 4 hours ago
ltbarcly3 | 6 hours ago
Retr0id | 5 hours ago
Also, I see mention of hashing, but no mention of canonicalization. Does fiddling with a schema's whitespace change its hash?
ramses0 | 5 hours ago
I've been explicitly trying to support `--json5` on some of my internal work tooling. Being very explicit that I'm not parsing `--json`, but instead using a slower (but more forgiving) `--json5` which would allow comments, trailing commas, whatever JSON5 claims to support.
This `--tson` feels like it's solving two problems in disguise:
1) It wants to be `--json6` (eg: `pi: !number 3.14`)
2) It wants to use it's own `--json6` (aka: `--tson`) to write "json-ish schemas" (eg: `foo: [text; 1..10]` for presumably a list of maximum of 10 elements?)
...JSON was a blessing because it existed naturally as an unambiguous "lists, dicts, values" representation that most programming languages treat as first-class citizens. Missing "sets" and things like "date" or "boolean" are certainly under-specified, but that's the real-world impact of JSON as lowest common denominator.
SCHEMA's don't have nearly as much natural, unambiguous representations across many programming languages. The closest thing I can think of is straight up Java + Constructors (ie: a full programming language for object initialization but w/o allowing interaction or behavior).
...where my mind has gone lately is doubling down on TypeScript's `*.d.ts` as a "naturally occurring, expressive schema language". It's hella-more-complicated to parse/validate than JSON, but there's tons of tooling around it, and it's relatively unambiguous that it can solve and express Real World(tm) engineering problems.Retr0id | 3 hours ago
deepsun | 2 hours ago
But it's pretty ambiguous when parsing. Like a long number -- is it a floating point, BigInt or i128? Every language is different
JSON was a blessing because it was literally Javascript. It was unambiguous in Javascript only.
A true unambiguous would be "everything is a string", like TCL.
kbolino | 5 hours ago
geoah | 5 hours ago
thyristan | 3 hours ago
kbolino | 6 minutes ago
lokar | 5 hours ago
pratyahava | 5 hours ago
lokar | 4 hours ago
I’ve used it once for something small. It was ok, but the docs and some of the libraries were a bit lacking.
But it demonstrates the kind of things you could have if you don’t care about text/parser compatibility with json
biggestlou | 5 hours ago
al_be_back | 5 hours ago
Of course, immutable means as-is, but since you're not dealing with ordering etc (that's pretty big), I might as well use existing tech (JSON with a schema) and a policy (simple/naive: hash and compare lowercased data).
[1] From their spec: 2.2.1 Identity and Content Addressing - https://tson.io/2026/32/tson-part1-data/#
dizlexic | 4 hours ago
jensneuse | 4 hours ago
tantalor | 4 hours ago
corbindavenport | 4 hours ago
aggregator-ios | 4 hours ago
tanepiper | 3 hours ago
thyristan | 3 hours ago
No comments means that one cannot use it for configuration. Properties repeat the XML mistake of the attribute/content dichotomy.
And trailing commas as a syntax error prevents easy sorting/appending/editing of arrays.
And it doesn't fix a ton of JSON problems like strings containing newlines, quotes and the like, while introducing a ton of new problems, like the dependency on obscure Unicode features to elide quotes. This will lead to TSON homoglyph attacks.
aljarry | 3 hours ago
sandeepkd | 3 hours ago
Yannik_Sc | 2 hours ago
> Data with an immutable schema.
But for what? I don't see a fit for APIs here, maybe config but there are already other languages that are perfectly suited for this job.
Also this feels more like some proposal than a serious attempt to build a new format. Java is widely used but I would at least expect such a new format to at least release with Java-/TypeScript, Go and Python libraries (personal perference: Rust too). But just a Java launch is at best a PoC.
tomnipotent | 2 hours ago
Baically protobuf, Cap’n Proto, msgpack, Avro, or every other serialization approach that versions schemas?
gwbas1c | 2 hours ago
> Data with an immutable schema.
> TSON (Typed Schema Object Notation) is a schema system with immutable, hash-pinned schemas whose definitions are themselves data. A document names its schema, the schema names its meta-schema; one hash verifies the whole chain. The finishing touch, TSON's data format is a Unicode-first superset of JSON you'll actually enjoy writing.
I'm not sure what problem this is solving?
I rarely have issues with JSON schema validation; and when I do, the failure patterns aren't something that I want to offload to a 3rd party library.
Basically, how my application fails with poorly formed JSON is part of how I define my application, which means that unexpected JSON needs to be handled on a case-by-case basis.
---
Anyway, the system smells like xsd, which when I used it, wasn't worth the effort.