Mritunjoy Mahanta

Could you help me to understand more about your background by giving a brief introduction? So yeah. So, hi, my name is Mithun J. Mohanty, I'm from Bolpur, which is in Birbhum district in West Bengal. So basically, I have three years and two months of experience in full stack development. So mostly in the ReactJS, NodeJS, ExpressJS, MongoDB, so in the NoSQL database. Also, I work on DynODB as well. And a little bit of AWS, like EC2 instances, Amplify, AWS Amplify, and also S3 Buckets, this kind of thing I worked on earlier. And the last project, the current project I'm working on is called Elite Primary, that's in the real estate domain. And here my role is a front-end developer, I'm just handling the front-end stuff and also leading the front-end team here by using ReactJS, Redux, TypeScript, and Style Component, this kind of thing. And also, before that, I have worked on a project called Mindvoice. So Mindvoice is a quality management tool for contact centers, and that project I have worked on from the scratch. So there my role was as a full-stack developer, I used to work on the front-end part as well as in the back-end part. So in the front-end, I have used ReactJS, Redux, TypeScript, and Ant Design for designing purposes. And for the back-end part, I have used Node.js, Express.js, and MongoDB. And also for hosting purposes, we have used there something called EC2, that comes from AWS. And yeah, so the project is basically, about the project, the project is basically whenever we just call a contact center, right? So the contact center actually records our call. And based on that recording, they have some quality assurance engineers who actually monitor the calls. And depending on that, they actually rate the agent, how's the performance of the agent. And that was very cost-effective, and very time-effective as well. So it was kind of hard to maintain all the agent's performance. And also, we can detect that any fraud in case has happened or not from that tool. So earlier, that quality assurance team actually used to hear all the calls, listen all the calls. And then depending on that, they are actually giving the feedback. But after we build up this project, it actually automatically detects all the things, like any fraud has happened or not, or how the quality of that agent. So basically, it was actually transcribing all the calls, and then getting the transcription out of that. And then based on that transcription, we are actually doing all this stuff. So that was another project. And before that also, I've worked on another project that's called Business Easy. Business Easy is kind of an e-commerce platform, but for e-text filing, too. So there, my role was also as a full-stack developer. So I used to work on that project from the scratch as well. So yeah, that's pretty much all about me.

Can you leverage React's context API to manage global state in the application? And how does it differ from state manual libraries like Redux? So in content, leverage React context API to manage global state. Yeah, so why do we have to, why do we have to, let's suppose we have a parent component, right? And then inside that, and so also we have a child component, and inside that we are also having another child component, so grandchild component. So let's suppose I need data, whichever is present, let's suppose in the parent component, right? And also I need the data, same data in the grandchild component. So what we have to do, like in the normal state, like if you just try to pass that same data, either we have to call that same API from the grandchild component, and that's not a very effective way or efficient way to do that. And other way we can do, like we have to pass that data from the parent component to the child component, and then again to the child to the grandchild component. So that is also not effective way or efficient way, because that child component is actually getting that data unnecessarily, and the data can leak from that child component, right? So what context API does, it does, you don't have to, it actually creates a separate store, and separate store, and whenever we just need the data, instead of just passing it from the parent to child and child to grandchild, we can do one thing, we can just directly call that data from that store, from that, inside that grandchild component. So it just wraps out, we have to wrap up our context, to that whole, initially we have to wrap up our, that let's say that app, which is the initial component to that context provided, and then we can do that. And what's different from the Redux, Redux is also, works like the same way, but what is the difference, is that Redux is a very huge tool, it's an external library, and it doesn't work with only with React, it also work with the Angular as well. So that's the one difference, and also context API actually comes with the, inbuilt in the Redux, and whenever we just create, want to create a mid-size of application, that time if we can use context API, that is fine for it, that we can use, but for a very large scale of application, so where we have to manage a lot of state, that time we have, I mean it is recommended to use Redux, instead of using the context API.

to demonstrate how you would use NestJS guards for implementing a role-based access control. So for role-based access control, what we can do, like we can in the NodeJS, I mean in the backend side, what we can do, we can create one in the user schema, let's suppose. In the user schema, we can pass, let's suppose we have a user schema called first name, last name, email, phone number, and then we also should have a schema called title. So that, sorry, that role, and that role should be, how I actually handle it is like, I just give the value as a numeric value for that role, that is like 0, 1, 2, 3, 4, and what's the higher, I mean if the number is higher, then depending on that higher number, that user has more access, or that, let's suppose we have three types of users, okay? So one is for normal user, and another one is the manager, and the third one is the super admin, or the fourth one is the super admin. So what we can do, like for normal user, we can pass it as like, the role value as 0, and then for the manager, we can pass the value as 1, and depending on 1, 2, and 3. And in the front-end side, what we can do, like whenever we just doing the login, doing the login for that user, we can check what's the role of that user, if it is the 0 or 1, and depending, if it is 0, then we can show the view, or we can log in the user, and then after that, we can show the view, depending on that role of that user, or whatever that user should show, like for the normal user, it should show something different, and for the manager, it should show something different, and depending on that, we can do that. And from the front-end side, what we can do, we can create something called a higher-order component, and inside that higher-order component, we can do this kind of check, that what's the role of that user, and that's how we can do that role-based access control, we can implement that.

Illustrate how you would set up a mongodb replica set to provide high availability for a Node.js application Set up a mongodb replica set to provide high availability for a Node.js application So what we can do, replica set to provide high availability for a Node.js application Let me open up my editor Let me create a new folder For mongodb implementation, what we can do For mongodb implementation, what we can do I thought we have to demonstrate that I thought we have to demonstrate that We can use something called mongoose To connect with the database, we can use mongoose That's a separate package we have to install We can do something like mongoose.connect We can do something like mongoose.connect We can do something like mongoose.connect We can use mongoose.connect We can use mongoose.connect We can use mongoose.connect We can use mongoose.connect We can get the connection string from there We can use mongoose.connect We can use mongoose.connect We can use mongoose.connect We can use mongoose.connect We can get the connection function, from there We can get the connection function, from there

strategy for merging complex feature branches with git, merging complex feature branches with git while ensuring minimal disruption to the main development branch. Demonstrate a strategy for merging complex feature branches with git while ensuring minimal disruption to the main development branch. So what we can do for merging a branch what we can do like initially what I do like let me demonstrate this from the scratch very scratch like let's suppose I have a main branch and that all the things are actually merged to the finally into the main branch right so what you can do let's suppose I am creating a new branch called staging branch and I just need to merge that I just need to take that take that main branch code to the staging branch first and then we can later on whatever changes we are doing in the main staging branch we can just merge it to the main branch so what we can do like the comment sorry the command we have to do like git initially like we can do like git stash to stash all the changes whatever we did so that we don't miss out all the changes whatever we did earlier and then what you can do like git checkout and with the sign of minus b to create a new branch and then giving up the new name that is the staging right so I will just pass their new name after minus b or dash b space staging and then we can pass the main name because we are taking all the code from the main branch and then if you just press the enter it will create a new branch in the name of staging and then what will happen it will create a new branch from the from by taking the code from the main branch and also we can after that we can do something like git stash pop so that whatever changes we have done and whatever are in the stash we stashed earlier it will be pop up I mean it will be come here again in this new branch so that is the staging branch and whatever changes we have to make and we can just select all those or like git add and select all those files and then what we can do like we can do like git commit and minus m for message and then pass it pass the message whatever we commit message whatever we want to do add and then we can do something like git push origin and to that branch name that is that staging branch right so that staging and then these changes will be there in the staging branch and later on what we can do like git merge we can write that git merge command and then them with the branch name that main branch and also that current branch name and otherwise if you go to the if you are using github or git lab for that we can do like we can directly go to the github or git lab portal and then we can create a peer for that one or the merge request for that from them for that staging branch to the main branch and then it will come up come up a merge request in the main branch and we can merge the code from there so that's the way we actually doing the git merging the complex feature

How do you integrate a client-side React application with a server-side Node.js backend, ensuring secure API calls and data transfer? So yeah, so for integrating a client-side React application with a server-side Node.js backend, ensuring secure API calls and data transfer. So for that, what we can do, we can use something called CORS. So CORS is a cross-origin resource, the full form is something like that. And what it does, it actually allows you to take the data or fetch the data from the different or it allows the server to call it from a different endpoint or from a different server. So let's suppose if you are not using a CORS in our backend application, then what will happen? If you try to call that API, after creating all the, let's suppose I'm creating an API for getting the user. So if you try to call the API from the front-end server, so the port number is different, right? So although it's running in the same machine, but the port number is different, right? So let's suppose the front-end is running in the port 5050, but the backend is running in the port 4000. So then it will give us some CORS error in the terminal or in the browser console. So you can see it there, that there is a CORS error. So that means that it doesn't allow, the backend server is not allowing it to call the data from a different server. So in that case, we have to install CORS in the backend server, and then what we can do, in the Node.js application, what we can do in the main file, like index.js file, we can create a, we can import the express.js from express library, and then let's suppose I'm just initializing that express.js in a variable called app. So we can use like app.use, and then inside that, we can just call the CORS, C-O-R-S, and just pair of parentheses. So and before that, we also have to import that CORS as well, install and import that CORS as well. So that's how we can do the secure API call for data transfer.

Observe the lifecycle methods and determine if there is an issue when this component is unmounted. There is an issue when this component is unmounted. And then component will unmount if there is anything we should do here. What we have to do here, we have to unmount the state from here. So in this case, in this component will unmount. In this case, what we have to do, we have to stop this fetch API calling. So what we can do, there is a function, I forgot that, but that function is something like, so it will just prevent to fetching that API or cancel that API call. So basically that's the thing. We have to cancel this fetch user data call in this component will unmount. So what will happen? Let's suppose we are just going to that user's page and then this user profile page, then this API will call, right? So it's the component it mounts, so initially it will be called. But let's suppose, and again, instantly we're just clicking on the other page, like the home page. So that time what will happen, we don't need that API, right? So that will be an unnecessary resource taking thing. So we have to unmount that component as well as we have to cancel that fetch user data, this function. So that user fetching doesn't happen and that resource won't take this, because we don't need the data. So we have to call this, we have to cancel this API call, so that's what we have to do. But I was slightly missing that exact function name, what I have to do, but yeah, that's what we have to do.

In this Node.js code block, can you spot any issues that might affect scalability or cause potential errors in handling asynchronous operations? Function fs.readfile path utf-error-data if-error-thrower-console-log-data In this fs.readfile, we have to make it as asynchronous operation because whenever we just try to read a file, that is an asynchronous operation. We can use an async await method here so that inside that await we can just log this data and otherwise we can handle the error from there. So inside the try-catch, let's suppose I'm just passing instead of this if-error, we just, this is fine, if-error, this is fine, but then we can pass something called a try-catch inside the try block, we can pass this, we can store this data inside a variable and then that is the await inside that await and then console log this data, otherwise in the catch, we can just catch the error and then console log that error or whatever we want to do in the error, so that's what we can do in this function.

What strategies would you deploy to optimize the performance of a React Native application integrating with a Node.js packet? So strategies optimize the performance of a React Native application interacting with a Node.js packet. So strategies I would make is initially in the Node.js server, so that is the clustering thing I will use, definitely the clustering thing because if we are creating it as a multiple cluster and multiple thread, then it will be a lot more easier or a lot more scalable whenever we just, there is a multiple user for this one, I mean for that actual application and that doesn't break that application very easily. So that clustering thing we will use, so that we can actually optimize, use our whole system's core, every core of the system that we can use, that's the thing. And another thing is we have to handle all the errors properly or we have to try and catch everywhere so that we can catch all the errors instead of it just broke somewhere. And also we have to approach that error first approach, we have to use that so that whenever there is something error, we have to catch it first and then if you are just getting some error, then we have to catch it first and otherwise if you are not getting the error, you have to check it first and then if you are not getting the error, then it's fine, we can just pass the response, that's the thing we can use in the backend. And the React Native application what we can do, we can use something called Redux to managing the states, also we can use lazy loading to load the components properly, not properly, it's actually like lazy loading for whenever we just need a component and that time only we will import that component, otherwise we won't import that component, that is the thing. And we also use something called React Suspense to show some suspense in our project so that user can actually know that there is something, instead of just loading all those components at the initial state, we can just use React Suspense. And also Redux is one thing that I have already mentioned and also for getting that error in the development time, we can use something called TypeScript, so that will also improve the development speed, it will not improve the performance but it will improve the development speed. And we will use functional component as functional component is much faster than the class-based component as what's the reason for that, the reason for that is that class-based components are actually converted by our compiler into the functional component, so in the functions initially it is, I mean later on when we just try to build our project, that time it just converted into the functional component, so that actually takes a slight extra time while we are just writing a class-based component, so we will use the functional component, so that will eliminate that time, so that's the thing we can use to optimize the performance in the React Native application with the Node.js backend.

Can you explain how Jenkins can be utilized to automate testing MongoDB backend node.js applications? Yeah, we can use Jenkins while we are creating the CI-CD pipeline also to create an automated test that if all the codes are in the place or something like that, we can use Jenkins for that.

How do you handle automatic deployment of React application using AWS infrastructure using CICD tools? So, one way, that's the easy way, I would say, for React application is that AWS offers something called AWS Amplify. If we deploy, if we give the permission of our GitHub repo or GitLab repo to that Amplify, then it will, whenever we just commit the code in a specific branch, let's suppose I'm just telling AWS Amplify that there is a specific branch called master, then you have to select that, then whenever we're just committing that code in the master or just merging some other branch with the master, it will find that changes, it will conditionally check that if there is any change in the master branch, then it will take that changes and then it will automatically deploy that in the server. So, that's the one thing. Otherwise, we can use something called Jenkins to create our own CICD pipeline. So, that's the different thing. We can also use that. So, that's how we can do that.