The worst mistake of computer science

1. NULL subverts types

• toUppercase() can be safely called on any String…unless the String is null.
• read() can be called on any InputStream…unless the InputStream is null.
• toString() can be called on any Object…unless the Object is null.

2. NULL is sloppy

if (str == null || str.equals("")) {
}

if (string.IsNullOrEmpty(str)) {
}

Every time you write code that conflates null strings and empty strings, the Guava team weeps. – Google Guava

3. NULL is a special-case

Pointers

char c = 'A';
char *myChar = &c;
std::cout << *myChar << std::endl;

char *myChar = 123; // compile error
std::cout << *myChar << std::endl;

char *myChar = 0;
std::cout << *myChar << std::endl; // runtime error

Strings

 76 117  99 105 100  32  83 111 102 116 119  97 114 101  0
 L   u   c   i   d       S   o   f   t   w   a   r   e  NUL

4. NULL makes poor APIs

class Store
    ##
    # associate key with value
    #
    def set(key, value)
        ...
    end

    ##
    # get value associated with key, or return nil if there is no such key
    #
    def get(key)
        ...
    end
end

store = Store.new()
store.set('Bob', '801-555-5555')
store.get('Bob') # returns '801-555-5555', which is Bob’s number
store.get('Alice') # returns nil, since it does not have Alice

store = Store.new()
store.set('Ted', nil) # Ted has no phone number
store.get('Ted') # returns nil, since Ted does not have a phone number

5. NULL exacerbates poor language decisions

int x = null; // compile error

Integer i = null;
int x = i; // runtime error

6. NULL is difficult to debug

#include <iostream>
struct Foo {
    int x;
    void bar() {
        std::cout << "La la la" << std::endl;
    }
    void baz() {
        std::cout << x << std::endl;
    }
};
int main() {
    Foo *foo = NULL;
    foo->bar(); // okay
    foo->baz(); // crash
}

    ...
    virtual void bar() {
    ...

int main() {
    Foo *foo = NULL;
    foo->bar(); // crash
    foo->baz();
}

7. NULL is non-composable

int a = 1;     // integer
int? b = 2;    // optional integer that exists
int? c = null; // optional integer that does not exist

1. string is nullable to begin with; you cannot make a non-nullable string
2. Even if string were non-nullable, thus making string? possible, you still wouldn't be able to disambiguate the situation. There isn't a string??

Manipulating Maybes/Options

Optional<Integer> option = ...
if (option.isPresent()) {
   doubled = System.out.println(option.get());
}

option.ifPresent(x -> System.out.println(x));
// or option.ifPresent(System.out::println)

option.map(x -> 2 * x)

option.flatMap(x -> methodReturningOptional(x))

option.orElseGet(5)

1. reducing unsafe assumptions about what values “exist” and which do not
2. making it easy to safely operate on optional data
3. explicitly declaring any unsafe existence assumptions (e.g. with an .get() method)

Down with NULL!

Edits