What is wrong with NULL

#1

Post by mjswensen » Mon, Aug 31, 2015, 8:42 PM UTC

Re: What is wrong with NULL

#2

Post by kazinator » Mon, Aug 31, 2015, 8:56 PM UTC

The mistake is an unsafe null: making every object type carry a value in its domain which says "Oops, though my type says I'm a Foobar, I'm not actually an object, la la la! Have a free exception on me, in your face!"

Lisp's NIL is brilliant. It's in its own type, the null type! And it's the only instance of that type. No other type has a null instance.

Null references in the language simply reflect the tension between the static type system which is supposed to assure us that if static checks pass, then values are not misused, and the need to have sometimes (at the very least) a "Maybe" type: maybe we have an object, or maybe not. Null references are the "poor hacker's Maybe": let's make every type support a null value, so that Maybe shows up everywhere.

Maybe, or something like the Lisp NIL, are themselves not mistakes by any stretch of the imagination. Sometimes you really need the code to express the idea that an object isn't there: directly, not with hacks like some representative instance, and some booelan flag which says "that's just a decoy indicating the object isn't there". You want the exception if the decoy is used as if it were an object; that's a bug. Something is trying to operate on an object in a situation when there is no object; safely operating on a decoy just sweeps this under the rug. (Yet, not always: sometimes operating on the decoy is fine. Lisp's NIL lets us specialize a method parameter to the NULL class and deal with it that way in one place.)

Re: What is wrong with NULL

#3

Post by PaulAJ » Mon, Aug 31, 2015, 9:03 PM UTC

This mistake is fixed in Haskell.

Re: What is wrong with NULL

#4

Post by ant6n » Mon, Aug 31, 2015, 9:03 PM UTC

For statically typed languages this is definitely an issue, but for dynamic languages less so. In Python, I wouldn't use an optional value,

  x is None

seems to be just fine. I'm still waiting for

  std::optional

for C++.

Re: What is wrong with NULL

#5

Post by xyzzyz » Mon, Aug 31, 2015, 9:04 PM UTC

kazinator wrote: post #2

The mistake is an unsafe null: making every object type carry a value in its domain which says "Oops, though my type says I'm a Foobar, I'm not actually an object, la la la! Have a free exception on me, in your face!" Lisp's NIL is brilliant. It's in its own type, the null type! And it's the only instance of that type. No other type has a null instance. Null references in the language simply reflect the tension betwe…

nil really isn't any better than null-pointers/references. In the end, you need to check for nil-ness anyway, and there's no mechanism that will help you ensure the check is made. Algebraic data types with pattern matching, that is, Maybe/option is really the proper solution.

Re: What is wrong with NULL

#6

Post by seagreen » Mon, Aug 31, 2015, 9:05 PM UTC

PaulAJ wrote: post #3

This mistake is fixed in Haskell.

That's mentioned in the article. It gives Haskell's null handling a score of 5 stars, along with OCaml and Standard ML.

EDIT: The articles definition of 5 star null handling is "Does not have NULL." :)

Re: What is wrong with NULL

#7

Post by kinghajj » Mon, Aug 31, 2015, 9:05 PM UTC

PaulAJ wrote: post #3

This mistake is fixed in Haskell.

Rust, too!

Edit: Btw, I disagree with how the article categorizes Rust in comparison to Haskell. It shows that Rust has std::ptr::null, but neglects the fact that Haskell has Foreign.Ptr.nullPtr. Either both should be "5 stars" or both should be "4 stars".

Re: What is wrong with NULL

#8

Post by weaksauce » Mon, Aug 31, 2015, 9:05 PM UTC

kazinator wrote: post #2

The mistake is an unsafe null: making every object type carry a value in its domain which says "Oops, though my type says I'm a Foobar, I'm not actually an object, la la la! Have a free exception on me, in your face!" Lisp's NIL is brilliant. It's in its own type, the null type! And it's the only instance of that type. No other type has a null instance. Null references in the language simply reflect the tension betwe…

ruby nil is similar in that it's an instance of the Nil class. though, calling a method on nil that isn't there is a common error.

I like how swift handles things. strong type system that makes it a little painful to do things unsafely. guarantees some things that make it a powerful and more safe language than objective c. I think they lost a few dynamic patterns though in the transition but that's just what i recall from a blog post and the details of it are a little fuzzy.

Re: What is wrong with NULL

#9

Post by tines » Mon, Aug 31, 2015, 9:05 PM UTC

kazinator wrote: post #2

The mistake is an unsafe null: making every object type carry a value in its domain which says "Oops, though my type says I'm a Foobar, I'm not actually an object, la la la! Have a free exception on me, in your face!" Lisp's NIL is brilliant. It's in its own type, the null type! And it's the only instance of that type. No other type has a null instance. Null references in the language simply reflect the tension betwe…

Though the philosophy is different, I'm not sure I see an advantage for NIL when you just look at the effect it has on a programmer's code. You can still have a "NULL-pointer dereference" in CL, except the error is rephrased as "SYSTEM::%STRUCTURE-REF: NIL is not a structure of type X" or whatever. And you still have to have "(if (not (null x)) ...)" which doesn't do much for you, regardless of the underlying theory.

Re: What is wrong with NULL

#10

Post by bronson » Mon, Aug 31, 2015, 9:05 PM UTC

Uglier than a Windows backslash, odder than ===, more common than PHP, more unfortunate than CORS, more disappointing than Java generics, more inconsistent than XMLHttpRequest, more confusing than a C preprocessor, flakier than MongoDB, and more regrettable than UTF-16, the worst mistake in computer science was introduced in 1965.

That could be the greatest intro sentence ever seen on Hacker News.