Optionally available has quite a few issues with out countervailing advantages. It doesn’t make your code extra appropriate or strong. There’s a actual downside that Optionally available tries to resolve, and this text reveals a greater solution to resolve it. Subsequently, you might be higher off utilizing an everyday and presumably null Java reference somewhat than Optionally available.
The net and blogosphere are filled with claims that the Optionally available class solves the issue of null pointer exceptions. This isn’t true. Altering your code to make use of the Optionally available class has the next damaging results:
◉ Optionally available transforms a NullPointerException right into a NoSuchElementException, which nonetheless crashes your program.
◉ Optionally available creates new issues that weren’t a hazard earlier than.
◉ Optionally available clutters your code.
◉ Optionally available provides area, time, and coding overhead.
When your code throws a NullPointerException or NoSuchElementException, the underlying logic bug is that you just forgot to test all prospects when processing knowledge. It’s greatest to make use of a software that ensures you don’t overlook. That lets you perceive and repair the underlying downside.
(These criticisms aren’t particular to Java’s implementation of Optionally available. Different languages that declare to have solved the null pointer downside have additionally merely reworked it into a unique manifestation.)
To be clear, the Optionally available class isn’t all unhealthy: If you must use Optionally available, it defines strategies for decreasing code litter when coping with presumably current knowledge. Nonetheless, it is best to nonetheless keep away from the Optionally available class.
The remainder of this text expands on the factors raised above.
Think about the next Cartesian level class with fields x and y (this dialogue is equally relevant to getter strategies):
As a result of a Java reference could also be null, there’s a hazard of a NullPointerException everytime you dereference it, as in myPoint.x under.
…
… myPoint.x …
If myPoint is null and doesn’t seek advice from an actual level, then myPoint.x throws a NullPointerException and this system crashes. The next is a solution to write this code utilizing Optionally available:
If myOPoint doesn’t include an actual level, then myOPoint.get().x throws a NoSuchElementException and this system crashes. This isn’t any higher than the unique code, as a result of the programmer’s objective is to forestall all crashes, not simply NullPointerException crashes!
It’s doable to forestall the exception and crash by doing a test first.
if (myPoint != null) {
… myPoint.x …
}
or
if (myOPoint.isPresent()) {
… myOPoint.get().x …
}
Once more, the code may be very related and Optionally available just isn’t superior to utilizing an everyday Java reference.
Optionally available is vulnerable to misuse
Optionally available is a Java class; due to this fact, the variable myOPoint of sort Optionally available<Level> may be null. Thus, the expression myOPoint.get() would possibly throw a NullPointerException or a NoSuchElementException! You actually need to write down the next:
if (myOPoint != null && myOPoint.isPresent()) {
… myOPoint.get().x …
}
You may specific complicated knowledge utilizing the excellence between a null Optionally available worth, a non-null Optionally available with knowledge absent, and a non-null Optionally available with knowledge current, however that is complicated and complicated. Alternatively, you would resolve to forgo these prospects and to watch out and disciplined about not letting variables of sort Optionally available be null. Nonetheless, in the event you trusted your self about that, you wouldn’t have had any null pointer exceptions within the first place and also you wouldn’t be utilizing Optionally available.
Optionally available clutters your code
With the Optionally available library, your code is extra verbose, as proven within the following examples:
◉ Code for sort names: Optionally available<Level> versus Level
◉ Code for checking a price: myOPoint.isPresent() versus myPoint == null
◉ Code for accessing knowledge: myOPoint.get().x versus myPoint.x
Optionally available introduces overhead
Optionally available introduces area overhead: An Optionally available is a separate object that consumes further reminiscence.
Optionally available introduces time overhead: Its knowledge should be accessed by way of an additional indirection, and calling strategies on it’s dearer than Java’s environment friendly take a look at for null.
Optionally available introduces coding overhead: You have to take care of Optionally available’s incompatibility with present interfaces that use null, with the truth that it’s not serializable, and so forth.
The true downside: Remembering to carry out checks
A NullPointerException or NoSuchElementException happens as a result of the programmer forgot to carry out a test to see if knowledge is current, by way of != null or .isPresent(), earlier than making an attempt to make use of the info.
Many individuals say that the primary good thing about Optionally available is that with Optionally available, you might be much less prone to overlook to carry out the test. If true, that’s good! Nonetheless, it’s not sufficient to make an issue considerably much less seemingly, within the few locations the place Optionally available is written. It’s higher to have a assure that eliminates the issue in all places.
A method can be to power the programmer to at all times carry out the test earlier than accessing the info. (That is what some programming languages do, by providing a destructuring or pattern-match operator.) This is able to end in many redundant checks in locations the place the test has already been carried out or it’s not actually wanted. (As an analogy, take into consideration how some programmers react to checked exceptions, which power the programmer to do a test whether or not the programmer needs to do it or not.)
For instance, take into account Nullness Checker. It really works at compile time, and it examines each dereference in your program and requires that the receiver is thought to be non-null. That could possibly be as a result of you have got already checked it or as a result of it was generated by a supply that by no means produces null.
Nullness Checker makes use of highly effective evaluation to maintain monitor of whether or not a reference may be null. By comparability to using Optionally available, this reduces the variety of warnings and the variety of redundant checks which are wanted. By default, Nullness Checker assumes that references are non-null, however you’ll be able to specify presumably lacking knowledge by writing @Nullable, as within the sort @Nullable Level.
Writing @Nullable Level is analogous to Optionally available<Level>, however with the next vital advantages:
◉ There may be much less litter, since you write the @Nullable annotation on fields and methodology signatures—usually not inside methodology our bodies.
◉ It’s appropriate with present Java code and libraries. There isn’t a want to vary your code to name strategies of Optionally available. There isn’t a want to vary interfaces and purchasers to make use of the Optionally available sort and no must convert between Optionally available cases and common references.
◉ There isn’t a runtime overhead.
◉ You get a compile-time assure or a warning, by no means a runtime crash.
◉ The code is healthier documented. If Optionally available just isn’t current on a kind, you don’t know whether or not the programmer forgot it, Optionally available couldn’t be written due to backward compatibility, or the info is actually at all times current. With the static evaluation of Nullness Checker, the annotations are machine-checked at compile time, so this system has @Nullable on each reference that may be null.
◉ You get ensures about sources of null pointer exceptions, reminiscent of partially initialized objects and calls to Map.get, that Optionally available just isn’t relevant to. It could additionally specific methodology preconditions, that are helpful for fields containing presumably lacking knowledge.
Nullness Checker achieves the objective of guaranteeing that you just always remember to test for the presence of knowledge, wherever in your code, in a method that’s much less disruptive than using Optionally available. Different instruments reminiscent of NullAway and Infer give related ensures with completely different trade-offs.
Since each programmer error associated to null references is feasible with Optionally available, and Optionally available makes new varieties of errors doable, programmers want help to keep away from making all these errors. The Checker Framework additionally comprises a compile-time Optionally available Checker that does precisely that, and it’s helpful if you must use Optionally available (reminiscent of to interface with a library that makes use of Optionally available).
Optionally available’s helpful strategies
Though Optionally available tends to litter your code, if you must use Optionally available, it gives strategies that cut back the litter. Listed here are two examples.
◉ Its orElse methodology returns the worth whether it is current, or else it returns a default worth.
◉ Its map methodology abstracts the sample by doing the next:
◉ It takes as enter a price.
◉ If the worth is null, it returns null.
◉ In any other case, it applies a perform to the worth and returns the outcome.
There are libraries that do the very same issues for normal Java references. An instance is the Choose class that’s distributed with the Checker Framework. For every occasion methodology in Optionally available, the Choose class features a static methodology.
Counterarguments
Not everybody claims that Optionally available solves the issue underlying null pointer exceptions. As an example, Oracle’s JDK staff doesn’t declare this.
A common programming rule is to keep away from, as a lot as doable, the scenario that knowledge just isn’t current. This reduces the necessity to write a kind reminiscent of Optionally available<Level> or @Nullable Level. All of the arguments on this article proceed to carry wherever in your program knowledge may not be current.
The primary argument for Optionally available on return varieties is, “It’s too straightforward for purchasers to overlook to deal with the potential of a null return worth. Optionally available is ugly and in your face, so a shopper is much less prone to overlook to deal with the potential of an empty return worth. In all places else, programmers ought to proceed to make use of regular references, which may be null.” In contrast, my suggestion is that programmers ought to proceed to make use of regular references in all places of their program however use a software to make sure that at each doable location—not simply at methodology calls—this system checks in opposition to null when wanted.
When you discover a model of utilizing Optionally available that solves a part of your issues, at a suitable value to you, then good for you—use it.
