Sharad kumar

Okay, so my name is Sharad Kumar, and I'm from Ildur, Madhya Pradesh. I have overall 6 plus years of experience in web development where my primary skills are React.js, Node.js, JavaScript, TypeScript, GraphQL, and Redux. And I'm also familiar with cloud services like AWS, GCP, Firebase, and others. I'm also familiar with the testing architectures. I've used Jest and React testing libraries to write front-end test cases for components. And on the back-end side, I've used Mocha for writing test kits on back-end side APIs. Talking about my project, I've worked on around 15 plus projects, which use React as a front-end technology. Out of 15, 7 to 8 projects use Node.js back-end technology. On those projects, I work as a full-stack developer. My roles and responsibilities include creating components working on features on the front-end side. For the same components and features, I need to create APIs on the back-end side as well. I need to connect both front-end and back-end using React and Node.js. I'm also familiar with writing queries for MongoDB and SQLs. Talking about the projects I'm currently working on, it's a cool app. It's basically a social media platform for Indian people. It's similar to Twitter, where Indian people can post their thoughts without language barriers. They can post their thoughts and local images without worrying about language translations or barriers. On that project, my roles and responsibilities include handling a team of 4 to 5 front-end developers. I need to review their code, assign tasks, and provide help when needed. I also need to connect with the business team and take calls with product managers on a daily basis to give updates about my team's work and assigned tasks.

Catching data in the Node.js side is a good approach for not calling the APIs again for the same data. And we can use Redis on the back-end side. On the Node.js side, we can use Redis implementations. Redis is basically a cache database. So, we just need to configure Redis on the back-end side for some of the APIs, or if you want to apply it to all of the APIs, and we want to avoid requesting the database queries every time because the data is not updated frequently. So we put that data into the Redis. So when a user requests the Node.js server, it will get the data from the Redis database. It won't hit the API or query to the Mongo database or any real database like MySQL or Postgres. So, that's how we can implement the caching on the back-end side for the React front end as well.

Talking about the memory leaks on the notes here. So, memory leak works by means of memory leak first. So, memory leak is nothing but a data leakage on the back-end side. Someone due to some variables or creations, we found that a variable is not used at all and on the back-end code base. And we are just assigning that memory to that variable because we are not using a garbage collector on the Node.js side. So, that's why that memory is assigned to a variable which is not accessed or which is not usable on the back-end side or the code base on the back-end. So, we just need to avoid creating variables using let and const. We cannot create global level variables for our functions or for our internal APIs, basically. So, we just need to use const and let variable declarations. So, it will be a block-level scope for the let and without const. So, once the function use is complete, that variable memory will be reassigned back to the CPU or the memory, basically. So, that's how we can prevent the memory leaks on the back-end side.

Okay. So, basically, if we need to implement role-based access control in our Node.js application, we need to assign a key on our users table, so we can assign the role key in our user database and assign just the role, basically. Like, what type of role we need to manage in our application. We have admin, we have user, we have client. Okay. So, we can just create a role for that, and we will assign that particular role when we are creating a user to that user. Basically, we can assign a role like admin, client, and user. So, once that role is created, we need to manage that role-based access in our application. Okay? So, what we can do is, like, we can create a common function for checking the role. And, according to that, we have the access. So, we just need to add a condition. We just need to create a common function for checking the role access. If we just need to put that into the middleware as well, like, at the time of calling the APIs or the controllers from the routes on the back end side. We just need to put that function into the middleware. So, it will be checking the rules every time once the API hits from the front end to back end. So, it will be checking that function, which is checking the authorization access of the user, basically, to access that controller or not. So, that's how we can manage the access-based control on our application.

If we, okay, want to avoid cross origin request to our back end server, basically, we basically need to avoid the cross origin request to our back end server. So what we can do is use a CORS library to avoid that cross origin errors in our applications. So we can just put URLs, which can only access the backend servers. Okay. So we can create a constant for that URL, basically, and we can pass that array into the CORS options. The CORS options array, we can pass that into the CORS options. So we can just create applications using the express app. We can call the app, and inside that, we just need to pass the list of the URLs, which can access our database from the front end, basically. So that's how we can manage our cross origin request on the back node JS applications. We can use a call as well.

Okay. So, for managing the session on the note aside, we need to understand first how the session is working. Okay. So, the session is basically once the user comes to use our application. We create a session for that user to use our application's APIs or the backend controllers and request backend APIs, basically, for getting and storing data. So, what we can do is when the user signs up or logs in to our application, we can generate a token. And using that token, we can manage a session for that user on a particular browser. So, that token comes into every request that's coming from the frontend to the backend. We just validate if the token is valid or not. So, we need to add an authorization check, and we can check that token is valid or not using token management, we can use JWT, and verify if the token is valid or not. So, what we can do is create an authorization check function, and we can put that function into all the middlewares. We just put that into the request that needs authorization check, basically. We can use that function inside the middleware where we are managing our routes, basically. So, that's how we can manage a session in our application.

We need to convert that response into the JSON object as well because user's data is coming as a JSON object. So we need to use dot notation one more time to convert that response into the object response. So where we get the users as a JSON response, we just need to use the dot notation again. And one more thing I found is, we can create a connection in different functions. Also, we can avoid creating connections in every function in our code base. So we can just avoid creating connections from query database functions to other places. Well, we can use it in other ways as well. That's how we can fix the issues.

If we need to work with batch processing in Node JS, there is a Node JS task library available in Node JS. We can use this Node task for managing our batch processing jobs. So, we can create a task and create one function for handling one batch process. We can also create another function, another task, for managing other batch requests. Okay. Or we can also use the Lambda functions of AWS for managing large-scale batch processing because they are serverless functions. We just need to create one more connection, or we can create another server. So, it will run on the cloud, basically. Cloud servers, basically. It will not need our server to run that batch task, basically. So we just need to create Lambda functions for managing multiple batch processings in our applications.

Okay. So what type of methods we are using to scale our applications? So we have two types of scaling strategies. One is vertical scaling and the other one is horizontal scaling. So if we are going with the vertical scaling, we just need to increase the size of the servers or the memory size of the servers, which we are using currently. So we just need to increase the RAM and the processing power of the current server. So if we are going with the horizontal scaling, we just need to add one or two more machines for handling the traffic in our application. I will go with the second approach, which is a horizontal scaling. So in this approach, what we are doing is we are creating one more server. Okay? With the same CPU size and the same CPU architecture as well. So we can create one more or two more servers. We can deploy our applications. We can create a gateway. So the other services, we can follow the microservice architecture on the AWS and GCP. So AWS provides a default router, which is managing the services on the different servers, basically. So the same thing GCP is doing with Kubernetes. We can also use Kubernetes on the GCP for managing our servers to manage our different services. It will give us zero downtime because if any service breaks, it will not affect the whole application. So that's how we can scale our application and avoid zero downtime during deployment. So that's how we can manage or scale our applications.

Suggest improvements for React Native application performance observed on low-end mobile size. So, low-end mobile size, I'm not entirely sure about that, but let's assume it's a specific screen size. For the responsiveness, if you need to manage performance-related issues on low-end mobiles with less memory. So, what we can do is, when writing a component in our React Native applications, we can identify the unsupported mobiles. If the application fails on those mobiles, we can simply avoid supporting them. We're not operating on this type of mobiles and responsive devices, basically. If it's compulsory, we just need to write some extra components to handle the specific issues on that particular low-end mobile screen. That's how we can improve our React performance on low-end mobiles by creating new components that won't affect other components. These components will only render on low-end mobiles and not on high-end mobiles, basically.

Okay, talking about the Vojisco. So, basically, Vue is following two-way data flow binding as well. Okay, so that's a very important architecture as well. A two-way data binding is there in Vue JS. So we can move that to this improvement. Okay, so we can go through some documents basically when we're working with the. So we just need to follow the best architectures for the code base, basically. Okay, suppose if we're following the MVC architecture. Okay, so we need to create a proper model, view, and controllers in. Also, we need to create the folders for the helper files and the utility folders. We also need to create those. So what we need to do is, like, we need to move the view code, the view part, into the view folder, basically. The model part inside the model. And the controllers are managing the server-side part, inside of Vue JS. So that's an architecture we can follow while working with the Vue JS code base. So it will be pretty good to maintain, and everyone needs to be familiar with the MVC architecture. So we can go with that architecture while working with the Vue JS code base. Thank you.