Last week, I was at the conference. FOSDEM is specific in that it has multiple rooms, each dedicated to a different theme and organized by a team. I had two talks: FOSDEM , in the devroom Practical Introduction to OpenTelemetry Tracing Monitoring and Observability , in the devroom What I miss in Java, the perspective of a Kotlin developer Friends of OpenJDK The second talk is from . Martin Bonnin did a tweet from a single slide, and it created quite a stir, even attracting Brian Goetz. an earlier post In this post, I'd like to expand on the problem of nullability and how it's solved in Kotlin and Java and add my comments to the Twitter thread. Nullability I guess that everybody in software development with more than a couple of years of experience has heard the following quote: 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. -- Tony Hoare The basic idea behind is that one can define an . If one calls a member of such a variable, the runtime locates the memory address of the variable... and fails to dereference it because there's nothing behind it. null uninitialized variable Null values are found in many programming languages under different names: Python has None JavaScript has null So do Java, Scala, and Kotlin Ruby has nil etc. Some languages do allow uninitialized values, such as Rust. not Null-safety In Kotlin As I mentioned, Kotlin does allow values. However, they are baked into the type system. In Kotlin, every type has two indeed two types: null X , which is non-nullable. No variable of type can be . The compiler guarantees it. X X null val str: String = null The code above won't compile. , which is nullable. X? val str: String? = null The code above does compile. If Kotlin allows values, why do its proponents tout its null safety? The compiler refuses to call members on null values, , nullable types. null possible i.e. val str: String? = getNullableString()
val int: Int? = str.toIntOrNull()           //1 Doesn't compile The way to fix the above code is to check whether the variable is before calling its members: null val str: String? = getNullableString()
val int: Int? = if (str == null) null
          else str.toIntOrNull() The above approach is pretty boilerplate-y, so Kotlin offers the null-safe operator to achieve the same: val str: String? = getNullableString()
val int: Int? = str?.toIntOrNull() Null-Safety In Java Now that we have described how Kotlin manages values, it's time to check how Java does it. First, there are neither non-nullable types nor null-safe operators in Java. Thus, every variable can potentially be and should be considered so. null null var MyString str = getMyString();           //1
var Integer anInt = null;                   //2
if (str != null) {
    anInt = str.toIntOrNull();
} has no method, so let's pretend is a wrapper type and delegates to String toIntOrNull() MyString String A mutable reference is necessary. If you chain multiple calls, it's even worse as every return value can potentially be . To be on the safe side, we need to check whether the result of each method call is . The following snippet may throw a : null null NullPointerException var baz = getFoo().getBar().getBaz(); Here's the fixed but much more verbose version: var foo = getFoo();
var bar = null;
var baz = null;
if (foo != null) {
    bar = foo.getBar();
    if (bar != null) {
        baz = bar.getBaz();
    }
} For this reason, Java 8 introduced the type. is a wrapper around a possibly null value. Other languages call it , , etc. Optional Optional Maybe Option Java language's designers advise that a method returns: Type if cannot be X X null Type if can be Optional<X> X null If we change the return type of all the above methods to , we can rewrite the code in a null-safe way - and get immutability on top: Optional final var baz = getFoo().flatMap(Foo::getBar)
                        .flatMap(Bar::getBaz)
                        .orElse(null); My main argument regarding this approach is that the itself could be . The language doesn't guarantee that it's not. Also, it's not advised to use for method input parameters. Optional null Optional To cope with this, annotation-based libraries have popped up: Project Package Non-null annotation Nullable annotation JSR 305 javax.annotation @Nonnull @Nullable Spring org.springframework.lang @NonNull @Nullable JetBrains org.jetbrains.annotations @NotNull @Nullable Findbugs edu.umd.cs.findbugs.annotations @NonNull @Nullable Eclipse org.eclipse.jdt.annotation @NonNull @Nullable Checker framework org.checkerframework.checker.nullness.qual @NonNull @Nullable JSpecify org.jspecify @NonNull @Nullable Lombok org.checkerframework.checker.nullness.qual @NonNull - However, different libraries work in different ways: Spring produces WARNING messages at compile-time. FindBugs requires a dedicated execution. Lombok generates code that adds a null check but throws a if it's anyway. NullPointerException null etc. Thanks to for mentioning , which I didn't know previously. It's an to deal with the current mess. Of course, the famous XKCD comic immediately comes to mind: Sébastien Deleuze JSpecify industry-wide effort I still hope it will work out! Conclusion Java was incepted when -safety was not a big concern. Hence, occurrences are common. The only safe solution is to wrap every method call in a check. It works, but it's boilerplate-y and makes the code harder to read. null NullPointerException null Multiple alternatives are available, but they have issues: They aren't bulletproof, compete with each other, and work very differently. Developers praise Kotlin for its -safety: it's the result of its -handling mechanism baked into the language design. Java will never be able to compete with Kotlin in this regard, as Java language architects value backward compatibility over code safety. null null It's their decision, and it's probably a good one when one remembers the pain of migration from Python 2 to Python 3. However, as a developer, it makes Kotlin a much more attractive option than Java to me. To go further: Are there languages without "null"? Kotlin nullable types and non-null types JSpecify Originally published at on February 12th, 2023 A Java Geek

From the Software Architect Mindset to Solution Architect Mindset (and back again)

How to Secure Admin Access to Apache APISIX

Read all my posts!

Kotlin vs. Java: Which Is the Best When It Comes to Null Safety?

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

16 Best Practices For Securing Your APIs with Apache APISIX - Part 1

Improving the Working Environment for Developers - In 3 Stages Only

Enhancing Developer Productivity: 4 Approaches for CTOs

5 Things I Learned as a Junior Software Developer

7 Indicators of Poor Developer Experience and Ways to Improve It

16 Best Practices For Securing Your APIs with Apache APISIX - Part 1

Improving the Working Environment for Developers - In 3 Stages Only

Enhancing Developer Productivity: 4 Approaches for CTOs

5 Things I Learned as a Junior Software Developer

7 Indicators of Poor Developer Experience and Ways to Improve It

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps