Home » Software Development » What if every object was an array? No more NullPointerExceptions!

About Lukas Eder

Lukas is a Java and SQL enthusiast developer. He created the Data Geekery GmbH. He is the creator of jOOQ, a comprehensive SQL library for Java, and he is blogging mostly about these three topics: Java, SQL and jOOQ.

What if every object was an array? No more NullPointerExceptions!

To NULL or not to NULL? Programming language designers inevitably have to decide whether they support NULLs or not. And they’ve proven to have a hard time getting this right. NULL is not intuitive in any language, because NULL is an axiom of that language, not a rule that can be derived from lower-level axioms. Take Java for instance, where:

// This yields true:
null == null

// These throw an exception (or cannot be compiled)
int value = (Integer) null;

It’s not like there weren’t any alternatives. SQL, for instance, implements a more expressive but probably less intuitive three-value logic, which most developers get wrong in subtle ways once in a while.

At the same time, SQL doesn’t know “NULL” results, only “NULL” column values. From a set theory perspective, there are only empty sets, not NULL sets.

Other languages allow for dereferencing null through special operators, letting the compiler generate tedious null checks for you, behind the scenes. An example for this is Groovy with its null-safe dereferencing operator. This solution is far from being generally accepted, as can be seen in this discussion about a Scala equivalent. Scala uses Option, which Java 8 will imitate using Optional (or @Nullable).

Let’s think about a much broader solution

To me, nullability isn’t a first-class citizen. I personally dislike the fact that Scala’s Option[T] type pollutes my type system by introducing a generic wrapper type (even if it seems to implement similar array-features through the traversable trait). I don’t want to distinguish the types of Option[T] and T. This is specifically true when reasoning about types from a reflection API perspective, where Scala’s (and Java’s) legacy will forever keep me from accessing the type of T at runtime.

But much worse, most of the times, in my application I don’t really want to distinguish between “option” references and “some” references. Heck, I don’t even want to distinguish between having 1 reference and having dozens. jQuery got this quite right. One of the main reasons why jQuery is so popular is because everything you do, you do on a set of wrapped DOM elements. The API never distinguishes between matching 1 or 100 div’s. Check out the following code:

// This clearly operates on a single object or none
$('div#unique-id').html('new content')
                  .click(function() { ... });

// This possibly operates on several objects or none
$('div.any-class').html('new content')
                  .click(function() { ... });

This is possible because JavaScript allows you to override the prototype of the JavaScript Array type, modifying arrays in general, at least for the scope of the jQuery library. How more awesome can it get? .html() and .click() are actions performed on the array as a whole, no matter if you have zero, one, or 100 elements in your match. What would a more typesafe language look like, where everything behaves like an array (or an ArrayList)? Think about the following model:

class Customer {
  String firstNames;  // Read as String[] firstNames
  String lastName;    // Read as String[] lastName
  Order orders;       // Read as Order[] orders

class Order {
  int value;          // Read as int[] value
  boolean shipped() { // Read as boolean[] shipped

Don’t rant (just yet). Let’s assume this wouldn’t lead to memory or computation overhead. Let’s continue thinking about the advantages of this. So, I want to see if a Customer’s orders have been shipped. Easy:

Customer customer = // ...
boolean shipped = customer.orders.shipped();

This doesn’t look spectacular (yet). But beware of the fact that a customer can have several orders, and the above check is really to see if all orders have been shipped. I really don’t want to write the loop, I find it quite obvious that I want to perform the shipped() check on every order. Consider:

// The length pseudo-field would still be
// present on orders

// In fact, the length pseudo-field is also
// present on customer, in case there are several

// Let's add an order to the customer:
customer.orders.add(new Order());

// Let's reset order

// Let's calculate the sum of all values
// OO-style:
// Functional style:

Of course there would be a couple of caveats and the above choice of method names might not be the best one. But being able to deal with single references (nullable or non-nullable) or array references (empty, single-valued, multi-valued) in the same syntactic way is just pure syntax awesomeness. Null-checks would be replaced by length checks, but mostly you don’t even have to do those, because each method would always be called on every element in the array. The current single-reference vs. multi-reference semantics would be documented by naming conventions. Clearly, naming something “orders” indicates that multi-references are possible, whereas naming something “customer” indicates that multi-references are improbable.

As users have commented, this technique is commonly referred to as array programming, which is implemented in Matlab or R.


I’m curious to hear your thoughts!


Do you want to know how to develop your skillset to become a Java Rockstar?

Subscribe to our newsletter to start Rocking right now!

To get you started we give you our best selling eBooks for FREE!


1. JPA Mini Book

2. JVM Troubleshooting Guide

3. JUnit Tutorial for Unit Testing

4. Java Annotations Tutorial

5. Java Interview Questions

6. Spring Interview Questions

7. Android UI Design


and many more ....




  1. I think it is useful to have NullPointerExceptions because of the “fail-fast” philosophy. When you misspell the jQuery selector there is no hint to that mistake and it will be harder to find.

    Furthermore there are many interpretations what
    boolean shipped = customer.orders.shipped();
    may mean. Is it true if any order of any customer is shipped? Or if all orders are shipped for a single customer? Or if all orders of all customers are shipped? etc.

  2. I have been working on a language, and one of the things I like about JavaScript and Python is the fact that every object is for all practical purposes an “Iterable”. You can iterate over the properties and methods and other things.

    I think if objects were transparently treated like “Iterable” that would be interesting vs an Array. Raw Arrays are nothing I want to have to deal with.

    • Yes, approaching the problem through iterables is not a bad idea, although I never liked the fact that JavaScript has no explicit order when iterating over object properties.

      I agree that raw arrays are not a very nice thing in Java, but if a new language was designed from scratch, one might as well design better arrays…

  3. Looking for bugs due to naming conventions. “Ouch” are coming :)

    And all your “if” about “null” will be replaced by test about “foo.length” so I don’t see a big advantage. An advantage about scala Option[T] type is that it’s an internal type not a coding convention so you can test it and in an API you know that you have to deal with that type of behavior (“null or not null”), you don’t test “null” in a defense coding style against misunderstanding about a return value. “Oh yeah, this API can now return a null, I didn’t tell you? I didn’t update the doc? Sorry!”

    Anyway I love (yes, love) programming with list so I do a bit like your suggestion but only for code parts where computation is about 0 to n object, not one and only one. In that case, you can easely overide the “null or not null” problem in a ~foreach (imperative) or a map/filter (functionnal).

    Sorry for my english, I hope it’s understandable.

    • > And all your “if” about “null” will be replaced by test about “foo.length” so I don’t see a big advantage.

      But the point is that you hardly ever need to check. Often you just don’t care. You can write the code in a way that it doesn’t matter if calling the method has an effect (non-empty array) or not (empty array).

      I understand Option. It forces me to deal with null (i.e. not to forget about it). But I actually rarely *want* to deal with null. Your hint about foreach or map/filter probably responds to that, though.

Leave a Reply

Your email address will not be published. Required fields are marked *


Want to take your Java skills to the next level?

Grab our programming books for FREE!

Here are some of the eBooks you will get:

  • Advanced Java Guide
  • Java Design Patterns
  • JMeter Tutorial
  • Java 8 Features Tutorial
  • JUnit Tutorial
  • JSF Programming Cookbook
  • Java Concurrency Essentials