## 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 watch the lecture again! :)
>
> **2:** Actually yes, but that's not the main reason. 
> 
> **3:** Come on!


## 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.
> 


## How Go handles error handling?
1. Using a throw/catch statement
2. Using a simple if statement with nil comparison *CORRECT*
3. Using a mechanism called tagging

> **1:** There isn't a throw/catch statement 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.