
# EBS - Elastic Block Store

An Amazon EBS volume is a durable, block-level storage device that you can attach to your instances. After you attach a
volume to an instance, you can use it as you would use a physical hard drive. EBS volumes are flexible. For
current-generation volumes attached to current-generation instance types, you can dynamically increase size, modify the
provisioned IOPS capacity, and change volume type on live production volumes.

You can use EBS volumes as primary storage for data that requires frequent updates, such as the system drive for an
instance or storage for a database application. You can also use them for throughput-intensive applications that perform
continuous disk scans. EBS volumes persist independently from the running life of an EC2 instance.

You can attach multiple EBS volumes to a single instance. The volume and instance must be in the same Availability Zone.
Depending on the volume and instance types, you can use Multi-Attach to mount a volume to multiple instances at the same
time.

![Elastic Block Store](ebs-volume.png)

### EBS Snapshots

Amazon EBS provides the ability to create snapshots (backups) of any EBS volume and write a copy of the data in the
volume to Amazon S3, where it is stored redundantly in multiple Availability Zones. The volume does not need to be
attached to a running instance in order to take a snapshot. As you continue to write data to a volume, you can
periodically create a snapshot of the volume to use as a baseline for new volumes. These snapshots can be used to create
multiple new EBS volumes or move volumes across Availability Zones. Snapshots of encrypted EBS volumes are automatically
encrypted.

When you create a new volume from a snapshot, it's an exact copy of the original volume at the time the snapshot was
taken. EBS volumes that are created from encrypted snapshots are automatically encrypted. By optionally specifying a
different Availability Zone, you can use this functionality to create a duplicate volume in that zone. The snapshots can
be shared with specific AWS accounts or made public. When you create snapshots, you incur charges in Amazon S3 based on
the volume's total size. For a successive snapshot of the volume, you are only charged for any additional data beyond
the volume's original size.

Snapshots are incremental backups, meaning that only the blocks on the volume that have changed after your most recent
snapshot are saved. If you have a volume with 100 GiB of data, but only 5 GiB of data have changed since your last
snapshot, only the 5 GiB of modified data is written to Amazon S3. Even though snapshots are saved incrementally, the
snapshot deletion process is designed so that you need to retain only the most recent snapshot.

![EBS Snapshot](ebs-snapshot.png)

# EC2 Instace Store

EBS volumes are network drives with good but limited performance, if you need a high-performance hardware disk, use EC2
Instance Store.

An instance store provides temporary block-level storage for your instance. This storage is located on disks that are
physically attached to the host computer. Instance store is ideal for temporary storage of information that changes
frequently, such as buffers, caches, scratch data, and other temporary content. It can also be used to store temporary
data that you replicate across a fleet of instances, such as a load-balanced pool of web servers.

An instance store consists of one or more instance store volumes exposed as block devices. The size of an instance store
as well as the number of devices available varies by instance type.

![EC2 Instace Store](ec2-instance-store.png)

# EFS - Elastic File System

Amazon EFS provides scalable file storage for use with Amazon EC2. You can use an EFS file system as a common data
source for workloads and applications running on multiple instances.

With Amazon EFS, storage capacity is elastic. It grows and shrinks automatically as you add and remove files. Your
applications can have the storage they need and when they need it.

![EFS](efs.png)

# FSx

Amazon FSx makes it easy and cost effective to launch, run, and scale feature-rich, high-performance file systems in the
cloud. It supports a wide range of workloads with its reliability, security, scalability, and broad set of capabilities.
Amazon FSx is built on the latest AWS compute, networking, and disk technologies to provide high performance and lower
TCO. And as a fully managed service, it handles hardware provisioning, patching, and backups -- freeing you up to focus
on your applications, your end users, and your business.

You can choose between four widely-used file systems: NetApp ONTAP, OpenZFS, Windows File Server, and Lustre.

# AMI - Amazon Machine Images

An Amazon Machine Image (AMI) is a supported and maintained image provided by AWS that provides the information required
to launch an instance. You must specify an AMI when you launch an instance. You can launch multiple instances from a
single AMI when you require multiple instances with the same configuration. You can use different AMIs to launch
instances when you require instances with different configurations.

An AMI includes the following:

-   One or more Amazon Elastic Block Store (Amazon EBS) snapshots, or, for instance-store-backed AMIs, a template for
    the root volume of the instance (for example, an operating system, an application server, and applications).
-   Launch permissions that control which AWS accounts can use the AMI to launch instances.
-   A block device mapping that specifies the volumes to attach to the instance when it's launched.

You can launch an instance from an existing AMI, customize the instance (for example, install software on the instance),
and then save this updated configuration as a custom AMI. Instances launched from this new custom AMI include the
customizations that you made when you created the AMI.


EC2 Instance Storage


Amazon EC2 is one of the most used and most basic services on AWS that lets users launch and manage server instances, at
any time and for as long as they need, with over 500 instances and choice of the latest processor, storage, networking,
operating system, and purchase model to help you best match the needs of your workload.

Using Amazon EC2 eliminates your need to invest in hardware up front, so you can develop and deploy applications faster.

# EC2 Mainly Capibilities

-   Renting Virtual Machines (EC2)
-   Storing data on virtual drives (EBS)
-   Distributing load across machines (ELB)
-   Scaling the services using an auto-scaling group (ASG)

# EC2 User Data

It is possible to bootstrap our instances using an **EC2 User Data** script, meaning we can launch commands when the
instance first starts. These commands are used to automate boot tasks such as installing updates, installing softwares,
downloading common files from the internet and doing anything you can think of.

# EC2 Instance Types

### General Purpose

-   Great for a diversity of workloads such as web servers or code repositories
-   Balance between compute, memory and networking

### Compute Optimized

-   Great for compute-intensive tasks that require high performance processors:
    -   Batch processing workloads
    -   Media Transcoding
    -   High performance web servers
    -   High performance computing (HPC)
    -   Scientific modeling & machine learning
    -   Dedicated gaming servers

### Memory Optmized

-   Fast performance for workloads that process large data sets in memory
-   Use cases:
    -   High performance, relational/non-relational databases
    -   Distributed web scale cache stores
    -   In-memory databases optimized for BI (business intelligence)
    -   Applications performing real-time processing of big unstructured data

### Storage Optimized

-   Great for storage-intensive tasks that require high, sequential read and write acces to large data sets on local
    storage
-   Use cases:
    -   High frequency online transaction processing (OLTP) systems
    -   Relational & NoSQL databases
    -   Cache for in-memory databases (for example Redis)
    -   Data warehousing applications
    -   Distributed files systems

# Security Groups

**Security Groups** are the fundamental of network security in AWS. They control how traffic is allowed into or out of
EC2 Instaces. Security Groups only contains **_allow_** rules and they can reference by IP or by security group

Security Groups acts like a **_firewall_** on EC2 instances, they regulate access to Ports, IP ranges and control
inbound and outbound network.

They can be attached to multiple instances at the same time, but they are locked down to a region / VPC combination.
They live outside the EC2 instance, if traffic is blocked the EC2 instance won't see it. All inbound traffic is blocked
by default and all outbound traffic is authorised by default.

![Security Groups](security-groups.png)

# EC2 Instace Roles

EC2 Instance Role provides the Instance access to a set of IAM Credentials and – if the associated IAM Policies permit –
access to AWS services.

# Summary

-   **EC2 Instance:** AMI (OS) + Instance Size (CPU + RAM) + Storage + Security Groups + EC2 User Data
-   **Security Groups:** Firewall attatched to the EC2 instance
-   **EC2 User Data:** Script launched at the first start of an instance
-   **EC2 Instance Rolse:** Instance access to a set of IAM Credentials and AWS services
-   **Purchasing Options:** On-Demand, Spot, Reserved (Standard + Convertible + Scheduled), Dedicated Host, Dedicated
    Instance


EC2 - Elastic Compute Cloud


With AWS Identity and Access Management (IAM), you can specify who or what can access services and resources in AWS,
centrally manage fine-grained permissions, and analyze access to refine permissions across AWS.

### What are IAM Users?

This is any identity (humans or an application) that requires long term access to AWS resources. These entities make
requests to IAM to get authenticated before any interaction with AWS resources is allowed to happen.

### IAM Groups

IAM users can be placed in an IAM groups. IAM groups makes it easier to organize a large number of users and apply
permissions on a group level instead of an individual level. Groups can only contain users, but not other groups. Users
don't have to belong to a group, and a user can belong to multiple groups.

![IAM Groups](iam-groups.png)

### IAM: Permissions

**Users or Groups** can be assigned JSON documents called policies. These policies define the **permissions** of the
users.

You can think of these policies as how AWS authenticates a user or group to ensure that they are only allowed to access
and control permissions that were granted to them.

In AWS you apply the **least privilege principle**, which means you don't give more permissions than a user needs.

![IAM Permissions](iam-permissions.png)

### IAM: Password Policy

-   Strong passwords - higher security for your account
-   In AWS, you can setup a password policy:
    -   Set a minimun password length
    -   Require specific character types:
        -   Uppercase letters
        -   Lowercase letters
        -   Numbers
        -   Non-alphanumeric characters
    -   Allow all IAM users to change their own passwords
    -   Require users to change their password after some time (password expiration)
    -   Prevent password re-use
-   Multi Factor Authentication - MFA
    -   User is granted access only after successfully presenting two or more pieces of evidence to an authentication
        mechanism
    -   If a password is stolen or hacket, the account is not compromised

### IAM Roles for Services

Some AWS service will need to aperform actions on your behaulf. To do so, we will assign **permissions** to AWS services
with **IAM Roles**

An IAM role is similar to an IAM user, in that it is an AWS identity with permission policies that determine what the
identity can and cannot do in AWS. However, instead of being uniquely associated with one person, a role is intended to
be assumable by anyone who needs it.

-   Common roles:
    -   EC2 Instace Roles
    -   Lambda Function Roles
    -   Roles for CloudFormation

![IAM Roles](iam-roles.png)

### IAM Security Tools

-   IAM Credentials Report (account-level)
    -   A report that lists all your account's users and the status of their various credentials
-   IAM Access Advisor (user-level)
    -   Access advisor shows the service permissions granted to a user and when those services were last accessed
    -   You can use this information to revise your policies

### IAM Guidelines & Best Practices

-   Don't use the root account except for AWS account setup
-   One physical user = One AWS user
-   **Assign users to groups** and assign permissions to groups
-   Create a **strong password policy**
-   Use and enforce the use of **Multi Factor Authentication (MFA)**
-   Create and use **Roles** for giving permissions to AWS services
-   Use Access Keys for Programmatic Access (CLI / SDK)
-   Audit permissions of your account with the IAM Credentials Report
-   **Never share IAM users & Access Keys**


IAM - Identity and Access Management


# How Websites Works

We have a server hosted somewhere, and we as a web browser want to get access to that server to visualize a website.
What we are going to do as a client is use a network, a network between our selfs and the server. The client will find
the network and will use it to route the data into the server, then the server will reply to us and we will get the
response and view the website.

For the clients to find the server and the server to find the client you need to have IP address. The client has an IP
address and the server has an IP address, that way you can send requests to whatever server you want and the server can
know how to find you back.

![How Websites Works](how-website-works.png)

### What is a server composed of?

-   **Compute**: CPU

    -   Responsible for doing computations and calculations.

-   **Memory**: RAM

    -   Very fast memory which allow us to store information and retrieve it quickly.

-   **Storage**: Data

    -   Long term storage data, for example files.

-   **Database**

    -   Store data in a structured way. Easy to seach and query.

-   **Network**: Routers, switch, DNS server

### IT Terminology

-   Network: cables, routers and servers connected with each other

-   Router: A networking device that forwards data packets between computer networks. They know where to send your
    packets on the internet.

-   Switch: Takes a packet and send it to the correct server/client on your network.

![Switch vs Router](switch-vs-router.png)

### Traditional IT

Traditional IT infrastructure is made up of physical hardware, like a desktop computer, which is connected to a network
via a remote server. The server is installed on the premises and gives anyone who has access to the hardware a view into
stored data and applications. When the time comes to scale up, businesses with this IT model typically need to purchase
additional hardware and upgrades which can be quite costly. Often, it is the IT department that is responsible for
installing and maintaining this hardware.

![Traditional IT](traditional-it.png)

### Problems with traditional IT approach

-   Pay for the rent for the data center

-   Pay for power supply, cooling, maintenance

-   Adding and replacing hardware takes time

-   Scaling is limited

-   Hire 24/7 team to monitor the infrastructure

-   How to deal with disasters? (earthquake, power shutdown, fire)

# What is Cloud Computing

Cloud computing is the on-demand delivery of compute power, database storage, applications and other IT resources.
Though a cloud services platform you get a **pay-as-you-go** pricing, which means you're only going to pay for what you
requested, when you requested it and as you use it, when you're done using it, you're not going to pay it anymore. You
can provision exactly the right type and size of computing resources you need. You can access as many recources as you
need. almost instalty, you don't need to order it in advance. Simple way to access servers, storage, databases and a set
of application services.

![Cloud Computing](cloud-computing.png)

### The Deployment Models of the Cloud

-   Pivate Cloud:

    -   Cloud services used by a single organization, not exposed to the public
    -   Complete control
    -   Security for sensitive applications
    -   Meet specific business needs
    -   Example: Rackspace

-   Public Cloud:

    -   Cloud resources owned and operated by a third-party cloud service provider delivered over the internet
    -   Example: Azure, Google Cloud, AWS

-   Hybrid Cloud:
    -   Keep some servers on premises and extend some capabilities to the Cloud
    -   Control over sensitive assets in your private infrastructure
    -   Flexibility and cost-effectiveness of the public cloud
    -   Ecample: On-premises and AWS

### Characteristics of Cloud Computing

-   On-demand self service:

    -   Users can provision resources and use them without human interaction from the service provider

-   Broad network access:

    -   Resources available over the network, and can be accessed by diverse client platforms

-   Multi-tenancy and resource pooling:

    -   Multiple customers can share the same infrastructure and applications with security and privacy
    -   Multiple customers are serviced from the same physical resources

-   Rapid elasticity and scalability:

    -   Automatically and quickly acquire and dispose resources when needed
    -   Quickly and easily scale based on demand

-   Measured service:
    -   Usage is measured, users pay correctly for what they have used

### Advantages of Cloud Computing

-   Trade capital expense (CAPEX) for operational expense (OPEX)

    -   Pay On-Demand: don't own hardware
    -   Reduced Total Cost of Ownership (TCO) & Operational Expense (OPEX)

-   Benefit from massive economies of scale

    -   Prices are reduced as AWS is more efficient due to large scale

-   Stop guessing capacity

    -   Scale based on actual measured usage

-   Increase speed and agility

-   Stop spending money running and maintaining data centers

-   Go global in minutes: leverage the AWS global infrastructure

### Problems solved by the cloud

-   Flexibility: change resource types when needed

-   Cost-Effectiveness: pay as you go, for what you use

-   Scalability: accommodate larger loads by making hardware stronger or adding additional nodes

-   Elasticity: ability to scale out and scale in when needed

-   High-availability and fault-tolerance: build across data centers

-   Agility: rapidly develop, test and launch software applications

# Type of Cloud Computing

-   Infrastructure as a Service (IaaS)

    -   Provide building blocks for cloud IT
    -   Provides networking, computers, data storage space
    -   Highest level of flexibility
    -   Easy parallel with traditional on-premises IT
    -   Example: Amazon EC2 (on AWS)

-   Platform as a Service (PaaS)

    -   Removes the need for your organization to manage the underlying infrastrcture
    -   Focus on the deployment and management of your applications
    -   Example: Elastic Beanstalk (on AWS)

-   Software as a Service (SaaS)
    -   Completed product that is run and managed by the service provider
    -   Example: Google Apps (Gmail), Dropbox, Zoom

![Type of Cloud Computing](type-of-cloud-computing.png)


What is Cloud Computing?


# Call Stack

The **Call Stack** is a place used by the JavaScript Engine to run and keep track of what is happening line by line in our code. A region in memory which operates in first in last out mode.

When you execute a script, the JavaScript engine creates a global execution context and pushes it on top of the call stack.

If a function calls another function, the JavaScript engine creates a new function execution context for the function being called and pushes it on top of the call stack.

When the current function completes, the JavaScript engine pops it off the call stack and resumes the execution where it left off.

The script will stop when the call stack is empty.

```js
function subtractTwo(num) {
    return num - 2
}

function calculate() {
    const sumTotal = 4 + 5;
    return subtractTwo(sumTotal)
}

calculate()
```

When the JavaScript engine executes this script, it places the global execution context (denoted by main() function) on the call stack.

```js
main()
//Call Stack
```

The global execution context enters the creation phase and moves to the execution phase.

The JavaScript engine executes the call to **calculate** function, and creates a function execution context and pushes it on top of the call stack. 

```js
calculate()
main()
//Call Stack
```

Within the function we can see that another function is called, **subtractTwo**. JavaScript engine creates another function execution context for the **subtractTwo** function and places it on the top of the call stack.

```js
subtactTwo()
calculate()
main()
//Call Stack
```

Once subtractTwo is done running, its removed from the call stack.

```js
calculate()
main()
//Call Stack
```

At this point, the **calculate** function is on the top of the call stack, the JavaScript engine executes and pops it off the call stack.

```js
main()
//Call Stack
```

Now, the call stack is empty so the script stops executing.

```js
//Call Stack
```

# Memory Heap

 The **Memory Heap** is a place to store and write information, variables, objects and data of our app in an unordered fashion. It allows us to use variables to point to different storage areas.

```js
const number = 10 //allocate memory for number
const string = 'text' //allocate memory for string
const human = { // allocate memory for an object and it's values
    firstName: Matheus,
    lastName: Silva
}
```

In the example above, a place in memory is allocated to store the variables number and string and for the human objext, and each one of them points to its respective values.

## Memory life cycle

In JavaScript, when we create variables, functions, or anything you can think of, the JS engine allocates memory for this and releases it once it's not needed anymore.

Every time we assign a variable or create a function, the memory for that always goes through the same following stages:

- Allocate memory

JavaScript takes care of this for us: It allocates the memory that we will need for the object we created.

- Use memory

Using memory is something we do explicitly in our code: Reading and writing to memory is nothing else than reading or writing from or to a variable.

- Release memory

This step is handled as well by the JavaScript engine. Once the allocated memory is released, it can be used for a new purpose.

![Memory Life Cycle](memory-life-cycle.png)

JavaScript Call Stack and Memory Heap


A JavaScript engine is **a software component that executes JavaScript code**.

# Introduction

JavaScript is not understandable by computer, only browsers understands JavaScript. We need a program to convert our
JavaScript code into computer-understandable language. A JavaScript engine is a computer program that executes
JavaScript code and converts it into language a computer understands.

All modern browsers come with their own version of the JavaScript Engine but the most popular one is Google’s V8 Engine.
Google’s V8 engine powers Google Chrome browsers, as well as, Node.js. Node.js is a JavaScript runtime that is used to
build server-side applications outside of the browser.

![JavaScript Engine Diagram](javascript-engine-diagram.png)

# The Parser

The first thing that happens inside the engine, is that our code is parsed by a parser, which basically reads our code
line by line, and checks if the syntax of the code that we gave it, is correct. If everything is correct, the parser
produces a data structure known as the Abstract Syntax Tree, which is then translated into code computers understands.

# Interpreters and Compilers

Runs through the source code and executes it line by line. Code is read and executed all at the same time.

Works ahead of time to translate the code just written and compiles down to a language our machine can understand.

Have you heard of **_Babel_** or **_TypeScript_**? They are heavily used in the Javascript ecosystem and you should now
have a good idea of what they are:

-   **_Babel_** is a Javascript compiler that takes your modern JS code and returns browser compatible JS (older JS
    code).
-   **_Typescript_** is a superset of Javascript that compiles down to Javascript.

Both of these do exactly what compilers do: Take one language and convert into a different one!

# IS JAVASCRIPT AN INTERPRETED LANGUAGE?

JavaScript used to be a purely interpreted language but the problem with interpreted languages is that they are much,
much slower than compiled languages. This used to be okay for JavaScript, but now with modern JavaScript and
fully-fledged web applications that we built and use today, low performance is no longer acceptable.

Now many people still think that JavaScript is interpreted language, but that’s not really true anymore. So instead of
simple interpretation, Modern JavaScript engine now uses a mix between compilation and interpretation which is called
**Just-in-time(JIT) compilation**.

This approach basically compiles the entire code into machine code at once and then executes it right away. The
execution happens immediately after the compilation. And this is perfect for JavaScript as it’s really a lot faster than
just execution code line by line.

![Interpreter and Compiler](interpreter-compiler.png)

![JIT Compiler](jit-compiler.png)

In the next chapter, we will be leraning about JavaScript Call Stack and Memory Heap.


JavaScript Under The Hood


To fully understand why var is bad, you first need to understand three core concepts of Javascript: Declaration,
Hoisting, and Scope.

## Declaration vs Initialization

Javascript **var** allows you to declare a variable before you need to use it.

```js
var myVariable; // This is 'undefined' here
```

This assigns a default value of **_undefined_** to the declared variable. When you are ready to use it, you can
**initialize** the variable with a value.

```js
myVariable = 'a value';
```

Until the variable is initialized it will return the special type **undefined** if it is used.

## Variable Scope

Javascript contains three levels of scope – **_Global, Functional, and Block_**. Global variables are declared outside
of any function and live at the root level of the entire running application. They can easily be accessed by outside
manipulation, so they should never be used!

A variable is Function scoped if it is usable anywhere inside a defined function, but can’t be accessed from outside
that function. This includes inside any child functions and blocks of code (defined by **{}**).

By contrast, a Block Scoped variable is only usable inside the **{}** that is defined within. Even child blocks and
functions.

**var** is either Global Scope or Function Scope.

## Hoisting

Combining the other two concepts, you get hoisting. A **var** declared anywhere in a function will be automatically
included at the top level of that function and assigned ‘undefined’. For instance:

```js
function hello(assign) {
    console.log(message); //prints undefined
    if (assign) {
        var message = 'Hello there!';
        console.log(message); // prints "Hello there!"
    }
}
```

Notice that you can print out the contents of message even though it may have never been initialized. This is because
Javascript actually rewrites that code into:

```js
function hello(assign) {
    var message = undefined;
    console.log(message); //prints undefined
    if (assign) {
        message = 'Hello there!';
        console.log(message); // prints "Hello there!"
    }
}
```

## What is let?

So, how is **let** different from **var**? A variable declared with **let** will be automatically Block scope, and it
will not be Hoisted. So, from our example above:

```js
function hello(assign) {
    console.log(message); // Reference Error: message is not defined
    if (assign) {
        let message = 'Hello there!';
        console.log(message); // prints "Hello there!"
    }
}
```

If you try to use a variable declared with **let** either before it is initialized or outside of its scope, you will get
a **ReferenceError**.

## What is const?

When you use **let** you can reassign the variable to anything you want at any time. If you want the variable to be
constant and unchangeable, use **const**. There is no other difference between **let** and **const**.

If you try to change a **const** declared variable, you will get a **TypeError** instead of a **ReferenceError**.

# Conclusion

**let** and **const** introduce block scope that allows us to write clean and less error-prone code. You don’t need to
think twice when declaring variables inside blocks. It is easier to work with block scope than with function scope. The
var usage has been being discouraged.

Please, keep in mind that you should use a transpiler tool, like Babel, to transpile your code from ES6 to ES5, to make
sure it will run in any browser. Not all browsers support the complete ES6 specification yet.


The var keyword in JavaScript


Diferent than primitive types, non-primitive types are **_mutable_** and refers to objects. Non-primitive types contains
multiple values or complex data.

# Objects

Objects are used to store various keyed collections and more complex entities. An object is an unordered collection of
key-value pairs. Each key-value pair is called a property.

The key of a property can be a string. And the value of a property can be any value, e.g., a **string**, a **number**, an **array**, and even a **function**.

JavaScript provides you with many ways to create an object. The most commonly used one is to use the object literal notation.

The following example creates an empty object using the object literal notation:

```js
let empty = {};
```

To create an object with properties, you use the key:value within the curly braces. For example, the following creates a new person object:

```js
let person = {
    firstName: 'Matheus',
    lastName: 'Silva'
};
```

# Accessing properties

To access the firstName property of the person object, you use the following expression:

```js
person.firstName
```

You can also access the value of an object’s property via the array-like notation

```js
person['firstName']
```

# Modifying the value of a property

```js
let person = {
    firstName: 'Matheus',
    lastName: 'Silva'
};

person.firstName = 'Matt';

console.log(person);
```

Output:

```js
{ firstName: 'Jane', lastName: 'Doe' }
```

# Adding and deleting properties

In JavaScript, you can add a property to an object after object creation.

```js
person.age = 29;
```

To delete te property, you can use the **delete** keyword

```js
delete person.age;
```

# Summarry

* An object is a collection of key-value pairs.
* Use the dot notation (.) or array-like notation ([]) to access a property of an object.
* The delete operator removes a property from an object.

JavaScript Non-Primitive Types


Data Types specify what kind of data can be stored and manipulated within a program. A value in JavaScript is always of
a certain type. For example, a string, a boolean or a number.

# Primitive Types

In JavaScript, a primitive type is a data that is not an **object** and has no **methods**. **All primitives are ***immutable***, they cannot be altered**. Variables can be reassigned a new value, but the existing value can not
be changed in the ways that objects, arrays, and function can. There are 7 primitive data types: string, number, bigint,
boolean, undefined, null and symbol.

## String

```js
const str = "Single quotes string";
const str2 = 'Double quotes string';
const phrase = `Backticks string ${str} ${str2}`
```

The **string** data type is used to represent a sequence of characters. strings are useful for holding data that can be represented in text form.

They can be represented with single quotes, double quotes and backticks. There is no difference between single and double quotes.

Backticks are “extended functionality” quotes. They allow us to embed variables and expressions into a string by wrapping them in ${…}, for example:

```js
const firstName = "Matheus";
const lastName = "Silva";

console.log(`Helo, my name is ${firstName} ${lastName}`)

// Helo, my name is Matheus Silva
```

## Numbers

```js
const a = 100;
const b = 55.5;
```

The **number** data type is used to represent positive or negative numbers, with or without decimal place.

There are many operations for numbers, e.g. multiplication **'*'**, division **'/'**, addition **'+'**, subtraction **'-'**, and so on.

Besides regular numbers, there are so-called “special numeric values” which also belong to this data type: Infinity, -Infinity and NaN.

```js
const infinity = 1 / 0; // Infinity
const negInfinity = -1 / 0; // -Infinity
const notANumber = 'Hello' / 2; // NaN
```

## BigInt

The **BigInt** represents integers of arbitrary length.

In JavaScript, the “number” type cannot represent integer values larger than ***(253-1)*** (that’s ***9007199254740991***), or less than ***-(253-1)*** for negatives. It’s a technical limitation caused by their internal representation.

A **BigInt** value is created by appending n to the end of an integer:

```js
const bigInt = 1234567890123456789012345678901234567890n;
```

## Boolean

The **boolean** data type has only two values: ***true*** or ***false***.

This type is commonly used to store yes/no values: ***true*** means “yes, correct”, and ***false*** means “no, incorrect”.

```js
const isReading = true;   // yes, I'm reading
const isSleeping = false; // no, I'm not sleeping
```

Boolean values also come as a result of comparisons.

```js
const a = 2, b = 5, c = 10;
 
console.log(b > a) // true
console.log(b > c) // false
```

## Undefined

The **undefined** type can only have one value, which is a special value ***undefined***. One example is when a variable is declared but it has not been assigned a value yet.

```js
const a;
 
console.log(a) // undefined
```

## Null

The **null** type is also a special value, which can only be ***null***. A **null** value means that there is no value. It is not equivalent to an empty string ("") or 0, it is simply nothing.

```js
let name = null;
```

## Symbols

The **symbol** type is used to create unique identifiers for objects. We will get deeper into symbols in the **object** section.

# Summary

There are 8 basic data types in JavaScript.

* ***number*** for numbers of any kind: integer or floating-point, integers are limited by ±(253-1).
* ***bigint*** is for integer numbers of arbitrary length.
* ***string*** for strings. A string may have zero or more characters, there’s no separate single-character type.
* ***boolean*** for true/false.
* ***null*** for unknown values – a standalone type that has a single value null.
* ***undefined*** for unassigned values – a standalone type that has a single value undefined.
* ***symbol*** for unique identifiers.
* ***object*** for more complex data structures.

In the next chapter, we will be talking about Objects, also referred as [**Non-primitive or Reference Data Type**](https://my-blog-r6sn4orp9-heuzin.vercel.app/posts/non-primitive-types).

Understanding Data Types in JavaScript


JavaScript is a dynamic computer programming language, used both on the client-side and server-side that allows you to make web pages interactive. 

it's **the** most important programming language you need to know as a web developer. Over 97% of websites use JavaScript.

# How JavaScript Works

JavaScript is often used with HTML and CSS. While HTML and CSS are languages that give structure and style to web pages, JavaScript turns static web pages into interactive web pages by dynamically updating content, validating form data, controlling multimedia, and almost everything else on the web pages, allowing you to implement complex features.

# HTML, CSS and JavaScript, What's the difference?

![Difference between HTML, CSS and JavaScript](html_css_javascript_infographic.png)

# JavaScript overview

To define a variable, you use the ***const*** keyword. For example:

```js
const x = 10;
const y = 20;
```

ES6 added a new way to declare a variable with the ***let*** keyword:

```js
let x = 10;
let y = 20;
```

There's also another way to declare variables, which is with ***var*** keyword, but it's not a recomended to use it in JavaScript. You can learn more about declaring variables, good practices, different use cases, downsides and benefits [here](https://my-blog-blond-pi.vercel.app/posts/javascript-datastructure).

To declare a function, you use the ***function*** keyword:

```js
function add(a, b) {
  return a + b
}
```

The function above calculates the sum of two arguments.

To call the **add()** function, you use the following syntax:

```js
const result = add(x, y);
```

To log the result into the console window of the web browser, you use the **console.log()**:

```js
console.log(result);

// 30
```

You should see "**30**" print out in the console window.

[Click here](https://my-blog-blond-pi.vercel.app/) for a more in depth overview on JavaScript syntax and structures.

# Why use JavaScript

- JavaScript is the only programming language native to the web browser, meaning, it is the only client-side language available
- JavaScript is the most popular language, it's the standard programming language for web browsers and anybody who's into web development needs to use it
- There’s a low threshold to get started, there is no need to set up any kind of development, it comes installed on every modern web browsers
- Can load content into the document if and when the user needs it, without reloading the entire page
- Tests for what is possible in your browser and reacts accordingly

![JavaScript featues overview](features-of-javascript.png)

Before writing JavaScript it's important to know how it works under the hood. There are two important pieces to learn: How the web browser works, and the Document Object Model(DOM).
Learn more about it [here](https://www.javascript.com/).

All Posts