News

Kotlin 1.4 Coming with NPE Optimization

The Kotlin community released the 1.3.5 update of the language earlier this month, and along with it, plans for the upcoming 1.4 release and an explanation of a potential impact on Java developers.

The plan is to correct an issue around NullPointerExceptions (NPEs) that stems from Kotlin's interoperability with Java code. Kotlin decreases the chances of NPEs by providing support for nullable types. But because of the language's interoperability with Java, it's impossible to avoid them completely. Kotlin compilers are designed to throws different types of runtime exceptions with clear error messages instead of pure NPEs, which helps developers better understand the source of a nullability problem, but reduces the potential null check optimizations that might be performed by the Kotlin compiler or other bytecode processing tools.

To solve this problem, explained Svetlana Isakova in a blog post, starting with Kotlin 1.4, all runtime null checks will throw a java.lang.NullPointerException instead of a KotlinNullPointerException, IllegalStateException, IllegalArgumentException, or TypeCastException.

This applies to the !! operator, parameter null checks in the method preamble, platform-typed expression null checks, and the as operator with a non-null type. It does not apply to lateinit null checks and explicit library function calls, such as checkNotNull or requireNotNull, Isakova said.

Isakova, who is a developer advocate at JetBrains and co-author of "Kotlin in Action," added that, from a developer's perspective, things won't change that much. "The Kotlin code will throw exceptions with the same error messages as before," she said. "The type of exception changes, but the information passed stays the same." She provides some useful examples in her post.

"After this change of behavior," she added, "the optimizers will be able to decrease the total number of null-checks present in the bytecode by removing repetitive null-checks when possible; since all checks throw the same NPE exception, only one can remain. During such optimizations, the specific helpful messages of NPEs can be lost, but that's the price to be paid for the gained performance benefits. Note that these optimizations are still to be implemented in the corresponding tools, and when implemented, there will be more details about that, but the change of the exception type makes it possible in the future."

A NullPointerException is thrown when an application attempts to use an object reference that has been assigned the null value. This includes things like calling an instance method on the object referred by a null reference and accessing or modifying an instance field of the object referred by a null reference.

Kotlin is a statically typed language similar to Scala, Gosu, Ceylon, and Fantom, which compiles to both JVM byte code and JavaScript. JetBrains has claimed that Kotlin is more stable at runtime than Java, because it can statically check weak points and supports things like variable type interface, closures, extension functions, and mix-ins. It's also less verbose than Java, which means devs can write less code with a more readable syntax.

About the Author

John has been covering the high-tech beat from Silicon Valley and the San Francisco Bay Area for nearly two decades. He serves as Editor-at-Large for Application Development Trends (www.ADTMag.com) and contributes regularly to Redmond Magazine, The Technology Horizons in Education Journal, and Campus Technology. He is the author of more than a dozen books, including The Everything Guide to Social Media; The Everything Computer Book; Blobitecture: Waveform Architecture and Digital Design; John Chambers and the Cisco Way; and Diablo: The Official Strategy Guide.

Featured

AppTrends

Sign up for our newsletter.

Terms and Privacy Policy consent

I agree to this site's Privacy Policy.

Upcoming Events