Mahima Gupta

Yes, so my name is Marina, I have 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 extensive experience in JavaScript, and currently I am working on two sets of pipelines. There is one which is around fake media templates. So basically, I created a dashboard for them in React, and I used Material UI components. The back end is in Node.js, so I designed the APIs, and then from the APIs, I load the front end. 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.

I would ensure smooth rendering and efficient performance in my thread by implementing pagination and lazy loading of images based on screen size. So, in case of a large data set, for example, 10,000 rows, I would have pagination. On the basis of the current set of pages that I need to show, I'll make a query and take the required rows at that time. For instance, if I need to show 500 rows at a time, I'll make a query and take the 500 rows, and when the person clicks on the next page, I'll take the next 500 records. This ensures that not all of the data gets loaded at a single go, but rather in the form of small data sets, which improves the rendering. Also, to further improve the rendering, I'll implement lazy loading of images based on screen size. For example, if I have different dimensions or layouts of images at the backend, I'll take the data based on my screen size. If I'm using a large screen, I'll take the data instead of getting all the images and their sizes, which reduces the asset size and 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 requests? 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 abort signals, so basically when we are making an API call with abort signals, they help you stop the request immediately.

In this case, I think what we can do is horizontally scale the React application, because when we horizontally scale up, there are nodes and 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. So basically this data volume, we are storing a lot of data, so I think we can resolve this via identifying the issue with the Lighthouse tool and then following the instructions 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 MongoDB, so you can, so basically on the common filters, you can have the indexes and make sure you'll get it. So, with the help of indexes, it helps by dividing your data into sub-ranges, so that when you 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, instead of just pushing it in the array, we can just make use of map, with the help of map, it will automatically give you the array. So you need not push this. Yeah.