Please find the Code for Nullables here: 

package eu.tutorials.helloworld

fun main(){
    // NULLABLES/OPTIONALS in Kotlin
// Kotlin supports nullability as part of its type System.
// That means You have the ability to declare whether 
// a variable can hold a null value or not.
// By supporting nullability in the type system,
// the compiler can detect 
// possible NullPointerException errors at compile time 
// and reduce the possibility of having them thrown at runtime.
    var name: String = "Denis"
// name = null // Compilation Error

    var nullableName: String? = "Denis"
    nullableName = null // Works

// Here name cannot/must not be null
    val len = name.length
    val upper = name.toLowerCase()

// but the same methods won't work on nullable types
    val len2 = nullableName.length // Compilation Error
    val upper2 = nullableName.toLowerCase()  // Compilation Error

// So how can we solve this? We could do a null check before hand

    val nullableName2: String? = "Denis"

    if(nullableName2 != null) {
        println("Hello, ${nullableName2.toLowerCase()}.")
        println("Your name is ${nullableName2.length} characters long.")
    } else {
        println("Hello, Guest")
    }

// This works but seems to be quite some work...
// So how about we shorten the syntax...
// Kotlin provides a Safe call operator, ?.  
// It allows you to combine a null-check and 
// a method call in a single expression.

    nullableName2?.toLowerCase()

// This is the same as:
    if(nullableName2 != null)
        nullableName2.toLowerCase()
    else
        null

// You can use methods on a nullable variable like this
    val nullableName3: String? = null

    println(nullableName3?.toLowerCase()) // prints null
    println(nullableName3?.length) // prints null

// You can perform a chain safe calls:
    //val wifesAge: String? = user?.wife?.age


// Let'S say we dont want to print anything if 
// the variable is null?

// In order to perform an operation only if the 
// variable is not null, we can use the safe call 
// operator with let -

    val nullableName4: String? = null

    nullableName4?.let { println(it.toLowerCase()) }
    nullableName4?.let { println(it.length) }
// Prints nothing because there nullableName is null 
// and we used let to prevent anything from being performed


// What if we would like to enter a default value?
// Then we can use the elvis operator ?:
    val name2 = nullableName4 ?: "Guest"
    
    //val wifesAge2: String? = user?.wife?.age ?: 0


// Not null assertion : !! Operator
// The !! operator converts a nullable type to a 
// non-null type, and throws a NullPointerException 
// if the nullable type holds a null value.
// This is risky, and you should only use it if 
// you are 100% certain, that there will be a value in 
// the variable.
    val nullableName5: String? = null
    nullableName5!!.toLowerCase() // Results in NullPointerException

}