How not to panic

background-image: url("figs/greg-rosenke-WX4LFn24RxQ-unsplash.jpg")
background-size: cover

<p style="font-weight: 900; font-family: Georgia; font-size: 2.5rem; color: white; text-shadow: 2px 2px black;">
How not to panic
</p>

<p style="font-weight: 900; font-family: Georgia; font-size: 2rem; color: white; text-shadow: 2px 2px black;">
in face of an error message
</p>

<br>
<br>
<br>
<br>
<p style="font-weight: 900; font-family: Georgia; font-size: 1.8rem; color: white; text-shadow: 2px 2px black;">
Julia Romanowska
</p>

<p style="font-size: 12pt; font-weight: bold; right: 10px; bottom: 20px; position: absolute; ">
Photo by <a href="https://unsplash.com/@greg_rosenke?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Greg Rosenke</a> on <a href="https://unsplash.com/?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
</p>

???

Any programming requires understanding not only of how to use syntax of a
given programming language or script, but also how the instructions are
evaluated. Because when we know what's going on under the hood in each
step of the program, then we can easily search for sources of error _when_
it occurs. Note that I use "when", not "if" - because there will always be
errors, even if you're super experienced. That's why I don't want you to be
intimidated by the errors - treat them as a challenge.

---

## Overview

### Computer basics

### Types of instructions

### How to translate a problem?

### Program execution

### Exercise

???

Today, I will provide you with a simple model of a computer in action. I will
briefly recap how a computer is made, then I will introduce the most important
types of instructions, next, I will show you how can we translate a simple
question into a program prototype and how an execution of such a program runs.

After this, I will give you a problem to solve.

---

### Computer basics

> _What is a computer?_

- <svg aria-hidden="true" role="img" viewBox="0 0 512 512" style="height:1em;width:1em;vertical-align:-0.125em;margin-left:auto;margin-right:auto;font-size:inherit;fill:currentColor;overflow:visible;position:relative;"><path d="M416 48v416c0 26.51-21.49 48-48 48H144c-26.51 0-48-21.49-48-48V48c0-26.51 21.49-48 48-48h224c26.51 0 48 21.49 48 48zm96 58v12a6 6 0 0 1-6 6h-18v6a6 6 0 0 1-6 6h-42V88h42a6 6 0 0 1 6 6v6h18a6 6 0 0 1 6 6zm0 96v12a6 6 0 0 1-6 6h-18v6a6 6 0 0 1-6 6h-42v-48h42a6 6 0 0 1 6 6v6h18a6 6 0 0 1 6 6zm0 96v12a6 6 0 0 1-6 6h-18v6a6 6 0 0 1-6 6h-42v-48h42a6 6 0 0 1 6 6v6h18a6 6 0 0 1 6 6zm0 96v12a6 6 0 0 1-6 6h-18v6a6 6 0 0 1-6 6h-42v-48h42a6 6 0 0 1 6 6v6h18a6 6 0 0 1 6 6zM30 376h42v48H30a6 6 0 0 1-6-6v-6H6a6 6 0 0 1-6-6v-12a6 6 0 0 1 6-6h18v-6a6 6 0 0 1 6-6zm0-96h42v48H30a6 6 0 0 1-6-6v-6H6a6 6 0 0 1-6-6v-12a6 6 0 0 1 6-6h18v-6a6 6 0 0 1 6-6zm0-96h42v48H30a6 6 0 0 1-6-6v-6H6a6 6 0 0 1-6-6v-12a6 6 0 0 1 6-6h18v-6a6 6 0 0 1 6-6zm0-96h42v48H30a6 6 0 0 1-6-6v-6H6a6 6 0 0 1-6-6v-12a6 6 0 0 1 6-6h18v-6a6 6 0 0 1 6-6z"/></svg> CPU

- <svg aria-hidden="true" role="img" viewBox="0 0 640 512" style="height:1em;width:1.25em;vertical-align:-0.125em;margin-left:auto;margin-right:auto;font-size:inherit;fill:currentColor;overflow:visible;position:relative;"><path d="M640 130.94V96c0-17.67-14.33-32-32-32H32C14.33 64 0 78.33 0 96v34.94c18.6 6.61 32 24.19 32 45.06s-13.4 38.45-32 45.06V320h640v-98.94c-18.6-6.61-32-24.19-32-45.06s13.4-38.45 32-45.06zM224 256h-64V128h64v128zm128 0h-64V128h64v128zm128 0h-64V128h64v128zM0 448h64v-26.67c0-8.84 7.16-16 16-16s16 7.16 16 16V448h128v-26.67c0-8.84 7.16-16 16-16s16 7.16 16 16V448h128v-26.67c0-8.84 7.16-16 16-16s16 7.16 16 16V448h128v-26.67c0-8.84 7.16-16 16-16s16 7.16 16 16V448h64v-96H0v96z"/></svg> RAM

- <img src="figs/hard-drive-solid.svg" style="width: 20px;"> disk
]

???

CPU = central processing unit

RAM = random access memory

disk

These are all connected. CPU reads from and writes to memory, so to analyse
anything, we need to read it from a disk into the memory. Then, to save it for
later, we need to save it to disk.

- instructions

- processing:
  1. input
  2. store / analyse
  3. output
]

???

For now, however, let's forget the hardware and focus on a computer as a 
machine that processes data according to instructions.

In each of these three steps there can be an error!

---

### Types of instructions

**1. Declaration**

**2. Input**

**3. Output**

**4. Assignment**

???

Generally, all the instructions can be divided into these four most important
types: Declaration, Input, Output, and Assignment.

Various types can have various features - e.g., we cannot perform an addition
on two character variables.

---

### Types of instructions

**1. Declaration**

> **variable** = space allocated in RAM to hold some data

- **variable type**
  - character/string
  - numeric
  - date

- *example*    
`String name`

---

### Types of instructions

**2. Input**

- from keyboard or from file

- *example*    
`KeyboardRead name`

---

### Types of instructions

**3. Output**

- to a file or to the screen (*standard output*)

- *example*    
`ScreenWrite "Good morning, dear ", name`

---

### Types of instructions

**4. Assignment**

- *example*    
`var_name <- value`    
`var_name <- expression`

---

### How to translate a problem?

- Problem in natural language:    
*Compute sum of three numbers given by the user*

???

Usually, when we think about data processing, we have a good understanding
of the problem statement we want to solve. This is, however, formulated in 
words and abstractions that are completely not understandable for our machine.

We need to translate it to a code.

*building blocks*

<img src="figs/Khalife_2006_fig_flowchart1.jpg" style="width: 70%;">
]

???

And for that, we need to split it into simple steps that can be then coded
with our instructions. We can build a flowchart using these building blocks.

]

???

With this, it's much easier to write pseudo-code and then real code.

---

### Program execution

- _program state:_
  - variables in memory
  - values
  - next instruction

???

When we write down our program, it's static, but when we want the computer
to run it, it's becoming dynamic. Each code line changes something, so we need
to understand what's changing and where.

We need to think in terms of _program state_. Let's see how it works.

> **Example**

```
[x] Numeric a, b, c
[ ] KeyboardRead a
[ ] KeyboardRead b
[ ] KeyboardRead c
[ ] Numeric total
[ ] total <- a + b + c
[ ] ScreenWrite "Sum is equal to ", total
```
]

_(empty)_
]

---

### Program execution

- _program state:_
  - variables in memory
  - values
  - next instruction

> **Example**

```
[ ] Numeric a, b, c
[x] KeyboardRead a
[ ] KeyboardRead b
[ ] KeyboardRead c
[ ] Numeric total
[ ] total <- a + b + c
[ ] ScreenWrite "Sum is equal to ", total
```
]

`a`  |  `b`  |  `c` |
:----:|:-----:|:----:|
 `NA` | `NA`  | `NA` |

]

---
### Program execution

- _program state:_
  - variables in memory
  - values
  - next instruction

> **Example**

```
[ ] Numeric a, b, c
[ ] KeyboardRead a
[x] KeyboardRead b
[ ] KeyboardRead c
[ ] Numeric total
[ ] total <- a + b + c
[ ] ScreenWrite "Sum is equal to ", total
```
]

`a`  |  `b`  |  `c` |
:----:|:-----:|:----:|
 `19` | `NA`  | `NA` |

]

---
### Program execution

- _program state:_
  - variables in memory
  - values
  - next instruction

> **Example**

```
[ ] Numeric a, b, c
[ ] KeyboardRead a
[ ] KeyboardRead b
[x] KeyboardRead c
[ ] Numeric total
[ ] total <- a + b + c
[ ] ScreenWrite "Sum is equal to ", total
```
]

`a`  |  `b`  |  `c` |
:----:|:-----:|:----:|
 `19` | `2`  | `NA` |

]

---
### Program execution

- _program state:_
  - variables in memory
  - values
  - next instruction

> **Example**

```
[ ] Numeric a, b, c
[ ] KeyboardRead a
[ ] KeyboardRead b
[ ] KeyboardRead c
[x] Numeric total
[ ] total <- a + b + c
[ ] ScreenWrite "Sum is equal to ", total
```
]

`a`  |  `b`  |  `c` |
:----:|:-----:|:----:|
 `19` | `2`  | `126` |

]

---
### Program execution

- _program state:_
  - variables in memory
  - values
  - next instruction

> **Example**

```
[ ] Numeric a, b, c
[ ] KeyboardRead a
[ ] KeyboardRead b
[ ] KeyboardRead c
[ ] Numeric total
[x] total <- a + b + c
[ ] ScreenWrite "Sum is equal to ", total
```
]

`a`  |  `b`  |  `c` | `total` |
:----:|:-----:|:----:|:-------:|
 `19` | `2`  | `126` |  `NA`   |

]

---
### Program execution

- _program state:_
  - variables in memory
  - values
  - next instruction

> **Example**

```
[ ] Numeric a, b, c
[ ] KeyboardRead a
[ ] KeyboardRead b
[ ] KeyboardRead c
[ ] Numeric total
[ ] total <- a + b + c
[x] ScreenWrite "Sum is equal to ", total
```
]

`a`  |  `b`  |  `c` | `total` |
:----:|:-----:|:----:|:-------:|
 `19` | `2`  | `126` |  `147`  |

]

???

In each of these steps, there can be an error!

E.g., what will happen if we put a character instead of a number for one of
`a`, `b`, or `c`? It might be able to continue the program, but the number in
this position will be `NA`, so the sum of the values will also be `NA`.

---

### Successful program

Requirements:

<img src="figs/circle-check-solid.svg" style="width:20px;"> _enough memory (RAM)_

<img src="figs/circle-check-solid.svg" style="width:20px;"> _all variables present_

<img src="figs/circle-check-solid.svg" style="width:20px;"> _permission to read from/write to disk_

---
class: inverse, right, middle

### Exercise 1

> Write a pseudocode that can be used to solve the following problem:

> _We received a CSV file with pollution values measured once per hour during_
> _last 24 hours. We need to compute mean pollution value. However, we know_
> _that these pollution values give highly skewed distribution, so first, we_
> _need to log-transform the data._

_To make it easier, new variable type: `NumericVec` might hold an entire_
_vector of values._

---
class: inverse, right, middle

### Exercise 2

> Write down all possible causes to the following error:

> _The calculated mean pollution value shows `NaN` (not a number) when printed to the screen._