 //:
 //: ### Introduction to Optionals
 //:
-//: Sometimes, it's useful to express the fact that a variable may contain a value or no value at all. Swift allows us to do this with **optionals**. Optionals contain **either** a value **or** `nil` (meaning "no value").
+//: Sometimes, it's useful to express the fact that a variable may contain a value or no value at all. Swift allows us to do this with **optionals**. Optionals contain **either** a value **or** `nil` (meaning "no value"). Optionals are like boxes that may have something inside, or they may have nothing inside.
 //:
-//: Some languages, such as Objective-C, allow a variable to contain `nil` without its type expressly indicating that a value may be absent. Swift is much more strict about when variables can lack a value, and this is very helpful in avoiding bugs where we think we have a value when in fact we don't. Functions can return an optional to indicate when the operation has failed or they have no value to give back to you.
+//: Some languages, like Objective-C, Python and Java, allow a variable to be set to `nil` or `null` without its type expressly indicating that a value may be absent. Swift is much more strict about when variables can lack a value, and this is very helpful in avoiding bugs where we think we have a value when in fact we don't. Functions can return an optional to indicate when the operation has failed or they have no value to give back to you.
 //:
-//: Syntactically, we express the fact that a value is of optional type by appending a question mark (?) to the type name. For example, here is how we declare a variable of type `Int?` (read as "optional `Int`"):
+//: We express the fact that a value is of optional type by putting a question mark (?) at the end of the type name. For example, here is how we declare a variable of type `Int?` (read as "optional `Int`"):
 
 var maybeAnInt: Int? = 15
 

    println("maybeAnInt does not contain a value")
}

//: Try changing the value of `maybeAnInt` again, and again take note that if it contains a value, the message indicates this and the local variable `definitelyAnInt` has the same value.

//: ### Implicitly Unwrapped Optionals
//:
//: Sometimes we want to indicate that an optional will always have a value when we need to read it. For example, this happens when we separate the declaration of an optional from the first time we set its value. To support this scenario, we can declare a variable as an **implicitly unwrapped optional**. Implicitly unwrapped optionals are declared by placing an exclamation point (!) after the type to indicate that they **can** contain `nil`, but must always have a value when they are read:

var alwaysAString: String! = nil



maybeAnInt = nil

//: Now `maybeAnInt` is `nil`, which is to say it has _no value_. If `maybeAnInt` had just been of type Int, we could not have set it to `nil`.

//: ### Unwrapping an Optional
//:
//: When we get the value from an optional, we say we "unwrap" it. This is like opening the box and seeing whether there's anything inside. We can test whether an optional has a value by comparing the whole thing to `nil`. If it is not equal to `nil`, it contains a value. Woo hoo!
//: We can then safely use **force unwrapping** to get its value. Force unwrapping is done by putting an exclamation point (!) after the name of the variable we want to unwrap. This assures Swift that the optional contains a value and that it is therefore safe to read. Here, we test whether `maybeAnInt` has a value and if it does, we rip open the box (force unwrap) and print its value.

if maybeAnInt != nil {
    println("maybeAnInt contains a value, and it is \(maybeAnInt!)")
