Explaining Java's Optional -[OOP & Java #14]
Tags: computerscience, java
Published: 2021-05-04 06:11:34

##### TLDR: You should watch this [video by Stuart Marks](https://youtu.be/fBYhtvY19xA) if you wish to learn more about the considerations behind Java's **Optional** feature and its practical usage.
{% youtube fBYhtvY19xA %}

---

## Motivation
I was introduced to Java's Optional as a response to the billion-dollar mistake made by Tony Hoare, the little monster called **"null"**.
>Tony Hoare introduced Null references in ALGOL W back in 1965 "simply because it was so easy to implement", says Mr. Hoare. He talks about that decision considering it "my billion-dollar mistake".

Honestly, I had never considered null as the problematic kid on the block. If there were any thoughts as a Java beginner, I felt that null was extremely helpful in dealing with return types. No suitable object for a method to return? Just return null.

When I learned about Optional, I thought that it is an unnecessary abstraction. Why go through the trouble of boxing up an object and then pass the instructions to the box in order to interact with the value contained in the Optional? This is actually because of the problem of null reference and also issues with having null as a return value.

#### Problem with null reference
When methods calls are chained together, a method within the chain will cause the following method to throw an exception if it returns null.
```java
methodA().methodB().methodC();
// if methodB returns null, it results in
// null.methodC()
// Not a good idea
```
The issue with this is that although we can proactively check for null references before invoking a method call, that solution will result in messy and necessarily long code just to ensure a method call is legitimate.
```java
Foo foo = methodA();
if (foo != null) {
	Bar bar = foo.methodB();
	if (bar != null) {
		Coo coo = bar.methodC();
	}
}
```
#### Problem with the meaning of null
There might be cases where null is returned to signify an empty value. And there might be cases that null is returned to mean invalid. Therefore, it might be confusing to use it as a return value. This often means that the developer has to put in an extra effort to express his intent in the comment or in the documentation. The callers to such code also suffer from having to deal with such functions with care.

## Solution provided by Optional 
I choose to leave out the details of Optional API and its usage for now as I intend to cover it together with Java's Stream and CompletableFuture, drawing on their similarity of providing a context/abstraction. The details of the Optional API could be found at the official Java API [website](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Optional.html)

## Conclusion
Optional is simply a language feature but it is worth learning the concept and reasoning behind its existence. This is because most languages face the same issue and while individual implementations might have different names, they all operate on similar logic and resolution technique. 
# Recommended guidelines
- Optional is intended to provide is a limited mechanism for method return types where there is a clear need to represent "no result", and where using null for that is overwhelmingly likely to cause errors.
- Avoid using Optional.get()
- Avoid using Optional in fields, method parameters, and collections.