Multi AZ & read replica on AWS RDS


I've used aws rds to host database in two of the projects that I previously built. This is just a short summary of some of the rds features that I figured out along the way of using it.

### **Multi AZ**

Multi AZ means replicating a database instance synchronously in another availability zone (datacenter).
AWS basically creates an exact copy of our database in standby and in a situation where our main database go down, the rds will simply flip the cname of our db instance to the standby instance. 

### **Read Replica**

Setting up read replica allow us to have a read-only copy of our rds. It replicate asynchronously from the primary database. We can have up to 5 copies of read replicas and each replica will have its own dns endpoint.

#### **Use case**

Both of them make copies of the main database. So how to determine which one should be implemented?
Well then we have to look at our use case. 

Imagine an application with a very read-heavy workload. Without spawning another database instance to handle the load, our primary database probably wouldnt survive and performance could be affected. That's where read replicas come in handy. By setting up multiple read-only db instances, we can elastically scales out beyond the constraint of a single database instance. Now the read-heavy traffic can be spread around a few database instance instead of just a single db. So if performance or scaling is the main criteria, implementing read-replica is a good way to achieve it.

Its possible to promote a read-replica db to become the primary db should we want to. However by doing that, the replication will no longer work and we have to setup the replication again for that newly promoted primary database. We can also launch the read replicas in another AZ or even in another region.

There may be cases where performance may not matter too much to a point where setting up read replicas is pretty much pointless. But if ensuring the availability of the data is crucial and we cannot afford the downtime while restoring from backup, then turning on multi-az is sensible. 

With multi-az, in case of failure to the primary db, aws will automatically point the rds dns endpoint to the backup instance located in another AZ without any intervention from us. This in turn minimizes the potential downtime of our application. We can also force a failover to another AZ by rebooting the primary db instance.

Its important to note that the multi-az instance is just a standby instance. Its intended usage is mainly for disaster recovery and not performance so we cannot utilize it to reduce the load on the primary db.

Obviously there are many other ways to improve performance or setting up for disaster recovery, but these are the two built-in features which we can easily utilize when we use AWS RDS. 

For a startup that may not have that much traffic yet and can afford the downtime, its probably okay to skip these two and just implement a manual backup. It can be done later when the application needs to scale.

Of constructor, prototype & inheritance


*These are some of my notes from reading '**The Principles of Object-Oriented JavaScript**' book by [Nicholas C. Zakas](https://humanwhocodes.com/). The book is an amazing resource for anyone who is looking to have a deeper understanding about object-oriented concept in JavaScript.*

### **Constructor**

Constructor is just a function to create an object. In order to invoke a constructor function, we must use the *new* keyword. 

The way we write a constructor is the same as writing a normal function though the unofficial standard in creating a constructor is by making the name of the function start with a capital letter just so we can differentiate it to a normal function.

There's no need to return from a constructor function because the *new* keyword will automatically return the value.

> "*If we specify a return value and the return value type is object, the function will return that object instead of creating a new instance. But if the return value is a primitive type then return will be ignored and an instance will be created as per usual"*

```jsx
// an example of a constructor function
function Person(name) {
	this.name = name;
	this.sayName = function() {
		console.log(this.name)
	}
 }
```

We can use this constructor function to initialize a new object

```jsx
const person1 = new Person('lei')
person1.sayName() // lei
```

Doing this will automatically make person1 as an instance of the Person type and Person as the prototype of person1.

```jsx
person1 instanceof Person // true
Person.prototype.isPrototypeOf(person1)) // true
```

The advantage of using constructor to create object is that we can create multiple objects that can use the same properties and methods.

There's one caveat with this because everytime we instantiate an object using constructor, it will create a new copy of the method listed inside the constructor. It is inefficient to create new copy each time so in order to avoid redundancy we can make use of prototype.

### **Prototype**

Function has a property called prototype. We can add methods to a constructor function prototype instead of writing it inside the constructor itself. So instead of code example above, we can do it like this:

```jsx
function Person(name) {
	this.name = name;
 }

Person.prototype.sayName = function() {
	console.log(this.name)
}
```

This will make our code more efficient because all instances of Person will now refer the sayName method from the Person prototype instead of creating a copy of sayName method themselves.

```jsx
const person1 = new Person('lei')
const person2 = new Person('lil')

person1.sayName() // lei
person2.sayName() // lil
```

We can also replace the constructor prototype using object literal notation instead of changing it one by one. When we do this, we will overwrite the constructor property because constructor lives inside the prototype. So we need to specify the constructor property to ensure that the constructor property is pointed back to itself or to the correct value.

```jsx
Person.prototype = {
	constructor: Person

	sayName: function() {
		console.log(this.name)
	}

	sayHello: function() {
		console.log('hello ' this.name)
	}
}
```

The relationships between an instance and its constructor is connected via the constructor function prototype. When we create a new instance using constructor function, the constructor function prototype is assigned to the [[prototype]] property of that newly created instance. We saw this above when we use the isPrototypeOf method

All instance of a particular constructor refers to the same shared prototype so if we add a new method to that prototype, it will be available for all instance to use.

If we change constructor property inside the prototype, it will be reflected on all instance as well.

### **Inheritance**

Inheritance in JavaScript is based upon the concept of prototype. That is why we see inheritance in js being called as prototypal inheritance. Because that is how it works, an object inherits another object's prototype.

When we create an object using object literal notation, it will automatically inherits properties from Object.prototype because Object.prototype will be its default [[prototype]] value

```jsx
const obj = {
 name: "lei"
}
```

We can use Object.create() method to explicitly specify what should be the [[prototype]] value. The first argument that we pass into the method will be the [[prototype]] value in the new object.

```jsx
const obj = Object.create(firstArgument, {})
```

So if we would like to create an object that inherits from another object, we can do something like this: 

```jsx
const obj1 = {
	name: 'lily',
	sayName: function() {
		console.log(this.name)
	}
}

const obj2 = Object.create(obj1, {}
})

obj2.sayName() // lily
```

In this example, obj2 has access to *sayName* method because it inherits the method from obj1 after we created it using *Object.create()*. The property called *name* & its value is also inherited by *obj2* as we saw in the code above though we can overwrite it by passing a new value for it inside the second argument of *Object.create()*. This is basically how inheritance works in JavaScript.

When any property is accessed on an object, the JavaScript engine will first try to find the property on the instance itself, if it cannot found it, it will proceed to search on the [[prototype]] and so on until the [[prototype]] value returns null.

We can also create inheritance between object by referencing its prototype to another constructor function. for example:

```jsx
function Obj1(x, y) {
	this.length = x
	this.width = y
}

Obj1.prototype.getSize = function() {
	return this.length * this.width
}

function Obj2(x) {
	this.length = x
	this.width = x
}

// inherits prototype from Obj1
Obj2.prototype = new Obj1();

// reset its constructor property back to itself
Obj2.prototype.constructor = Obj2

let first = new Obj1(2, 2);
let second = new Obj2(4);

first.getSize() // 4
second.getSize() // 16
```

In the above example, *Obj2* have access to *Obj1* methods because we set *Obj2* prototype to refer to an instance of *Obj1*, therefore it inherits properties from *Obj1* prototype. We can reset the constructor property of *Obj2* prototype to point back to itself because the original value has been overwritten.

### **Class**

With ES6, we can just use class to create prototypal inheritance. Instead of using Object.create or referencing a prototype to another instance to create inheritance, we can simplify all that using class.

```jsx
class Obj1 {
	constructor(x, y) {
		this.length = x
		this.width = y
	}

	getSize() {
		return this.length * this.width
	}

}

// initiate an instance using the class. (same syntax as using constructor func)
const first = new Obj1(2,2);

// create inheritance via extends
class Obj2 extends Obj1 {
	constructor(x) {
		super(x, x)
	}
}

const second = new Obj2(4);

second.getSize() // 16

```

In the example above, any instance created via *Obj2* will be able to access methods inside *Obj1* because of the *extends* keyword. *Obj2* automatically inherits all method from Obj1 prototype.

s*uper()* method is called to invoke the *Obj1* constructor function. We need to pass argument based on what Obj1 constructor function requires. By invoking *super*, *Obj2* will inherit the length and width properties. 

Class simplifies everything but its still good to know about prototype & inheritance because those are the concept that make classes works.



Scope


Scope and some other things that I always forgot what is it about so I decided to write it down and hopefully it sticks in my brain.

## **Scope one-liner definition:**
Scope is a rule that determines where a variable can be found and how it can be used.
### Scope & Lexical Environment
Lexical environment plays a big part in determining a function scope and its outer environment.
Lexical environment basically means the place where the code physically sits. Its about where the code is written and what surrounds it.

Consider this:
```javascript
function a() {
    let num = 1;
    b()
}

function b() {
    console.log(num) // 0
}

let num = 0;
a()
```
What will happen when _b_ is invoked? It will log 0 as the value of _num_. This is because _b_ sits on the global scope. It does not have any other outer environment. So it goes straight to global to look for a variable that does not exist within its own scope. 

The outer environment of a function depends on where the functions sits lexically or in other word, where it is physically written.

Lets see an example:
```javascript
function a() {
    let name = 'lily';

    function b() {
        console.log(name) // lily
    }

    b()
}

let name = 'zahra';
a()
```
Here _b_ sits physically inside _a_. When _b_ try to log the variable _name_, it doesnt found it in its own scope so it will refer to its lexical outer environment which is _a_. There it will found the variable _name_ and use that instead. 


##### **Scope & Execution Context**
Another way to think about scope is by looking at which execution context created or initialized the function. In the code above, _b_ does not exist before the execution context for _a_ starts. In contrast, _a_ was created in the global execution context. The execution context determines where a function was created thus it automatically becomes that function's outer environment.


### Block Scope
Block scope only applies when a variable is declared using let or const. Whenever a variable is declared inside a pair of curly braces, it will create a new scope for that variable. 
```javascript
let num = 2;
if (true) {
    let num = 1;
    console.log(num) // 1
}
console.log(num) // 2
```
In the code above, there are two variable defined with the same name but both holds different values. This is possible with block scoping only if we use let or const. If we use var instead, the first variable will be overwritten:
```javascript
var num = 2;
if (true) {
    var num = 1;
    console.log(num) // 1
}
console.log(num) // 1
```


In essence, a variable can be on the global scope, function scope or the block scope. It is all determined by where it is created or where it physically sits. 

Using @ts-check in regular JavaScript project


Been diving deep into typescript recently so I figured I'd write some of the things that i find easy to play around with while exploring more about typescript. @ts-check is a good starting point.

## **What is @ts-check and why you should use it in your regular JavaScript files?**

If you're using vs code as your editor you can get the benefit of type checking & error reporting even though your project is not written in typescript. 

ts-check is a great feature we can take advantage of when working with regular JavaScript project because this tool will automatically analyze our files and help us catch mistakes during development. When we add ts-check to our files, typescript is activated on top of our JavaScript file and it will help look for errors and then notify us if there are issues within our code.

The easiest way to add ts-check to our code is by simply adding //@ts-check on the first line of our file.
```jsx
// @ts-check
```

Here's an example of how it works:
The code example below is not using ts-check and it is deliberately littered with errors.
```jsx
let number = 1

const change = () => {
    number = 'test'
    addNumber()
}

for (let i = 0; i < number; i++) {
    nunber += i
}

number.map(num => console.log(num))
```

There's a lot of obvious error in the code above but our code editor is not showing it to us. It may be easy to go line by line and spot these errors in this small code example but imagine if we're working within a large codebase and we're under pressure to deliver a task, its normal to overlook simple error like this. Lots of time will be wasted because we will only discover much of these errors during runtime.

Modify the same code above a little bit by adding @ts-check:
```jsx
// @ts-check
let number = 1

const change = () => {
    number = 'test' // Type 'string' is not assignable to type 'number'
    addNumber() // Cannot find name 'addNumber'.
}

for (let i = 0; i < number; i++) {
    nunber += i // Cannot find name 'nunber'. Did you mean 'number'?
}

number.map(num => console.log(num)) // Property 'map' does not exist on type 'number'.
```

By just adding @ts-check on the first line as shown above, our code editor will highlight every single line of code that contains an error without us having to run the code beforehand.

The good thing about this is that it will not just highlight which line is problematic. If we hover over the highlighted line, we'll get an explanation about the error so we can see what actually causes the problem.

### **The advantage of using @ts-check**:
* It help us check variety of errors such as normal typo, missing properties, invalid usage of method and many others.
* It saves us a lot of time from scratching our heads looking for errors in our code.
* It makes our code more robust by making sure we're not writing code that aren't making sense.
* We don't need to migrate our project to typescript to benefit from this.

Using ts-check is a good way to start if you're not currently using typescript but planning to use it in the future. Its a great little tool that we can use without having to change any settings.

Checkout this link for more info on how to integrate ts-check in your project:
[https://code.visualstudio.com/docs/nodejs/working-with-javascript#_type-checking-javascript](https://code.visualstudio.com/docs/nodejs/working-with-javascript#_type-checking-javascript)

Azrul Aziz

Links

Contact