Abarna Venugopal

Yes. Hi. This is Aparna. My name is Aparna. I'm a developer with 3 years of experience in building dynamic replication. In my recent role at Akash tech solution as a software developer, I led development of several key projects. One of them was my model PMS, which increased clients to over 100. I'm a fast learner who can learn quickly and adapt quickly to new technologies and challenges. I thrive in fast-paced environments and have good communication skills. My technical expertise includes VRGS, Node.js, MongoDB, Express, and Next.js. I'm excited about this opportunity because of the friendly environment and the strong focus on learning and development. Thank you for considering my application.

To implement REST API in Node.js, I'll use so we have solid and decent patterns from which we will have a definite structure for Node.js. We use Express. We can also use Express to create a free-form application, and we create routes and controllers, and we have common schemas. And we can use separate utility functions to make it more manageable. The REST API has a set of rules. Like, we can use HTTP methods like get, post, delete, and patch. Most of them use standard HTTP methods, which is why everything is a resource. So it has to be stateless. Every API call, we have to send all the required data without any dependency.

We can horizontally scale our Node.js application. We can use clusters. We can create separate Node.js instances so we can run it. So, it will be more scalable, and it increases the performance because we have a lot of clusters, and it can be created using forking. And so we can also use load balancing with a cluster from a Node.js application. It provides load balancing. So there are a lot of requests coming inside your Node.js application. So it will separate them and distribute the API. So your server should always be available, and performance is really high.

Mammalix, they are a concept that memory leaks can happen from using many global variables and closures. So we have to avoid this in order to improve our performance and optimize the ReactOS application. We have to mitigate them by avoiding the use of global variables and closures, like OSHA functions, which will cause memory leaks and also props filling. You don't have to send additional props or unnecessary props to a React component so we can improve the performance of the React application.

We can use JavaScript promises. Flip, JavaScript is even better at managing promises. Initially, we had callbacks, but promises were introduced after ES 6. We can handle synchronous tasks, for example, an API call. So, which is asynchronous. So, we'll get the data only after some amount of time after reaching the server. So, we can handle it using the promise provided by ES 6, and we can then use the then function, which also has some error handling. So, using promises, it's really easier than using callbacks.

To configure a secured API to include data transfer notification, we can use the standard HTTP methods, HTTPS, and add a prototype of HTTPS, and we can add SSL. So data are encrypted, so it will avoid eavesdropping from any other side. So, from attackers and all. Using HTTPS, and properly maintaining SSL, like we have to keep updating if the SSL is expired or not. We have to keep checking on it. And we should also use several methods, like stopping, we can use validations and we can sanitize the data to safeguard the API from attacks.

So in this snippet using a sync It will throw some errors because we are throwing errors in the situation. It is an asynchronous function. So, asynchronous functions are like promises. They are built on promises. There are sugar coatings on that. So, we are throwing some errors. They will be handled using the catch.

We are using middleware functions that have access to the request and response and next. We are just logging that request type, like, what method it is, whether it is a post or get. We can use middleware functions, for example, for authentication purposes where you are using a JWT example. Here, we're just logging which type of method is called right now so we can use it for loggers. And in Express.js, we can use middleware to access the request and response and next. For example, there is a default middleware, express.json, which just passes all the data to JSON in Express. We can access the response. We can also modify the request and response and call a function. Once the next function is called, the next middleware or the next API, which is any callback function that is set, will be executed.

In reactives, we can use the catching mechanism. We have catching from in the React Hooks, like you can use the use callback sorry. Use memo with memoizing any computed result. So it is a React hook that is provided by the React so we can use it for the dependency is the same. You don't compute the data again. You don't compute any function again. You can use the same data that is available. So if the dependency changes, it will execute the operation. You can cache the result, and you can use it for API calls. You don't have to call again. You can check the cache if the value is already existing. And if it is existing, you can use it. Or else you can make API calls.

We can use React whose hooks to handle life cycle events. Actually, React functional components don't have any life cycle events in them, but they have introduced React hooks to handle state and life cycle methods and functional components. For example, you can use useEffect to handle this. For example, we have life cycle methods of mounting, updating, and unmounting. For mounting, you can use useEffect with a function and an empty dependency. And for updating, you can use the callback and the dependency array with a value, like the dependency that has to be checked if it's updated. And for unmounting, we can use the return statement inside our callback of useEffect, which does the function of the cleanup methods in class components.

The libraries you can use in one project can be just I worked on just so we can use it in the post front end and back end. So I think it would be easy for understanding. I haven't worked on any other libraries like Jasmine and all, but I have worked on only Jest so I guess I will be choosing Jest because it can be used in both front end and back end to check how the API is working and I used it for unit testing or API testing. So how the page will respond for any given input and how the API responds for any given input.