Trying to understand JSON…
Trying to understand JSON…
Meme transcription: Panel 1. Two images of JSON, one is the empty object, one is an object in which the key name maps to the value null. Caption: “Corporate needs you to find the difference between this picture and this picture”
Panel 2. The Java backend dev answers, “They’re the same picture.”
If you’re branching logic due to the existence or non-existence of a field rather than the value of a field (or treating undefined different from null), I’m going to say you’re the one doing something wrong, not the Java dev.
These two things SHOULD be treated the same by anybody in most cases, with the possible exception of rejecting the later due to schema mismatch (i.e. when a “name” field should never be defined, regardless of the value).
They're semantically different for PATCH requests. The first does nothing, the second should unset the
namefield.Only if using JSON merge patch, and that's the only time it's acceptable. But JSON patch should be preferred over JSON merge patch anyway.
Servers should accept both null and undefined for normal request bodies, and clients should treat both as the same in responses. API designers should not give each bespoke semantics.
Ya, having null semantics is one thing, but having different null and absent/undefined semantics just seems like a bad idea.
Billion dollar mistake
For those who don’t know:
Speaking at a software conference in 2009, Tony Hoare hyperbolically apologized for "inventing" the null reference:[26] [27]
I call it my billion-dollar mistake. It was the invention of the null reference in 1965. At that time, I was designing the first comprehensive type system for references in an object oriented language (ALGOL W). My goal was to ensure that all use of references should be absolutely safe, with checking performed automatically by the compiler. But I couldn't resist the temptation to put in a null reference, simply because it was so easy to implement. This has led to innumerable errors, vulnerabilities, and system crashes, which have probably caused a billion dollars of pain and damage in the last forty years.
Huh, so Tony Hoare invented
nulland then Graydon Hoare invented Rust,immediately terminating the existence ofwhich does not have a traditionalnullnullvalue.
Thanks for the transcription!
Surely Java can tell the difference between a key with a null value and the absence of that key, no?
I mean, you can set up your deserialization to handle nulls in different ways, but a string to object dictionary would capture this, right?
Sure, Java can tell the difference. But that doesn’t mean that the guy writing the API cares whether or not he adds a key to the dictionary before yeeting it to the client.
Kinda, I guess we all can agree it’s more typical to deserialize into POJO where theres is no such thing as missing field. Otherwise why would you choose Java if you don’t use types. This great precondition for various stupid hacks to achieve „patching” resources, like blank strings or negative numbers for positive-only fields or even Optional as a field.
You can always bind the JSON to a hashmap implementation, as that’s all JSON is anyway. It’s not pretty but it works.
It can, but especially during serialization Java sometimes adds null references to null values.
That's usually a mistake by the API designer and/or Java dev, but happens pretty often.
I’m sad that there are people who call themselves developers who need to be told this.
Just what every programming language needs, not one, but two types of null! Because nobody ever said one type was difficult enough.
If I see any of you make this distinction matter for anything other than "PUT vs. PATCH" semantics I'm going to be very angry.
I do this constantly.
undefined: not retrieved yet.null: Error when retrieving. Makes it easy to reason about what the current state of the data is without the need for additional status flags.
Had to solve this with Go recently, which was not as straightforward as I'd hoped! https://www.jvt.me/posts/2024/01/09/go-json-nullable/