Forem: Kushagra Mehta

Unacademy Software Engineer interview experience, Web

Kushagra Mehta — Sat, 07 Aug 2021 15:33:19 +0000

Hello everyone,
I'm Kushagra Mehta, a final year student from Jaipur. I have joined Unacademy as a Software Engineer. In today's blog, I'll be sharing my interview experience at Unacademy for a Software Engineer position.

Big shoutout to Rajat Gupta who, wrote a great Interview experience article that helps me along the way. Link🔗

How it started?

Hmm, This is an interesting one. From my side, I did some cold-DM's in mid of Jun-21 asking for interviews(Great videos on it).

Then on the sweet morning of 13-Jul, I got a call from HR team of Unacademy asking that, Was I available for an interview or not. From here, my journey started, So the call goes like this

** Basic introduction **
HR: Can you tell me something about yourself
Me: I'm kushagra.....
HR: Awsome man
Me: 😳 OK.!!
HR: Let's schedule a call for your next round
Me: 😮 Why not (Inside me:- Am I dreaming or what 😶)

The recruiter explained everything related to the next rounds over the call and scheduled the first round.

I asked my recruiter where he got my profile from, he said he liked my LinkedIn & Github profile and that's why he reached out to me. So boys and girls it's time to improve your online profiles.

Interview rounds✨

JS Fundamentals (~ 1 hr)
Frontend with React (~ 1 hr)
Senior Engineering Manager (~ 30 m)
Culture ( ~ 30 m)

Platform: Google Meet

Coding Environment: CodeSandbox

Let's dive into each round in detail.

👨🏻‍💻 JS Fundamentals

It started with a simple intro. Then we quickly jumped into the realm of JS. The questions revolved around basics concepts of Javascript like:- this, let/var/const, Promises

The interview was more around discussion-based, Why or How something is happening. We started with output-based questions, where we discussed What, Why & How things are happening.

He told me to implement Promises after that, we discussed my approach.

At last, we discussed eventHandling, debouncing & throttling. After that, I was asked to build debouncing function and implement a use-case for it(build Search bar).

How to prepare:💛javascript.info, Akshay Saini - FE Interview Ques

Everything was chill, he helped me in every step of the interview. Even when I did something wrong with .addEventListener he explained why things are not working and helped me with the process🤯

⚛️Frontend with React

This happened the day after the first round. We started with building a Google timer clone. I was asked to explain the approach I took.

After that, We discussed some basic concepts of JavaScript
closures, setTimeout, this, async/await, promises, async/defer, event loop... Then we jumped into some basic CSS questions like inline/inline-block, Box model, etc.

Then we jumped into the territory of ReactJs. The questions ranged from what is React, State/Props, Lifecycle methods, Lifecycle in Class components vs Functional components, Virtual DOM.

At last, I was given a basic problem to solve Sort an array of 0s, 1s and 2s

How to prepare: Front End Interview Handbook✨, List of top 500 ReactJS Interview Ques😵

This round was also super chill. I stuttering a lot in explaining things. Even I got confused in some question, but interviewer helped me understand them🤯.

👨🏻‍💼Senior Engineering Manager

It was more of a discussion on my decisions over tech-stack, team dynamics, and culture fit. It started with technical questions on Why I choose ReactJs, what I did in my previous internship, What I learned from there, and What I did not like there.

Then he asked me some behavioral questions like:

How will you suggest someone to opt ReactJs rather than other options?
What if there is some conflict with your manager. How will you resolve them?
What if a mentor in a new Organization is not helping much how would you be going to tackle the situation?

Then I was asked, If I have any questions for them and what I would like to work on.(If you see my profile, I'm more of a full-stack guy. 😅 They said we're a flexible team you can work on anything until you're sure about its working 🤩)

How to prepare: 60 Toughest Interview Questions😎

After this round, I got very excited as I wanted to work as a Full-stack guy and got a green flag from the Manager. 🕺🏻

Culture

In this round, we discussed the working of the company.

This round was all about behavioral and situation questions like how will you react if the project you're working on for a few months gets shelved.

🥳The End

After all these rounds, I got an Offer letter💌 and I accepted it (voilà 🎊).
I really liked the complete interview process at Unacademy. All the rounds were more oriented toward discussion rather than typical Questions and Answers sessions.

Big thanks to Unacademy for giving me chance to prove myself and to the Talent Acquisition team for the wonderful interview experience. I can't even imagine that I would ever receive an offer from Unacadmey, whole process was like a dream to me (some say I'm still dreaming till this date 😳)

If you're someone who wants to build the future of education, please apply here 👉🏻https://apply.workable.com/unacademy/

WebRTC ➕ Build Yet another Chatting app💭 but P2P/E2EE🤯.!!

Kushagra Mehta — Thu, 01 Jul 2021 13:21:50 +0000

What does this title mean

If by reading the title of this article you're thinking that we're going to build just a chatting app then you're thinking wrong, no we're not😅. Hey-Hey.!!! We all have built some kind of chat app in our free time then why to built one more again. So before you leave, let me explain why We're not going to create just a chatting app and why it is different from what you have built in the past as it does not use any REST API, not even a well-known WebSocket. we're going to build something much better faster, which is End-To-End encrypted, don't need any server And its code is short to write(Size matters, and sometimes it should be small).

Some thought behind Why I'm writing this article

So when I start searching about how to create any Real-time communication between two peers I didn't get many results. Everything was just hard to understand and not much help for a beginner. While searching one word was coming, again and again, it was WebRTC. So I want to understand what it is and how it works.

The first thing I found out about it is that it is really hard to find good content over WebRTC and second misconception. I'm just focusing on the second one in this article. Most of us when start learning WebRTC think it is just related to Video/Audio streaming and it is only restricted to client-client connection because it is only present in the browser. But WebRTC is much more than Video/Audio it is something much greater and much dynamic. It is built on the shoulder of some great legendary protocols.

WebRTC 101

Just for a quick note I'm not going in depth how WebRTC work. If you're interested you can read WebRTC For The Curious book.

WebRTC, short for Web Real-Time Communication, is both an API and a Protocol. The WebRTC API allows developers to use the WebRTC protocol. With WebRTC, you can add real-time communication capabilities to your application. The WebRTC API has been specified only for JavaScript defined by W3C and Protocol defined By IETF. It is just a bundle of different protocols. It is not just limited to Video/Audio it is much greater than that, you can also send text, binary or generic data. To increase your curiosity Cloud gaming is going to be build around WebRTC

Some feature provided by WebRTC

By default Feature E2EE.
Connect two users with no public IP (NAT traversal, ICE).
Stay connected on Move(Auto-negotiation by ICE Restart).
Connect without knowing IP(mDNS).
No more headline blocking(By SCTP).

You can understand WebRTC Lingo by clicking here

Let's understand how WebRTC do all these magics.

Signaling Offer/Answer :- So let's understand this by an eg. I don't know you & you don't know me. We have no idea about each other than how we're going to communicate with and what they are going to communicate about. So by Signaling we explain to each other, Hey man this is my address(NAT mapping) and this is the language(codec) I support, We can talk about Media(MediaStream) or some generic data(DataChannel), the man just chill and talk whatever you want I'm here for you. This is all done by sharing SDP with each other.
Connecting:- Now we know enough about each other. But the problem arises that we only know each other at a higher level in a networking term at the application layer, we should know each other's limitations and find a better way to communicate at the network layer that's why we share ICE candidates.Why we need ICE more here.

ICE candidate in layman's terms would be like hey this is my phone number, this is my email, my house address these all can be an ICE candidate. In simple terms, ICE candidate is just "These are some paths by which you can access me" it can be HostName(local Ip Addr), Server reflexive(NAT mapping), Relay(Proxy server/TURN server), etc.

Because of ICE candidates, we can be stay connected on the move:- New ICE candidate as you move(Wifi/LTE). Switch to between better connection when present(Auto-negotiation by ICE Restart)
Securing:-DTLS(TLS over UDP)+SRTP, Encryption over RTP. That mean now you have End to End Encryption(E2EE). No more man-in-middle.
Communication:- Now lets communicate, MediaCommunication or DataChannel whatever you want.

Let's build Chat app using WebRTC

In the chat app there will be two peer Local and Remote. We're going to use WebRTC API in browser.

Step 1:- Initial JS setup

As we have this HTML now connect it with JavaScript and add some event to it.

let localmessageInput = document.getElementById("local");
let localMessageArea = document.getElementById("localmsg");

localmessageInput.addEventListener("keyup", (event) => {
  if (event.key === "Enter") {
    addChildMessage(localMessageArea, event.target.value, "right");
    localChannel.send(event.target.value);
    event.target.value = "";
  }
});

Get reference to Input element and message are.
Add an event on input element whenever ENTER is pressed.

Add message to text area, with right align.
Call some localChannel.send function and pass our input value.
clear the input value.

Everything is same for remote peer part of code.

Step 2:-

let config = null;
// config = {
//   iceServers: [
//     {
//       urls: ["stun:stun1.l.google.com:19302", "stun:stun2.l.google.com:19302"],
//     },
//   ],
//   iceCandidatePoolSize: 10,
// };

let localPeer = new RTCPeerConnection(config);
let remotePeer = new RTCPeerConnection(config);

We create RTCPeerConnection object which provides methods to connect to a remote peer, maintain and monitor the connection. In our setting config is null as our project is running in local enironment if you are connecting two peer over internet then you can use the commented config.

Step 3 Establishing a connection: signaling:-

Step define here are not proper way of signalling so please refer The WebRTC perfect negotiation pattern

async function init() {
  localPeer
    .createOffer()
    .then((localOffer) => localPeer.setLocalDescription(localOffer))
    .then(() => remotePeer.setRemoteDescription(localPeer.localDescription))
    .then(() => remotePeer.createAnswer())
    .then((remoteSDP) => remotePeer.setLocalDescription(remoteSDP))
    .then(() => localPeer.setRemoteDescription(remotePeer.localDescription))
    .catch((err) => window.alert(err));
}

So anyone can start the offering here localPeer start it by calling .createOffer() this will return SDP of localPeer.
We store localOffer in the localPeer by calling setRemoteDescription.
Now we can send the LocalDescription by any method like webSocket, or REST API. but As our both the peer are present locally we'll directly set setRemoteDescription for the remotePeer.
Now localPeer has its own Description and remotePeer has Description of localPeer, Now remotePeer will create its own Description by calling createAnswer() which will create the Description but also initiate the connection process.
Same as localOffer we can also share remoteSDP by any proccess. Here we're just passing it to localPeer.

Now both the peer have Description or knowledge about each other. Now they can start connection.

If you didn't understand the proccess above then you can refer flow diagram from here.

Step 4. Connecting:-

localPeer.onicecandidate = ({ candidate }) => remotePeer.addIceCandidate(candidate);
remotePeer.onicecandidate = ({ candidate }) => localPeer.addIceCandidate(candidate);

onicecandidate Is an event-handler which specifies a function to be called whenever the local ICE agent needs to deliver a message to the other peer through the signaling server. What it does share the Info of ICE candidate it found and share to other peer, other peer just add the candidate. By this WebRTC API will try every ICE candidate and establish the throght the optimal ICE Candidate. After this step complete our connection is established. 🎉🎊.

Step 5. DataChannel:-

let localChannel = localPeer.createDataChannel("chat");
let remoteChannel = null;

localChannel.onmessage = (event) => {
  log("Got message at local side", event);
  addChildMessage(localMessageArea, event.data, "left");
};

remotePeer.ondatachannel = (event) => {
  remoteChannel = event.channel;
  remoteChannel.onmessage = (event) => {
    log("Got msg at remote side", event);
    addChildMessage(remoteMessageArea, event.data, "left");
  };
};

After Connection is establish, By calling createDataChannel on localPeer creates a new channel linked with the remote peer, over which any kind of data may be transmitted.
onmessage is an event handler which specifies a function which is called when the a meessage is sent over the DataChannel by other peer.
ondatachannel is an event handler which specifies a function which is called when an RTCDataChannel is added to the connection by the remote peer calling RTCPeerConnection.createDataChannel.

Success 🤝🏻

We have build the simplest chatting app you can think of. You can find the whole code here.

Awesome Idea implemented Over WebRTC

Multiple Language implementation

PostgreSQL with Go in 2021

Kushagra Mehta — Wed, 07 Apr 2021 13:05:40 +0000

Introduction

If you’re a modern web developer, it is inevitable to ignore a database for long as it plays an important part in the application.

So in this post, I’ll be demonstrating how we can connect to a PostgreSQL database and perform basic SQL statements using Go.

Prerequisites

You'll need Go version 1.16+ and PostgreSQL installed on your development machine.

In order to connect with PostgreSQL we need driver, So we'll use pgx as our driver.

Code time 🚀

Code v0.1 🌎

Aim

Let's Start with a simple "Hello World.!" code.

Let’s create a new main.go file. Within this, we’ll import a few packages and set up a simple connection to an already running local database. for this tutorial, I'm using postgres as username, 123 as password, localhost network address, :5432 default port, and test database.

You can change according to your setup.

postgresql://[user[:password]@][netloc][:port][/dbname][?param1=value1&...]

Now open main.go and write the following code.

package main

import (
    "context"
    "fmt"

    "github.com/jackc/pgx/v4"
)

func main() {

    // Open up our database connection.
    conn, _ := pgx.Connect(context.Background(), "postgres://postgres:123@localhost:5432/test")

    // defer the close till after the main function has finished
    // executing
    defer conn.Close(context.Background())
    var greeting string
    //
    conn.QueryRow(context.Background(), "select 'Hello, world!'").Scan(&greeting)
    fmt.Println(greeting)
}

pgx.Connec() establishes a connection with a PostgreSQL server with a connection string, this will return pgx.Conn is a PostgreSQL connection handle.

conn.QueryRow() executes sql query on the database, After that we store the response of data using .Scan()

Code v1.0

So, now that we’ve successfully created a connection and build hello world with the database. Now let's start with a table and perform some queries over it.

Aim

Now we build a program where we can insert and fetch user data. We will understand various functions in the pgx package.

Creating Table into PostgreSQL

CREATE TABLE IF NOT EXISTS USERS(
        ID          SERIAL   PRIMARY KEY,
        USERNAME    VARCHAR(20) NOT NULL UNIQUE
    );

Table name is Users with ID and USERNAME columns.

Creating user struct

// User is the model present in the database
type User struct {
    ID       int    `json:"id"`
    UserName string `json:"username"`
}

Inserting User into database

So if we want to store a user into the database.

//Creating temporary user object.
tmpUser := User{UserName: "Captain K"}
//Calling InsertUser Method
InsertUser(&tmpUser, conn)

func InsertUser(u *User, conn *pgx.Conn) {
    // Executing SQL query for insertion
    if _, err := conn.Exec(context.Background(), "INSERT INTO USERS(USERNAME) VALUES($1)", u.UserName); err != nil {
        // Handling error, if occur
        fmt.Println("Unable to insert due to: ", err)
        return
    }
    fmt.Println("Insertion Succesfull")
}

Querying Multiple Rows

When we want to read all the users stored in the database.

func GetAllUsers(conn *pgx.Conn) {
    // Execute the query
    if rows, err := conn.Query(context.Background(), "SELECT * FROM USERS"); err != nil {
        fmt.Println("Unable to insert due to: ", err)
        return
    } else {
        // carefully deferring Queries closing
        defer rows.Close()

        // Using tmp variable for reading
        var tmp User

        // Next prepares the next row for reading.
        for rows.Next() {
            // Scan reads the values from the current row into tmp
            rows.Scan(&tmp.ID, &tmp.UserName)
            fmt.Printf("%+v\n", tmp)
        }
        if rows.Err() != nil {
            // if any error occurred while reading rows.
            fmt.Println("Error will reading user table: ", err)
            return
        }
    }
}

Querying a Single Row

Find a user using user's ID.

func GetAnUser(id int, conn *pgx.Conn) {
    // variable to store username
    var username string

    // Executing query for single row
    if err := conn.QueryRow(context.Background(), "SELECT USERNAME WHERE ID=$1", id).Scan(&username); err != nil {
        fmt.Println("Error occur while finding user: ", err)
        return
    }
    fmt.Printf("User with id=%v is %v\n", id, username)
}

Conclusion 🎉

In this post, we managed to set up a connection to a PostgreSQL and then perform some simple queries to that database and marshal the returned responses into a struct. This should hopefully give you everything you need in order to take things further and build your own Go applications on top of PostgreSQL.

When to use db.Exec or db.Query ?

We can use pgx and pgxpool interchangeably but pgxpool is a concurrency-safe connection pool for pgx. It is not safe for concurrent usage. Using a connection pool to manage access to multiple database connections from multiple goroutines.

REST server with Go in 5 minutes

Kushagra Mehta — Mon, 05 Apr 2021 10:00:20 +0000

👋🏻Hey, If the title of this article excites you, then my friend, you're at right place.

Let's quickly go through what we're going to cover in this post.

First will be going to build a teeny weeny REST server and understand its working. After that, we'll incrementally improve its working and know its weakness.
We build a CRUD server where we can CREATE, READ, UPDATE and DELETE User details.

To keep everything simple. We'll focus on the basic concepts and won’t interact with any package and build server using the standard libraries and understand their limit and strength.

Prerequisites

You'll need Go version 1.16+ installed on your development machine.

Start 👷🏻‍♂️

Now let's dive into the code.

Version v1.0

package main

import (
    "fmt"
    "log"
    "net/http"
)

func homePage(w http.ResponseWriter, r *http.Request) {

    log.Println("Endpoint Hit: homePage")

    fmt.Fprintf(w, "Welcome to the HomePage!")
}
func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/", homePage)
    log.Fatal(http.ListenAndServe(":8090", mux))
}

If you run this code on your machine. This will start simple API server at port 8090. In your browser navigate to http://localhost:8090/, you'll going to see "Welcome to the HomePage!".

THE API IS CREATED 🎇

Ta-Da, You build your first API server with Go. Yes, It was that easy.

Ok, Now understand the code

func http.NewServeMux() *http.ServeMux

http.NewServeMux is the default serve mux in Go from the net/http package. The method will actually create a multiplexer where it registers patterns with their corresponding function. We can also skip this step, as by default net/http package create DefaultServeMux which is the same.

func (*http.ServeMux).HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request))

The HandleFunc method takes two arguments, the first string pattern, and the second handler function to which pattern to register with. Ok, but what the heck is a handler. Handler is an interface that has a method called ServeHttp, responds to an HTTP request, and has all the logic related to that End-point. We'll understand more about it in down the post.

func ListenAndServe(addr string, handler Handler) error

Then ListenAndServe method takes two arguments, the first is to address to start the server on and handler in the case of using DefaultServeMux we can pass nill as an argument.

Version v2.0

Now we're going to build REST server with all the functionality which will allow us to CREATE, READ, UPDATE and DELETE users.

User Structure

Before starting with anything first build the user structure and list in which our user will going to store in.

type User struct {
    ID       int    `json:"id"`
    Username string `json:"username"`
    Email    string `json:"email"`
}

// let's declare a global Articles array
// that we can then populate in our main function
// to simulate a database
var userlist []User

You can see that we have use tags on struct field declarations to customize the encoded JSON key names. These tags are going to be used by "encoding/json" package.

Create Helper function

JSON function is going to encode any data to JSON format so that we can send the data to the client.

func JSON(w http.ResponseWriter, statusCode int, data interface{}) {
    w.WriteHeader(statusCode)
    w.Header().Set("Content-Type", "application/json")
    if err := json.NewEncoder(w).Encode(data); err != nil {
        fmt.Fprintf(w, "%s", err.Error())
    }
}

getUid will extract user-id(uid) from URL by slicing the URL. After that, it converts the uid to int from the string.

func getUid(pathSuffix string, r *http.Request) int {
    var slug string
    if strings.HasPrefix(r.URL.Path, pathSuffix) {
        slug = r.URL.Path[len(pathSuffix):]
    }
    uid, _ := strconv.Atoi(slug)
    return uid
}

Error is just a wrapper around JSON function to add an additional error flag to the JSON data

func Error(w http.ResponseWriter, statusCode int, err error) {
    if err != nil {
        JSON(w, statusCode, struct {
            Error string `json:"error"`
        }{
            Error: err.Error(),
        })
        return
    }
    JSON(w, http.StatusBadRequest, nil)
}

Building our Router

Now we'll add our routes to main.go file.

func main() {
    mux := http.NewServeMux()

    mux.HandleFunc("/", homePage)
    mux.HandleFunc("/user/get/", getUser)
    mux.HandleFunc("/user/post/", postUser)
    mux.HandleFunc("/user/delete/", deleteUser)
    mux.HandleFunc("/user/patch/", patchUser)

    log.Fatal(http.ListenAndServe(":8090", mux))
}

Create

We will need to create a new function that will do the job of creating new users.

Let’s start off by creating a postUser() function within our main.go file.

func postUser(w http.ResponseWriter, r *http.Request) {
    fmt.Println("Endpoint Hit: postUser")
    reqBody, _ := ioutil.ReadAll(r.Body)
    var userData User
    json.Unmarshal(reqBody, &userData)
    userlist = append(userlist, userData)
    JSON(w, http.StatusCreated, "Created")
}

Now understand what we have written in the function.

First of all, we've to extract the bytes array from the request body, for that we use ioutil.ReadAll(r.Body) which reads from r until an error or EOF and returns the data it read.
json.Unmarshal(reqBody, &userData) parses the JSON-encoded data and stores the result in the .userData.
After that we append the user into userlist.
Send Created respone to the client

Read

Now we have created the creation function so now we want to fetch the newly created user from the server.

For that we'll create a getUser() function within our main.go file.

func getUser(w http.ResponseWriter, r *http.Request) {
    fmt.Println("Endpoint Hit: getUser")
    uid := getUid("/user/get/", r)
    for _, user := range userlist {
        if user.ID == uid {
            JSON(w, http.StatusOK, user)
            return
        }
    }
    Error(w, http.StatusNotFound, errors.New("User Not Found"))
}

Now understand what we have written in the function.

As client will send the user id in URL so we parse the URL and extract uid.
After that we'll loop over the userlist array to find the user
- If we find one then we send OK status with user data.
- If the user is not present then send an Error response that the user is not found.

Update

After creating and reading now it's time for updating. create a patchUser() function within our main.go file.

func patchUser(w http.ResponseWriter, r *http.Request) {
    fmt.Println("Endpoint Hit: patchUser")
    uid := getUid("/user/patch/", r)
    reqBody, _ := ioutil.ReadAll(r.Body)
    var updatedUserData User
    json.Unmarshal(reqBody, &updatedUserData)
    for index, user := range userlist {
        if user.ID == uid {
            userlist[index] = updatedUserData
            JSON(w, http.StatusOK, "Patched")
            return
        }
    }
    Error(w, http.StatusNotFound, errors.New("User Not Found"))
}

Delete

There may be times where you need to delete the data being exposed by your REST API. In order to do this, you need to expose a DELETE endpoint within your API that will take in an identifier and delete whatever is associated with that identifier.

Add a new function to your main.go file which we will call deleteUser():

func deleteUser(w http.ResponseWriter, r *http.Request) {
    fmt.Println("Endpoint Hit: deleteUser")
    uid := getUid("/user/delete/", r)
    for index, user := range userlist {
        if user.ID == uid {
            userlist = append(userlist[:index], userlist[index+1:]...)
            JSON(w, http.StatusOK, "Deleted")
            return
        }
    }
    Error(w, http.StatusNotFound, errors.New("User Not Found"))
}

Note - To keep this simple, we are updating a global variable. However, we aren’t doing any checks to ensure that our code is free of race conditions. In order to make this code thread-safe, I recommend checking out Go Mutexes

if you're reading this, that means now you can build any CRUD application.

Conclusion

This example represents a very simple RESTful API written using Go. In a real project, we’d typically tie this up with a database so that we were returning real values. For the next step, I would suggest you should read Gorilla/Mux package. As it will remove a lot of boilerplate code and written only with the standard line.

Source Code - The full source code for this tutorial can be found here: KushagraMehta/Blog/REST server with Go

In the next post, we'll add Postgresql plus Dockerize the whole application, furthermore host it on Heroku/AWS.

I hope you find this blog useful. Please share your thought in the comments.

Forem: Kushagra Mehta

Unacademy Software Engineer interview experience, Web

How it started?

Interview rounds✨

👨🏻‍💻 JS Fundamentals

⚛️Frontend with React

👨🏻‍💼Senior Engineering Manager

Culture

🥳The End

WebRTC ➕ Build Yet another Chatting app💭 but P2P/E2EE🤯.!!

What does this title mean

Some thought behind Why I'm writing this article

WebRTC 101

Some feature provided by WebRTC

Let's understand how WebRTC do all these magics.

Let's build Chat app using WebRTC

Step 1:- Initial JS setup

Step 2:-

Step 3 Establishing a connection: signaling:-

Step 4. Connecting:-

Step 5. DataChannel:-

Success 🤝🏻

Awesome Idea implemented Over WebRTC

Multiple Language implementation

PostgreSQL with Go in 2021

Introduction

Prerequisites

Code time 🚀

Code v0.1 🌎

Aim

Code v1.0

Aim

Creating Table into PostgreSQL

Creating user struct

Inserting User into database

Querying Multiple Rows

Querying a Single Row

Conclusion 🎉

Recommended Reading: REST server with Go in 5 minutes

REST server with Go in 5 minutes

Prerequisites

Start 👷🏻‍♂️

Version v1.0

THE API IS CREATED 🎇

Version v2.0

User Structure

Create Helper function

Building our Router

Create

Read

Update

Delete

Conclusion