Forem: ayeolakenny

Why Rest api's are Good and Graphql api's Better

ayeolakenny — Sat, 15 May 2021 09:25:50 +0000

GraphQL was internally developed by Facebook in 2012 and was later open sourced in 2015. The idea came up when facebook needed to rebuild its mobile native application, Facebook needed a data-fetching API powerful enough to describe all of Facebook yet simple enough to be easy to learn by their developers, now graphql powers tech giants like Netflix, Twitter, Shopify etc.

Now wondering what it is about graphql that outweighs rest, well lets get on with it.

Data Fetching

Data fetching is one of the obvious reasons we use api's, graphql makes data fetching easier by only exposing one endpoint to access data from the server, unlike rest where we have to make multiple requests to multiple endpoints.

Network Requsts

As said earlier, Graphql exposes only one endpoint which reduces trips and network requests to the server to fetch data, while Rest exposes multiple endpoints and increases trips and network requests to the server.
As you can see in the image above, to grab a users profile, users posts and users followers with graphql we only make a request to the server while we make 3 requests to the server using rest apis to grab all the data we need.

Over/Under Fetching

Graphql is a declarative data fetching specification and query language. we only fetch what we need from the server by constructing our query to only include what we need.
Rest apis gives you more or less data than is needed for the client at a point. This makes the server spit unecessary data that would not get used by the client, therefore making uneccessary requests.

Api Versioning

When the arise for addition of new features come in, you can easily add additional fields, queries, mutations etc to the server and other parts would not be affected, also it is easier to remove old features and make them backward compatible without any breaking changes.

Should I Abandon REST for GraphQL?

Graphql can be a life saver when when building scalable applications, but you do not need to rewrite or migrate applications that have been designed to use REST api. Rather you should plan to use GraphQL for future applications.

Conclusion

REST for sure is not going anywhere soon. For most small applications, there would not be significant increase in performance over REST, the real magic of GraphQL plays in as applications scale and the application becomes bigger.

Create a Graphql server with Nodejs, Typescript and Graphql

ayeolakenny — Mon, 11 Jan 2021 20:06:26 +0000

According to their docs graphql.org, GraphQL is a query language for APIs and a runtime for fulfilling those queries with your existing data.

Before you start with this blog post I'll recommend you know at least a good chunk on of typescript, graphql and nodejs, so lets dive in and get going :).

Firstly we would have to setup our project with node and typescript, run npm init -y to setup a package.json file.

We are going to need some packages for this project, simply install them by running the following command.
yarn add express express-graphql graphql
or
npm install express express-graphql graphql

After installing the main packages, we would also need some dev dependencies which would only be useful during development.
yarn add @types/express @types/express-graphql @types/graphql @types/node typescript nodemon -D

If you noticed, we installed the types for all our main packages as dev dependencies, typescript requires this to validate the types when working with the main packages or else it throws errors, keep this in mind.

After installing all the packages we would need to create the server, we would need some kind of configuration to tell typescript what's going on in our project and how to deal with it, luckily we can get this configuration through a simple npx command,
npx tsconfig.json
Then choose the framework you are working with, in our case it is node

? Pick the framework you're using (Use arrow keys)
> react
  react-native
  node

And zoom, you get a tsconfig.json file in the root of your project.

Go into the tsconfig.json file and check for your outDir and set it to "./build" and rootDir to "./".

"outDir: "./build",
"rootDir: "./",

Note: the outDir tells typescript where to save your compiled typescript code to, and the rootDir tells typescript where to find your typescript code to be compiled.

Looks like the configuration is becoming overwhelming, I promise you this is the last configuration haha!.

Now go to your package.json file and locate the "scripts" section and add the following scripts.

"scripts": {
  "start": "nodemon build/server.js",
  "build": "tsc -w server.ts"
}

The build command checks for changes in our typescript file and bundles the javascript code.
The start command checks for changes in our javascript code and runs the bundled javascript code.

Now lets get into the code hurrayyy!!!

Create a file named server.ts in the root of your project and import the your dependencies, initialize express and setup your localhost.

import express, { Request, Response } from "express";

//express initialization
const app = express();

//PORT
const PORT = 4000;

app.get("/", (req: Request, res: Response) => {
    res.send("Hello World!");
});

//localhost setup
app.listen(4000, () => {
  console.log("Graphql server now up at port 4000")
});

Open your terminal in your and run yarn build then yarn start or npm build then npm start, open your browser and navigate to http://localhost:4000, you should see the world Hello World! printed out.

Now lets get into the graphql part

We would add the express-graphql dependecy and some more code which would help us setup graphql playground in our browser.

The graphql playround is where we test our graphql queries, mutations and all other stuffs pertaining to graphql on the frontend, which i would talk about im my next post.

import express, { Request, Response } from "express";
import { graphqlHttp } from "express-graphql";

//express initialization
const app = express();

//PORT
const PORT = 4000;

app.get("/", (req: Request, res: Response) => {
    res.send("Hello World!");
});

//graphql playground setup code
app.use(
  "/graphql",
  graphqlHTTP({
    graphiql: true
  })
);

//localhost setup
app.listen(4000, () => {
  console.log("Graphql server now up at port 4000")
});

The graphiql set to true is what enables our graphql playround in the browser, if set to false it automatically disables the playground.

Now in your browser, go to http://localhost:4000/graphql

You should see something like this.

Hurray, you have created your first Graphql server!!! :).

We would be talking about queries in my next post, see you there ;)

Nodejs setup with Typescript

ayeolakenny — Thu, 07 Jan 2021 00:35:09 +0000

Setting up Nodejs and Typescript was a little bit of a hurdle for me at the time i was beginning, but turns out it was way easier than i thought. This is going to help you cover a decent set up to get you going.

Firstly i dont think i need to define both technologies, i assume you already know them before reading this post :), if not head over to Nodejs.org and typescriptlang.org to find out about them, so lets get going.

Navigate to your project root folder and run the following terminal commands
npm init -y
After that had initialized a package.json file for you run
npx tsconfig.json
let it run the choose the technology you are using which is node

? Pick the framework you're using: (use arrow keys)
> react
  react-native
  node

When that runs finish it automatically generates a suitable tsconfig.json file for your node project.
After that you would need to install some dev dependencies
yarn add -D @types/node typescript
or
npm i @types/node typescript -D
these are basic dependencies node needs to run typescript.
After that add the following scripts to your package.json file.

"scripts": {
   "start": "node dist/index.js",
   "watch": "tsc -w"
},

The dist folder is produced with your compiled javascript by tsconfig when you run the watch command on your typescript file.
Create a typescript file in your root and run yarn watch or npm watch then also run the start command yarn start or npm start and watch tsconfig compile your typescript file to javascript in the dist folder.

I hope i helped, goodluck :).

CovidHelpBot Twillio Hackathon Submission

ayeolakenny — Wed, 29 Apr 2020 20:27:11 +0000

What I built

I built a chatbot that Helps in relieving the stress of health workers by helping people know their present covid-19 status and advises them on what to do based on their answers. It provides people with live updates of the virus across over 100+ countries, and also enlightens people on the most common FAQ's and myths around the covid-19 virus.

Demo Link

It is a chat based bot integrated with whatsapp and programmable chat

Link to Code

Everything was done on the Twiliio console.

How I built it (what's the stack? did I run into issues or discover something new along the way?)

How i built it

I built a chatbot with nodejs, using Twilio autopilot and Twillio functions,
I also integrated it with whatsapp and programmable chat.

Stack

The project was fully built on nodejs.

Issues

Ran into some issues with the autopilot simulator, I the autopilot simulator was not adding line breaks in the output even when i added it in the code.
Could not add images to my with my text, throws an error

Additional Resources/Info

Placeholder title

ayeolakenny — Sat, 04 Apr 2020 01:12:52 +0000

What I built

I would be building a chatbot that helps detect if a person is infected with covid19

Demo Link

Coming soon

Link to Code

Coming soon

Golang

ayeolakenny — Thu, 14 Nov 2019 15:46:15 +0000

Part 1

Introduction
Golang also known as GO is an open source computer programming language created by Google, it was developed at Google in 2007 by Robert Griesemer, Rob Pike and Ken Thompson, and was officially released and introduced to the public in 2009.

From the left: Robert Griesemer, Rob Pike and Ken Thompson

What Is Golang
Golang is a general purpose programming language, making it useful in a wide range of areas, varying from web apps, network servers, mobile apps and machine learning, just to mention a few.
Golang is a statically typed and compiled programming language like the C family.

package main

import (
    "fmt"
)

func main() {
    fmt.Println("Hello, playground")
}

//Result
Hello, playground

Run in Playground
Golang comes with some amazing features like memory safety, garbage collection, structural typing and concurrency, which I would go through as we move further in this article.
However the Golang programming language is engineered for building larger scale and complex software, projects that involves distributed networks, cloud services and other backend technologies, it can also be very useful in solving problems encountered in complex software infrastructure as you scale.

Some Major Features Of Golang

Compiled Programming Language: Golang generates binaries for your applications, complete with dependencies, no iinterpreters or run-time installations are required. In simple terms Golang generates machine code directly from the source code and not from interpreters, in this case no pre-runtime translation takes place, making it a very fast programming language.
Error Handling: Golang is a statically typed programming language, that supports type safety, errors are caught by the compiler before execution. Go codifies errors with the built-in error interface:

type error interface {
    Error() string
}

//Result
can't load package: package main: 
prog.go:1:1: expected 'package', found 'type'

Run in Playgroung

Error values are used just like any other value.

func doSomething() error

err := doSomething()
if err != nil {
    log.Println("An error occurred:", err)
}

//Result
can't load package: package main: 
prog.go:1:1: expected 'package', found 'func'

Run in Playground

Garbage collection: This is one of the exciting features of Golang, havr you ever thought of how messages are pushed in real-time that fast? Low latency garbage collection plays an important role in this. In simple terms garbage collection is the process of freeing memory space that is not being used, this process happens in a concurrent way while the program is running and not before or after execution of the program. Concurrency would be explained as we go further into the article. Read more on implementing memory management with Golang’s garbage collector here
Multi-Paradigm: Golang supports multiple programming paradigms including, Object Oriented Programming(OOP) without inheritance and functional programming.
Concurrency: Basically this is simply the ability of the program to do multiple things at the same time, which allows it to handle numerous task at once in a given period of time. Golang has a very good support for concurrency using goroutines and channels.
Goroutines: A goroutine is a function or method that is capable of running concurrently with other functions or methods.

package main

import (
    "fmt"
    "time"
)

func print() {
    fmt.Println("Printing from goroutine")
}

func main() {
    go print()
    time.Sleep(1 * time.Second)
    fmt.Println("Printing from main")
}

//Result
Printing from goroutine
Printing from main

Run in Playground

From the code snippet above, we have a function print which is just printing a string, in the main function, we have called this function concurrently by using go as a prefix. So now we have 2 goroutines, first our main function and second our print function. We made the main goroutine to sleep for 1 second so that go print() has enough time to execute before the main groutine terminates, then the program will be terminated and no goroutine will run.
You can try this program by commenting go print().

//Result
Printing from main

Run in Playground

Channels: In the goroutine code snippet above we used time.sleep to see the difference between how goroutine works, however a better way to do this is by using channels, goroutine actually communicates with each other by channels.

package main

import (
    "fmt"
)

func print(ch chan bool) {
    fmt.Println("Printing from goroutine")
    ch <- true
}

func main() {
    ch := make(chan bool)
    go print(ch)
    <-ch
    fmt.Println("Printing from main")
}

//Result
Printing from goroutine
Printing from main

Run on Playground

From the code snippet above, we defined a channel ch on line 13 and on line 14 we call print goroutine passing channel as argument. Our print function receives this channels, prints the Printing from goroutine and writes true to the channel. When this write is complete, the main goroutine receives the data from the ch channel, till this time our main goroutine was blocked and once it read data from the channel ch, it is unblocked and then the text Printing from main is printed.
Read more about concurrency here

Note: Concurrency is a property of a program where two or more tasks can be in progress simultaneously. Parallelism is a run-time property where two or more tasks are being executed simultaneously. Through concurrency you want to define a proper structure to your program. Concurrency can use parallelism for getting its job done but remember parallelism is not the ultimate goal of concurrency.

Concurrency is about dealing with lots of things at once. Parallelism is about doing lots of things at once. — Rob Pike

Some Drawbacks Of Golang:

Less Flexibility: Golang has less flexibility than in dynamically typed languages, static typed programming languages like Golang types are checked before runtime while dynamic typed programming languages like JavaSript are checked on the fly during execution.

package main

import (
    "fmt"
)

func main() {
    m := "6"
    n := 6

    fmt.Println(m + n)
}

//Result
./prog.go:11:19: invalid operation: m + n (mismatched types string and int)

Run in Playground

In the code snippet above, statically typed languages like Golang would throw an error because they don't allow for type coercion.

function main(){
  var m = "6";
  var n = 6;

  console.log(m + n);
}

main();

//Result
66

Run in Sandbox
In the code snippet above, dynamically typed languages like JavaSript would merge the string and the number together.

Smaller Number Of Packages: As compared to other ecosystem like Node.js. This is because Golang's standard is full of features which mostly doesn't need third-party support. However, the number of packages are increasing.

In conclusion here are some real world examples of tools and software that uses Golang:

Kubernates: The Google-backed container platform.
Drop-box: The cloud storage and file sharing.
Cloudfare: A content delivery network, DDoS mitigation ans internet security service.
Malware bytes: An antivirus software.

Part 2

Installation

Installation Of Golang on Windows OS:

You’ll be completing most of the installation and setup on a command-line interface, which is a non-graphical way to interact with your computer. Make sure you have an internet connection and administrative access.

cd ..

Switch to your home directory, for example C:\Users\kenny

Navigate to the Go installation website here. Download and install the latest 64-bit Go set for Microsoft Windows OS.
After the installation, run the Command Prompt on your computer go version. You should see something similar to this on your command prompt:

Microsoft Windows [Version 10.0.16299.15]
(c) 2017 Microsoft Corporation. All rights reserved.
c:\Users\kenny>go version
go version go1.10 windows/amd64

Create your work-space, confirm your Go binaries by going to your computer’s Control Panel, then to System and Security > System > Advanced system settings, and on the left-hand pane click the Advanced tab. Then click on Environmental Variables on the bottom-right-hand side. Ensure Path under System Variables has the “C:\Go\bin” variable in it. Then create your Go work-space. This will be in a separate and new folder from where the Go installation files are saved. For example, your G installation files were saved under the path C:\Go and you are creating your Go work-space under C:\Projects\Go In your new Go work-space folder, set up three new folders:

Create the GOPATH variable and reference your newly-created Go work-space. Go back to your Control Panel and navigate to System and then Environmental Variables. Then under System Variables click on New. Next to Variable Name, enter GOPATH, and next to Variable Value enter C:\Projects\Go.

Microsoft Windows [Version 10.0.16299.15]
(c) 2017 Microsoft Corporation. All rights reserved.
c:\Users\kenny>echo %GOPATH%

Check that your path has been set correctly, by entering "echo %GOPATH%" on the command line.

Verify that all is working correctly by opening the command line and typing: go get github.com/golang/example/hello Wait for the code to be entirely implemented (this could take a few seconds), then enter in the following in the command line: %GOPATH%/bin/hello If the installation was successful, you should get the following return message: Hello, Go examples!.

c:Users\kenny>go get github.com/golang/example/hello
c:Users\kenny>%GOPATH%/bin/hello
Hello, Go examples!
c:\Users\kenny>

I hope the installation was successful. And if you run into any errors or confusing messages. You can reference here.
Congrats you are now ready to develop in Golang.

Installation Of Golang on a Mac OS:

To download the latest Go release visit here. You will see the download link for Apple macOS. The current version of Go 1.13 support macOS 10.10 or later versions with 64-bit support only. Alternatively, you can download Go 1.13.3 using the curl command line.

$ curl -o golang.pkg https://dl.google.com/go/go1.13.3.darwin-amd64.pkg

You have downloaded the Go package on your macOS system. To install it simply double click on the downloaded file to start the installation wizard. Command-line users can execute the below command to start the installation.

$ sudo open golang.pkg

Follow the installation wizard and complete the installation process.

Edit the ~/.bash_profile or ~/.profile file (or its equivalent) to set environment variables. Commonly you need to set 3 environment variables as GOROOT, GOPATH and PATH. GOROOT is the location where Go package is installed on your system.

$ export GOROOT=/usr/local/go

GOPATH is the location of your work directory. For example my project directory is ~/Projects/Proj1.

$ export GOPATH=$HOME/Projects/Proj1

Now set the PATH variable to access go binary system wide.

$ export PATH=$GOPATH/bin:$GOROOT/bin:$PATH

The govendor is a tool used for managing the Go application dependencies efficiently. You should consider this to install on your system.

go get -u github.com/kardianos/govendor

Finally, you have successfully installed and configured go language on your system. First, use the following command to check the installed Go version.

$ go version

go version go1.13.3 darwin/amd64

I hope the installation was successful. And if you run into any errors or confusing messages. You can reference here.
Congrats you are now ready to develop in Golang.

Installation Of Golang on Linux OS:

Go here and download the latest version of GoLang in an archive file as follows:

$ cd ~/Downloads
$ wget -c https://storage.googleapis.com/golang/go1.7.3.linux-amd64.tar.gz

Next, check the integrity of the tarball by verifying the SHA256 checksum of the archive file here using the shasum command as below, where the flag -a is used to specify the algorithm to be used:

$ shasum -a 256 go1.7.3.linux-amd64.tar.gz

ead40e884ad4d6512bcf7b3c7420dd7fa4a96140  go1.7.3.linux-amd64.tar.gz

To show that the contents of the downloaded archive file are the exact copy provided on the GoLang website, the 256-bit hash value generated from the command above as seen in the output should be the same as that provided along with the download link.

If that is the case, proceed to the next step, otherwise download a new tarball and run the check again.

Then extract the tar archive files into /usr/local directory using the command below.

$ sudo tar -C /usr/local -xvzf go1.7.3.linux-amd64.tar.gz

Where, -C specifies the destination directory..
Configure your environment, first, setup your Go workspace by creating a directory ~/go_projects which is the root of your workspace. The workspace is made of three directories namely:

bin which will contain Go executable binaries.
src which will store your source files and
pkg which will store package objects. Therefore create the above directory tree as follows:

$ mkdir -p ~/go_projects/{bin,src,pkg}
$ cd ~/go_projects
$ ls

Now it’s time to execute Go like the rest of Linux programs without specifying its absolute path, its installation directory must be stored as one of the values of $PATH environment variable. Now, add /usr/local/go/bin to the PATH environment variable by inserting the line below in your /etc/profile file for a system-wide installation or $HOME/.profile or $HOME./bash_profile for user specific installation: Using your preferred editor, open the appropriate user profile file as per your distribution and add the line below, save the file and exit:

export  PATH=$PATH:/usr/local/go/bin

Then, set the values of GOPATH and GOBIN Go environment variables in your user profile file (~/.profile or ~/bash_profile) to point to your workspace directory.

export GOPATH="$HOME/go_projects"
export GOBIN="$GOPATH/bin"

Note: If you installed GoLang in a custom directory other than the default (/usr/local/), you must specify that directory as the value of GOROOT variable.
For instance, if you have installed GoLang in home directory, add the lines below to your $HOME/.profile or $HOME/.bash_profile file.

export GOROOT=$HOME/go
export PATH=$PATH:$GOROOT/bin

The final step under this section is to effect the changes made to the user profile in the current bash session like so:

$ source ~/.bash_profile

$ source ~/.profile

Finally time to verify the installation, Run the commands below to view your Go version and environment:

$ go version
$ go env

To test your if your Go installation is working correctly, write a small Go hello world program, save the file in ~/go_projects/src/hello/ directory. All your GoLang source files must end with the .go extension. Begin by creating the hello project directory under ~/go_projects/src/:

$ mkdir -p ~/go_projects/src/hello

Then use your favorite editor to create the hello.go file:

$ vi ~/go_projects/src/hello/hello.go

Add the lines below in the file, save it and exit:

package main 

import "fmt"

func main() {
    fmt.Printf("Hello, you have successfully installed GoLang in Linux\n")
}

Now, compile the program above as using go install and run it:

$ go install $GOPATH/src/hello/hello.go
$ $GOBIN/hello

To run your Go binary executables like other Linux commands, add $GOBIN to your $PATH environment variable. I hope the installation was successful. And if you run into any errors or confusing messages. You can reference here. Congrats you are now ready to develop in Golang.

10 Most used Array methods in Javascript

ayeolakenny — Sat, 13 Jul 2019 01:00:18 +0000

In this blog post i'm going to walk you through the most commonly used array JavaScript methods.
Which is going to be helpful in your JavaScript journey, i would also try to keep it nice and simple, so lets dive right in;

1. "push();"

This works at the ending of an array,
which helps in adding elements to the end of an array.

Notice that the letter 'd' has been pushed(added) to the end of the array,
and it makes permanent change to the array.

let arr = ['a', 'b', 'c'];
console.log(arr.push('d'));//returns the new value of the array (4)
console.log(arr); //returns ['a', 'b', 'c', 'd']

2. The "pop();"

Like the "push" method mentioned above.
the "pop" method also works at the ending of an array,
which helps in removing elements at the end of the array, and returns the element.

Notice the the letter 'd' has been popped(removed) out of the end of the array,
and it makes permanent change to the array.

let arr =  ['a', 'b', 'c', 'd'];
console.log(arr.pop()); //returns 'd'
console.log(arr); //returns  ['a', 'b', 'c']

3. "shift();"

This works at the beginning of an array,
which helps in removing elements from the beginning of the array, and returns the element.

Notice the the letter 'a' has been shifted(removed) out of the end of the array,
and it makes permanent change to the array.

let arr =  ['a', 'b', 'c', 'd'];
console.log(arr.shift()); //returns 'a'
console.log(arr); //returns  ['b', 'c', 'd']

4. "unshift();"

You guessed right, this is the opposite of the "shift()" method,
it also works at the beginning of an array, and helps in adding elements to the beginning an array,
and returns the length of the array.

Notice that the letter 'a' has been unshifted(added) to the brginning of the array,
and it makes permanent change to the array.

let arr = ['b', 'c'];
console.log(arr.unshift('a'));//returns the new value of the array (4)
console.log(arr); //returns ['a', 'b', 'c']

5. "concat();"

This helps to concatenate(join/link) two arrays together.

Notice that the first array(arr) and the second array(arr2) has been concatenated(joined) together,
and moreover the "concat" method does not make any change to the array.

let arr =  ['a', 'b', 'c', 'd']; //first array
let arr2 = [true, false, true]; //second array
console.log(arr.concat(arr2));//returns ["a", "b", "c", "d", true, false, true]
console.log(arr);//returns ['a', 'b', 'c', 'd']
console.log(arr2);//returns[true, false, true]

6. "join();"

This joins all the elements in an array to create a string, and does not affect or modify the array.

Notice that the "join" method takes an element and outputs it inbetween the strings.

let arr =  ['a', 'b', 'c', 'd'];
console.log(arr.join(''));//returns 'abcd'
console.log(arr.join('-'));//returns 'a-b-c-d'
console.log(arr)//returns ['a', 'b', 'c', 'd']

7. "reverse();"

This basically takes in an array, and reverses it.

Notice that it makes a permanent change to the array.

let arr =  ['a', 'b', 'c', 'd'];
console.log(arr.reverse());//returns ['d', 'c', 'b', 'a']
console.log(arr);//returns ['d', 'c', 'b', 'a']

8. "sort();"

This basically helps in sorting arrays to order, however causing permanent change to the array.

Notice that it sorts the numbers before the alphabets.

let arr = [5, 3, 'c', 'b', 'a', 4, 1, 2];
console.log(arr.sort();)//returns [1, 2, 3, 4, 5, 'a', 'b', 'c']
console.log(arr);//returns [1, 2, 3, 4, 5, 'a', 'b', 'c']

9. "slice();"

This basically targets an array and returns the targeted array,
and the original array remains unchanged.

Notice that the value is returned from the first value((1)=b) of the array and one element aback from the second value ((2)=b) of the array,
and the original array remains unchanged.

let arr =  ['a', 'b', 'c', 'd'];
console.log(arr.slice(1,2));//returns ['b']

10 "splice();"

Just like the "slice();" method, this also targets an array and returns the targeted array,
moreover it causes a permanent change in the array.

let arr = [1, 2, 3, 4, 5, 'a', 'b', 'c'];
console.log(arr.splice(5, 3));//returns ['a', 'b', 'c']
console.log(arr)//returns [1, 2, 3, 4, 5]

Notice that the value is returned from the first value((5)='a') which states the element to start from,
and the second value(3) which states the number of elements to be removed from the array.

let arr = [1, 2, 3, 4, 5, 'a', 'b', 'c'];
console.log(arr.splice(5, 3, 'replaced'));//returns ['a', 'b', 'c']
console.log(arr)//returns [1, 2, 3, 4, 5, 'replaced']

Notice that you can also replace a spliced element with another element by adding the element in the third argument.

Thats the 10 most common/used array methods i think all javascript programmers must learn, if you have any to add feel free to add below.