Asynchronous Programming

[hon9g]

INDEX

• Async Patterns
  • Parallel vs. Async
  • Callbacks, one of fundamental unit of Asynchronous Programming
  • Thunks
  • Promises
  • Generators / Coroutines
  • Event Reactive (observables)
  • CSP (channel-oriented concurrency)

[hon9g]

Parallel vs. Async

sync vs. async

• sync 동기
  • 순차적으로 일을 끝냄.
• async 비동기
  • 해야할 일을 위임하고 기다림. (기다리는 동안 다음 순서에 있던 일이 먼저 실행될 수 있음)

    parallelism vs. non-parallelism

• parallelism express thread
• non-parallelism: 1 operation 1 thread at once
• parallelism: n operation at once
• parallelism is optimization

Single Thread

• The programming inside of javaScript runs a single thread
• looks like multi thread

Concurrency

[hon9g]

Callback

console.log(1)
setTimeout(() => console.log("callback"), 1000)
console.log(2)

/* expeted log
 * 1
 * 2
 * callback
*/

callback == continuation

• now: outside of callback function
• later: inside of callback function
  • later could be immediately after what i'm doing
  • gap could be 0 ms delay, waiting for some request, waiting for message from web worker, ... .

Callback Hell

• observation: too much indentations, nestings of callback function is callback hell

  setTimeout( () => {
  console.log(1);
  setTimeout ( () => {
  console.log(2);
  setTimeout ( () => {
    console.log(3);
  }, 1000);
  }, 1000);
  }, 1000);

• but also this is the Callback Hell

  
  const one = (f) => {
  console.log(1);
  setTimeout(f, 1000);
  };

const two = (f) => { console.log(2); setTimeout(f, 1000); };

const three = () => { console.log(3); };

one(two(three()));

- There are no observation of nesting or indentation.
- But, there are still fundamental nesting going on. 
- So, there is a Callback Hell.

## Callback Problems
#### 1. Inversion of Control
- Inversion of Control means there's a part of my program that i am in control of executing, and there's another portion of my code that I'm not in control of executing.
  - `_in control of executing:_ operations outside of callback function.`
  - `_not in control of executing:_ operations in callback function.`
- _Trust:_ 
  - not too early, 
  - not too late, 
  - not too many times, 
  - not too few times, 
  - no lost context, 
  - no swallowed errors, ... .

#### 2. Not Reasonable
#### 3. Non Fixes

## Solutions
- Async
- Promise

[hon9g]

Thunks

• Thunk:
  • a function with the values?
  • It is a container around the particular collection of state.
• The wrapper around a value is fundamental underpinning for what a promise is.

synchronous and asynchronous

const add = (a, b) => a+b;
const thunk = () => add(10, 20); // This is a synchronous thunk

thunk(); // 30

const addAsync = (a, b, callback) => setTimeout( () => callback(a+b) , 1000);
const thunk = (callback) => addAsync(10, 20, callback); // This is a asynchronous thunk

thunk(function(sum){
  console.log(sum); //30
});

Thunks and Closure

[hon9g]

Promise

Promise the Future value

• Promises are a codification of the idea that we need a placeholder to an eliminate time as the concern wrapped around a value.
• Promise from language called E, one of members of the TC39
  • In E, something like the promise is a future
  • the future is literally exchange by its value
  • you can perform the operations that would normally do against that value directly, transparently.
  • even though the value isn't physically there yet,
  • you can begin to compose it, perform operations on it.
• bring something like future that allows people to reason about values, ignorant of the timing.

Advantages of promise API

• time independent state
• manager, pattern for managing our callbacks in trustable fashion

Promise Trust

1. only resolved once
2. either success OR error
3. messages passed/kept
4. exceptions become errors
5. immutable once resolved

[hon9g]

Generators / Coroutines

[hon9g]

Event Reactive

(observables)