Commit stashed markdown files

Author: sa77

content/async-javascript.md

@@ -0,0 +1,89 @@
++++
+title = "Async JavaScript"
+slug = "async-javascript"
+layout = "page.html"
+date = 2021-05-08
+draft = true
+[taxonomies]
+tags = ["async", "javascript"]
++++
+
+There are 3 ways work with **asynchronous** code in JavaScript.
+- Callbacks
+- Promises (ES6; node v4.x, Chrome 32)
+- Async / Await (ES7; node v8.x, Chrome 55)
+
+Lets explore each of these for this example use case:
+```ts
+posts = [
+    { title: "Post 1", body: "This is post 1" },
+    { title: "Post 2", body: "This is post 2" }
+]
+```
+
+Promises are immutable, the handler cannot be changed. We are also guaranteed to receive a return value: either what we intended or an error.
+
+https://blog.logrocket.com/the-perfect-architecture-flow-for-your-next-node-js-project/
+
+- async - pushes the operation to run asynchronously
+- await - pause execution until myPromise is resolved
+
+## Callbacks
+---
+
+Callbacks are unintuitive and hard to debug.
+
+
+## Promises
+---
+
+A `Promise` is always fulfilled - either resolved or rejected.
+`Promise` is exclusively used in JS ecosystem: fetch API, axios, etc. So, it's a good idea to learn how to work with it properly.
+
+- A `Promise` enters a 'pending' state until it is resolved or rejected.
+- A promise can be created using `new Promise()` constructor
+
+```ts
+function createPost(post) {
+    // create new promise
+    new Promise((resolve, reject) => {
+        setTimeout(() => {
+            try {
+                posts.push(post)
+                resolve()
+            } catch {
+                reject("Error: Something went wrong")
+            }
+        })
+    })
+}
+createPost({ title: "Post 3", body: "This is post 3" })
+    .then(() => console.log("added"))
+    .catch(err => console.log(err))
+```
+
+- `Promise.all`
+
+Most of the time, we'll be dealing with returned promises from these external packages.
+
+```ts
+const promise1 = Promise.resolve('Hello world!')
+const promise2 = 10
+const promise3 = new Promise((resolve, reject) => {
+    setTimeout(resolve, 2000, 'Goodbye')
+})
+// need to resolve 2 promises; format to JSON -> use data
+const promise4 = fetch('https://jsonplaceholder.typicode.com/users').then(res => res.json())
+
+// values = an array of resolved promises
+Promise.all([promise1, promise2, promise3, promise4]).then(values => console.log(values))
+```
+
+## Async / Await
+---
+
+**Await** - waits for an asynchronous process to complete.
+
+NOTE: Async/Await do NOT invoke a seperate thread in the OS.
+<!-- Ref: <https://blog.stephencleary.com/2013/11/there-is-no-thread.html> -->
+

content/intro-to-rust-lang.md

@@ -0,0 +1,70 @@
++++
+title = "Intro to Rust Lang"
+slug = "intro-to-rust-lang"
+template = "page.html"
+draft = true
+[taxonomies]
+tags = []
++++
+
+**Rust** is a memory-safe, multi-paradigm statically-typed systems programming language that features:
+- zero-cost abstractions
+- ownership semantics
+- trait-based generics
+- pattern matching (functional)
+- syntactic macros
+
+## syntactic macros
+---
+**macros** are functions that work over syntax - macros take syntax as input and produces a new syntax as output. Instead of making function call, macros are expanded into source code. Macros enable metaprogramming in Rust.
+
+Syntax: `<macro_name>!`
+
+Use cases:
+- When you want to DRY the source code
+- To implement DSL
+- To implement *varadic interfaces*. A variadic interface takes an arbitrary number of arguments.
+
+Rust macros are expanded to ASTs rather than string pre-processing like in C, C++.
+
+(ref)[https://www.youtube.com/watch?v=VGk95NXaafs]
+
+```rust
+// declaration
+macro_rules! x_and_y {
+    // The arguments are prefixed by $ inside macros and type annotated by a 'designator'
+    // Ex: 'expr' is a designator - meaning this variable $e can be any expression - virtually anything in Rust - Rust is an expression based language
+    (x => $e:expr) => println!("X: {}", $e);
+    (y => $e:expr) => println!("Y: {}", $e);
+    () => {
+        println!("This is a macro.");
+    }
+}
+// invocation
+fn main() {
+    x_and_y!();
+    x_and_y!(x => 10);
+    x_and_y!(y => 20 + 20);
+}
+```
+
+Example: `println!("")`, `vec![]`
+
+```rust
+fn one_even(a: i32, b: i32) -> bool {
+    or!(even(a), even(b));
+}
+```
+
+`or!` is a macro that takes a input syntax and produces a new program as output syntax
+
+```rust
+fn one_even(a: i32, b: i32) -> bool {
+    if even(a) {
+        true
+    } else {
+        even(b)
+    }
+}
+```
+

content/wasm.md

@@ -0,0 +1,21 @@
++++
+title = "WebAssembly"
+slug = "webassembly"
+layout = "page.html"
+date = 2022-03-30
+draft = true
+[taxonomies]
+tags = ["wasm"]
++++
+
+# WebAssembly
+
+WebAssembly or `Wasm` is binary instruction format for a stack-based VM.
+**Wasm** is designed as a portable target for compilation of high-level
+languages like C/C++/Rust, enabling deployment on the web for client and server
+applications.
+
+- **Wasm** is basically a VM to prioritize portablity. `*.wasm` files are
+  ingested by a runtime (like the browser) that turns this file into actual
+  machine code of the actual machine the browser is running on and then execute
+  that code.