5 ms·
TSON – A JSON superset with immutable, hash-pinned schemas
- myshapeprotocol 2mo ago[flagged]
- andrewjneumann 2mo agoAgree. It’s early stages, but I love the approach!
- flanked-evergl 2mo agowhy can't you use hash pinned schemas with existing json? Why do you need a new format for it?
- IncreasePosts 2mo agoHere's some json: [] How do you add schema info to that?
- crote 2mo agoLike this: { 'schema': 'c3ab8ff13720e8ad9047dd39466b3c8974e592c2fa383d4a3960714caef0c4f2', 'data': [] }
- phailhaus 2mo agoAnd there you go, just `[]` is no longer valid, so you need a new format.
- ltbarcly3 2mo agoIf you need a schema for [] you have lost the plot.
- hyperhello 2mo agoWell, you could be annotating type that the array is for.
- inigyou 2mo agoIt's the schema's root type, obviously.
- IncreasePosts 2mo agoWhat record types are valid to add to that array?
- inigyou 2mo agoDon't ask me, ask the schema.
- deleted 2mo ago[deleted]
- phailhaus 2mo agoAre you serious? Do you honestly think that I am talking about a schema for passing empty lists around? If you are passing around lists of structured objects, I need you to send me what those objects are supposed to look like even if the list is empty sometimes. If you say "ok so sometimes I'll give you an object with a schema key and a list of data, other times I will just give you an empty list because I don't feel like it", everyone will hate you.
- flanked-evergl 2mo agoIf you need to embed the schema in the document, Don't design your schema in way that makes it impossible to embed the schema in the document. [1]: https://json-schema.org/learn/miscellaneous-examples https://json-schema.org/learn/miscellaneous-examples
- azatom 2mo agowhen will be xson invented, with support of xpathson and xsdson but strictly leaving out other xml features.. for future improvement?
- robto 2mo agoSeems 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.
- waweic 2mo agoBecause 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. Really unfortunate naming
- esafak 2mo agoIf the author is here, the Github repo in https://litterat.io/ https://litterat.io/ should be https://github.com/litterat https://github.com/litterat
- tonyg 2mo agoAbsolute 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/ https://preserves.dev/ . Though with a much prettier website and far, far, far more words.
- eska 2mo agoI 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.
- hmokiguess 2mo agoI think I'm gonna go back to XSLT
- pyuser583 2mo agoAlways tempted, but never enough.
- yourapostasy 2mo agoI 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.
- conartist6 2mo agoI 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. 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 https://docs.bablr.org/guides/cstml
- minraws 2mo agoyou 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...
- kelseydh 2mo agoA change in the direction of protobufs to reduce serialization and transfer costs of data exchange seems most likely the next trend.
- Diti 2mo agoThis has been a solved problem for at least two decades. Use ASN.1 and choose your encoding rules accordingly: JER when you need JSON, XER when you need XML, and switch to BER/DER when you need to reduce transfer costs.
- ltbarcly3 2mo agogreat another shitty JSON variant. now I'll have 9 different json-like libraries in every project that I can't get rid of.
- Retr0id 2mo agoWhat'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?
- ramses0 2mo ago"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. $ echo '{ "Hello": !number 3.14 }' | jq '.' jq: parse error: Invalid numeric literal at line 1, column 19 ...THAT's the difference/extension. 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.
- kbolino 2mo agoUsing 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 https://datatracker.ietf.org/doc/html/rfc3986#section-3.4
- geoah 2mo agoWas thinking the same. ?v=4#sha111 for defining the version and using fragment for hash verification seemed like a more interesting approach.
- thyristan 2mo agoFragments 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.
- kbolino 2mo agoYes, 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.
- thyristan 2mo agoIt is fine to have the fragment stripped before sending it to the server. What I meant was that client-side parsing of TSON in many languages will be hindered by the client-side libraries stripping the fragment far too early. Because you will need that fragment part for validation, but if your parse_url-function dismisses the fragment because nobody ever needs it...
- thomasnowhere 2mo ago[dead]
- lokar 2mo agoSeem to different from JSON to be an easy drop in, while still having the problems of json. I’d rather use something further away like cue.
- pratyahava 2mo agocue? what is that? i remember only cue which holds audio tracks metadata.
- lokar 2mo agohttps://cuelang.org/docs/reference/spec/ https://cuelang.org/docs/reference/spec/ 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 2mo agoSorry, but this tool is just never going to succeed being written in Java.
- al_be_back 2mo ago>> 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). [1] From their spec: 2.2.1 Identity and Content Addressing - https://tson.io/2026/32/tson-part1-data/# https://tson.io/2026/32/tson-part1-data/#
- dizlexic 2mo agoWhy?
- jensneuse 2mo agoWhat problem does it solve? The hero of the website doesn't answer.
- tantalor 2mo agoJust use protos?
- hdjrudni 2mo agoAuthor doesn't like protos. > Protobuf even marks the required keyword a hazard developers must avoid. These rules exist because a single definition is forced to serve every document ever written against it. TSON removes this burden because schemas are immutable. I personally don't have a problem with them. They've grown on me. Thought they looked icky before I actually had to use them. Now I see their merit.
- corbindavenport 2mo agoThe website smells vibe-coded.
- aggregator-ios 2mo agoMy 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.
- polymer8563 2mo agovibe-ideated too
- tanepiper 2mo agoGetting flashback to coffeescript
- thyristan 2mo agoDislike. 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 2mo agoSchemas, 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.
- sandeepkd 2mo agoNot sure if I am the only one feeling this way, but what problem is being solved with this?
- Yannik_Sc 2mo agoI 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.
- tomnipotent 2mo ago> I don't see a fit for APIs here Baically protobuf, Cap’n Proto, msgpack, Avro, or every other serialization approach that versions schemas?
- gwbas1c 2mo agoWhat problem is this trying to solve? > 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.
- eventualcomp 2mo agoI just use Amazon Ion as my JSON superset of choice for my own sanity, and downconvert to JSON when (if) it matters, it's not even bad and it supports comments. Hell there's a freaking Lisp for it now, too (Fusion). https://ion-fusion.dev/ https://ion-fusion.dev/ Given also that it's a big tech technology I am going to wager that it's not going away anytime soon.
- kkukshtel 2mo agoThis looks like AI slop, and also a worse version of CUE. https://cuelang.org/ https://cuelang.org/
- hdjrudni 2mo ago> Version 2 just added a new required email field to the person record. In mutable schema systems, adding a new required field is universally forbidden. The API guidelines for Google, Microsoft and Zalando all ban the practice. Protobuf even marks the required keyword a hazard developers must avoid. These rules exist because a single definition is forced to serve every document ever written against it. TSON removes this burden because schemas are immutable. A version is simply a new document with a new hash. Two contracts coexist at full strength, and employee composing person inherits the new requirement in the same declaration. I don't understand how this helps. That just means I have dozens of schemas for the same data set. How is that better? I'd rather have one lowest common denominator schema for the entire data set and be forced to validate. I mean I guess because the data blob specifies its own schema I can use that schema to ensure the blob is valid but then what. What is my code that processes this data supposed to do? `if(schema1) { ... } else if(schema2) { ... }`. How is that better?
- polymer8563 2mo agoMy friend you have discovered Nickel but with less types
- tensility 2mo agoOkay, but does it support comments?