add: questions and exercises for the if statement

11-if/questions/4-error-handling.md

@@ -0,0 +1,144 @@
+## What's a nil value?
+1. The dark matter that rules the universe.
+2. It's a zero value for pointers or pointer-based types. It means the value is uninitialized. *CORRECT*
+3. It's equal to empty string: `"" == nil` is true.
+
+
+## What's an error value?
+1. It stores the error details *CORRECT*
+2. A global variable which stores the error status.
+3. A global constant which stores the error status.
+
+> **2, 3:** There aren't any global variables in Go. There are only package level variables. And, since the error value is just a value, so it can be stored in any variable.
+> 
+
+
+## Why error handling is needed?
+1. I don't know.
+2. To control the execution flow.
+3. To make a program malware safe.
+4. Because, things can go wrong. *CORRECT*
+
+> **1:** Then, please rewatch the lecture! :)
+>
+> **2:** Actually yes, but that's not the main reason. 
+> 
+> **3:** Come on!
+
+
+## How Go handles error handling?
+1. Using a throw/catch block
+2. Using a simple if statement with nil comparison *CORRECT*
+3. Using a mechanism called tagging
+
+> **1:** There isn't a throw/catch block in Go; unlike Java, C#, and so on... Go is explicit.
+
+
+## When you should handle the errors?
+1. After the main func ends.
+2. Before calling a function.
+3. Immediately, after calling a function which returns an error value. *CORRECT*
+
+
+## For which one of the following functions that you might want to handle the errors?
+```go
+func Read() error
+func Write() error
+func String() string
+func Reset()
+```
+1. Read and Write *CORRECT*
+2. String and Reset
+3. Read, Write and Reset
+4. For neither of them
+5. For all of them
+
+> **1:** They return error values. So, you might want to handle the errors after you call them.
+> 
+> **2:** They don't return error values. So, you don't have to handle any errors.
+> 
+> **3:** Partially true. Try again.
+
+
+## Let's say a function returns a nil error value. So, what does that mean?
+1. The function call is failed.
+2. The function call is successful. *CORRECT*
+3. The function call is in an indeterministic state. We can't know.
+
+
+## Let's say a function returns a non-nil error value. So, what does that mean?
+1. The function call is failed. *CORRECT*
+2. The function call is successful.
+3. The function call is in an indeterministic state. We can't know.
+
+> **1:** Yep. Later on you'll learn that, this is not always true. Sometimes a function can return a non-nil error value, and the returned value may indicate something rather than an error. Search on Google: golang io EOF error if you're curious.
+
+
+## Does the following program correctly handles the error?
+
+**NOTE:** This is what the `ParseDuration` function looks like:
+
+```go
+func ParseDuration(s string) (Duration, error)
+```
+
+```go
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+func main() {
+	d, err := time.ParseDuration("1h10s")
+	if err != nil {
+		fmt.Println(d)
+	}
+}
+```
+1. Yes. It prints the parsed duration if it's successful.
+2. No. It doesn't check for the errors.
+3. No. It prints the duration even when there's an error. *CORRECT*
+
+> **1:** Yes, it handles the error; however it does so incorrectly. Something is missing here. Look closely.
+> 
+> **2:** Actually, it does.
+> 
+> **3:** That's right. It shouldn't use the returned value when there's an error.
+
+
+## Does the following program correctly handles the error?
+
+**NOTE:** This is what the `ParseDuration` function looks like:
+
+```go
+func ParseDuration(s string) (Duration, error)
+```
+
+```go
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+func main() {
+	d, err := time.ParseDuration("1h10s")
+	if err != nil {
+        fmt.Println("Parsing error:", err)
+        return
+    }
+    fmt.Println(d)
+}
+```
+1. Yes. It prints the parsed duration if it's successful. *CORRECT*
+2. No. It doesn't check for the errors.
+3. No. It prints the duration even when there's an error.
+
+> **1:** That's right. When there's an error, it prints a message and it quits from the program.
+> 
+> **2:** Actually, it does.
+> 
+> **3:** No, it does not. It only prints it when there isn't an error.