Mahima Gupta

Yes, so my name is Marina, I am having 5.8 years of experience as a full stack developer and I am currently working with Boston Consulting Group, in the front end I have worked on JavaScript, TypeScript and ReactJS, in the back end it's a combination of Python, Django and Node.js, so I do have an extensive experience in JavaScript and currently I am working in a two set of pipelines, there is one which is around the fake media templates and it's, so basically I created a dashboard for them in the React and I have used the material UI components, now the back end is in the Node.js and so I have designed the APIs and then from the APIs I load the front end and there is another set of pipeline where I am working as an individual developer where I am directly taking the requirements from the stakeholders and then working on that.

Describe a scenario where an atomic operation in MongoDB is critical within an OGS application and how do you change that? Yes, so there is a scenario where an atomic operation in MongoDB is critical because at that time there are multiple operations running on the parallel so at the time I need to just do one operation because if I allow another operation so it will update the value so I block the another thread and I just achieve it using the multithreading and I say okay like we just need to perform one operation at a time and for the other it's going to re-run and there is for one which is for updating the records.

You are building a dashboard that needs to display a large data set, for example, 10,000 rows, okay. How would you ensure smooth rendering and efficient performance in your thread? Yes, so in case of 10,000 rows, so basically in case of large data set, what I would do is I would have a pagination. So in that case, you will, from the backend, on the basis of the current set of pages that I need to show, on the basis of that, I'll show, so for example, if it's only 500 rows at a time, so I'll make a query and then I'll take the 500 rows at that time and then when the person click on the next page at that time, I'll take the next 500 records. So this ensures that not all of the data gets loaded at a single go, but yeah, it's loaded in the form of the small data sets, right? And yeah, so this improves the rendering because we are not taking the data at once. And also in this case, now the images and always the asset size will increase. So in that case, I'll, let's suppose I have for a single page, there's a couple of different dimensions or layouts of images at the backend. So what I can do is I can just take, based on my screen size, for example, if I'm using a large screen, so based on my large screen, I can take the data instead of getting all the images and all the sizes. So this improves the rendering in the frontend.

Given this reactant component state management approach can you explain what potential issues may arise and how could it improve to consider best practices? Now I want to demonstrate an approach to a state management approach can you explain what potential issues may arise and how could it improve to consider best practices? Now here I think the problem could arise with the way we are fetching this.state.count because this is something like we are directly fetching the count. So, instead what we can do is we can take the previous count and then can increment it because at some point maybe if it is a stale of this state variable. So, we may get and up updating a wrong value in the set state and also the way we are counting the increment the increment count it is directly I see it is directly on the return it should not be equal. So, on the basis of click or something we should have this function call should not be called on a return because this will like repeatedly called it right. So, yeah.

In React, what do you say is essential for properly unmounting components that involve ongoing API request? What do you say is essential for properly unmounting components? Yes, so for unmounting we can make use of useEffect and inside the useEffect we can have a return function, so that will do the unmounting. And also, let's suppose there is some ongoing API call and we want to stop it, so we can make use of exears, so basically when we are making an API call with exears, exears help you stop the request immediately.

In this case, I think what we can do is, we can horizontally scale it, horizontally scale the React application, because, let's see, when we are horizontally scaling up, there are nodes and when we, so we can basically scale it whenever there is a request coming, instead of pointing it to a single node, we can point it to multiple nodes, right, so that it will improve the performance and this data volume, yeah, so basically this data volume, we are storing a lot of data, so this I think we can resolve via, so first of all, we can identify the issue with the Lighthouse tool, the React, the recent React application and then we can follow the instruction that Lighthouse tool gives us.

So yeah, for efficiently executing the queries in MongoDB, what you can do is, so now it's a complex query, right? And there is no relation as such in the MongoDB, so you can, so basically on the, you know, on the common, on the common filters, you can have the indexes and make sure you'll get it. So for, so with the help of indexes, how it helps is like it divides your, basically the rules into sub, into two, so that when you'll, when you'll search, at that time when you're writing the complex queries, it will not search in the entire dataset, except it will search partially, so it will search in half of the data, I guess.

Example of this jumpstroke function that is intended to return the new variable with each element's code can be identified any logical issues and improvements that can be made. Yeah, one of the improvements is that this needs to go to minus 1, otherwise we will get at the, we will go, we will go till the last and it won't come, it will be there, so it will be out of index, it keeps you out of index error. And another is like instead of just pushing it in the array, we can just make use of map, with the help of map, it's like it will automatically give you the array. So you need not to push this. Yeah.