Amit Gupta

Hello? Okay. So, Shadi, What would be the approaches that you take there? Optimize query in SQL. So if I'll talk about what what approaches I'll be taking in optimizing query in SQL. In large datasets, it would be like, firstly, in our I'll be looking I'll be looking for n plus one query problem. That would be including, uh, that would be not including, uh, that would be not including, um, uh, multiple database queries that needed to be updated over there by using, uh, includes over to remove n plus 1 query. To when working with large datasets, consider limiting the data. These queries written via window functions or pagination. Window function can group, uh, aggregate, and limit datasets. For example, if I'm taking about the sales and there are millions of rows, so so 10 records per rate would be quite clumsy over there. So that would be helping that would have, uh, that would help us in that particular manner. So if I talk, uh, if I talk about fall into 2 categories, waiting and running, understanding the differences for crucial optimization problems, that would be one point. The running query actively uses system resources, including the CPU, memory, disk, uh, something like that. Yeah. Uh, awaiting query will wait for another query to finish for system resource to become available. That would be a quite difficult problem to face and to make it resolved. Running and waiting queries can both impact our database performance. Waiting queries waiting queries, uh, waiting queries can block other queries, slowing running queries and response time. Optimizing both of these type of queries will help in improving SQL performance in large datasets. That would be indexing would be one of the major crucial issue that we need to look over because indexing will help us to get the the performance of an API to be get improved and to have a better SQL indexing, uh, literally play critical part for improving that SQL query performance. On last, it will create pointers to the data table, accelerating data retrieval over there. Indexes are handy when they're dealing with large datasets, and they help data point where the query should search the information by reducing the amount of data, uh, and where you must have skin. Right? However, creating indexes on all of the table column isn't always the best solution, uh, as it's essential to identify and then create the missing indexes or fix the correct ones. You can use execution plan like SQL Server Management Studio and or one of the most important and the most, uh, trending would be Azure Data Studio to provide running by the query. And this execution of indexing warning will fix what will be the issue that we are facing, uh, to make the API a better a better performance, uh, to increase its performance.

Okay. So if I talk about if I talk about the feature that you if I talk about the feature, uh, to deploy utilize here, could deploy a large scale application. So if I talk about the instructions, we can create a Google account at first, then we can just install then we can just install whole put a tool kit on our computer. Uh, it would be in the terminal. We can log using the email address or password we are creating the group work on. Uh, then we can just, uh, we can add a PGGM or SQL live jam for the same. After that, we need to ensure that what are the issues that we are what are the issues that we are facing over there. If we are facing any error, then we can just update our code database dot y m n and, uh, and for the production environment, then we can add our code and create the commit for the same. Then we can use a command who are to create, and then we can push it to heroku.me. So in this way, uh, in this way, we can just move forward with the Horoku for our applications. But if we talk about, uh, if we talk about what would be the advantage or advantages for the same, so it would optimize or remove any long or long time consuming queries. Really reduce the number of queries by rewriting them, uh, rewriting them to the application to make it fewer queries that would be one of the greatest advantage. It would be optimized to configure DB connection pooling. It would be optimizing active reports connection pool, implement, uh, implement implement or optimize BG bounce, so that would be one of the major, uh, major, uh, issue major resolve for the same. Ensure our database is properly indexed. Configure, uh, read only, follow database, and use follow appropriate. Ensure data backups are configured into run p cards. That would be, uh, that would make most important. Uh, who who may who may focus on decreasing application throughput, decrease the application response time by 95 percentile. It would be by upgrading Ruby to the latest version, reduce throughput request to the application as search cloud cloud management. Uh, it would be cache a extensive calculations or queries on the server and memory in Redis or in edge server of the client. Optimize the web server, it would be by testing, uh, test multiple human configurations, including multi setting and multiple process for the combination. Uh, we can ensure any external API, uh, request client or address aggressively time out configured for the same. And it would be, uh, one of the one of the other and one of the other main example of Haruku, one of the other main, uh, what it should be said. Another main advantage of Haruku that it would be, uh, it would be after deploying a real application only, the next step would be to put it online. So just mentioned and made it very easy for us so that we can just deploy that application, uh, by just in few steps.

Okay. So if we'll talk about if we'll talk about, uh, testing strategies to ensure or testing strategies to ensure m v c components and create correct ajix call. So my answer would be, like, uh, unit testing for complete the detailed strategy would be unit testing for components. Like, we can use react component test, utilize testing, like, uh, libraries like jest and enzyme to test individual react component, ensure that the component renders correctly and behave exact as expected. Like, it would be a controller test test, a controller logic to verify the correctly handled state and props and interact properly with the text calls. And if we call it over, we can also use integration testing for the same. Uh, we can use mocking libraries like fetch mock or adjust into build mocking capabilities, uh, to simulate Ajax calls and to test how components are handling each other. It would be like we can use test component interactions over there. Uh, it would be a test how different component interact with each other, especially in passing data through props or callbacks triggered by AJAX calls. It would be one of the most important call would be e two way testing by testing, using testing framework, uh, employ frameworks like Cypress Selenium for e two way testing, Now right test that simulate user interaction with the application, including the agents, and verify it, uh, and verify the UI behaviors correctly. That is the most important part. Other than that, we can simulate different response and test how component handle various responses, success, error, failures, time out from agent calls to ensure robustness and proper error handling. Yeah. Uh, then we can go to a when then we can go to performance testing. Evaluate Ajax performance with one of the most important criteria by measuring the performance of Ajax request and component rendering tools using, like, uh, Chrome driver or Chrome Dev Tools, identify the bottlenecks and bottlenecks of performance, uh, issues to optimize it accordingly. And then we can, uh, we can look over continuous integration, continuous deployment that would be CICD to automate testing, integrate testing to CICD pipelines to automatically run, uh, whether the code changes, uh, are made or not. So this will ensure that this will ensure that the issue of agent functionality are detected early in the development process only. Uh, so, yeah, in this way, by implementing all these testing strategies, we can ensure that, uh, the MVC components of React, uh, React or components can just, uh, interact correctly with AJAX call, and that would be helping us, uh, that would be helping us for improving our testing strategies.

Okay. It would be how will be how will be designing a react front end to consumer raise API ruling, uh, using restful practices. Okay. So if I'll talk about this, uh, so in this particular question, uh, regarding, uh, regarding this testing the application, regarding testing the application, we just need to set up a react project as of now. Firstly, we'll be setting up react, then we'll be installing then we'll be installing the dependencies for the same, uh, making STP request in react such as axios and the native edge API, then we can just, uh, we can just create components. Like, we can, uh, we can design your React components to represent different part of the application such as resources, uh, example, user, post, form, something like that. Then we can define routes for the same using a route level, like, react router, define routes, uh, to navigate between different views of the application as the route will have a major purpose to when any p when an API calls. So it will go through the controller, then the controller will go through the model, and the model will manage all the basic logic. Then it can go back again to the controller, and then to the controller, makes it go to the view. So controller plays a major part, uh, in between handling the, uh, handling the business logic and to showing it in that in the UI. So that would be the most important routing book. Then we can just fetch data from real safe data, utilize the effect of using componented mount life cycle, uh, method in the components to make the s t t p request in your sales application endpoints. You can follow restful conventions for naming your API endpoints such as users, retrieving the data for user by users or user ID. So that would be one of the important part. Then after that, we can just handle the responses from your Rails application appropriately in your React component by updating the component state with the retrieve data or missing in the request phase. Yeah. That would be one of the important point. Then we can implement the current operation. One of the most important thing that need to be implemented in any of the APIs that we are developing so that, uh, we can have every single action in the HTTP request to delete a particular object to create or to edit the same. We can handle authentication authorization. If the rails API requires authentication or the authorization implemented mechanism for handling, uh, user authentication or authorization, so we'll be working out accordingly for the same, optimizing the performance optimizing the performance, uh, of your React application by implementing techniques such as medium, lazy loading, uh, component memorization, and pagination for large datasets. That will most one of the most important thing need to be done. Deploying your application or the app content rails by boosting a platform of your choice, ensuring that they're accessible to the users. By following these steps, you can design a React front end that can zoom rails API for, uh, restful practices to get an

Uh, efficient API performance over there. How can you define restful how can you define restful, uh, things in rails? So if I talk about this, uh, we can discuss the restful principle about applying to rail routing would be like, uh, by using resources over the the resourceful routing the critical component by the heading a restful principle. The rest of it stands for the percentage of state transfer is an architecture style that defines a set of, uh, defines a set of constraints for designing, uh, network application. Restful APIs are built around these constraints only, and they'll provide robust support for building restful APIs throughout the system. Uh, this is how it works. Uh, resources oriented routing would be one of the most important point. Uh, restful APIs are concerned centered around are centered around resources only, which are the key entities, uh, that the API exposes. In in range, resources are defined using the resource keyword, a resource method in the config dot routes. This method set up the conventional routes of prod, like, uh, create, read, update, delete for the same for opening a resource. And we'll talk about we'll talk about name, routing, path helpers. So rails provide name, routing, path helpers to simplify routing and generating URLs. These help us following RESTful API configurations to help and clean a readable way of generating URL in viewing it in the controller. Uh, nested resource uh, nestful resource. In RESTful API, resources can be nested within one another to represent hierarchical relationship. Rail support nested resources, uh, through the resource method within a block. Customer routes can be set up in rails, while risk full API primary line conventional routes. Generally, by resource resources method, rails allow redefining custom routes by handling noncredit operations on special purpose. Uh, custom routes should still follow restful principles and, uh, use appropriate HTTP words verbs and resourceful meaning. For example, if we'll talk about by following these riskful principles and rails routing, we can develop and build a structure predictable API, which is to understand and maintain, uh, maintain by the developers who will be working on a particular project, or it would be uh, at any moment of the development cycle.

Okay. So there will be good intended to handle a service execution. Explain what code, uh, does, how it could potentially fail at certain errors. So, okay, let me look at the code for my for my end. Okay. This would be the code. Okay. Okay. The code begins by the this code begins by attempting to execute a service using service dot execute. Right? If a service, uh, if a service service error is raised during exception, it can it is rescued a message indicating that the service error occurred along with the error message of type. If any other type of error is dated, not specially service, uh, former service error, it is rescued by a second rescue block in case a message indicating that unexpected error occurred along with the messages printed. Right? So while this code provides a basic error handling, there are some potential issues with it. It would be lack of specificity. Uh, that suggest that means catching all the errors with rescue can make it difficult to differentiate between types of errors. It can lead to improve, uh, this can lead to improper handling and masking of critical errors. That would be a major issue. Like, the second one issue would be putting, uh, potential offer, uh, swallowing errors. Uh, like, depending on how the error key error raised, keyword is used within, uh, within the second rescue block, it could potentially swallow the error within, uh, proper handling. It lead to unexpected behavior and lack of visibility of errors. To improve what we can do to improve this particular we can use specific exception classes for each type of error that can occur. We can ensure that the error message are informative and provide can test by debugging it. We can also avoid, uh, we can also avoid overly broad rescue blocks to prevent unintentional masking of critical errors. We can handle errors appropriately based on their service and impact of their application. So, yeah, these can be the major points that needs to be local and that can be improved in this particular section to, uh, make this thing better to work with.

Okay. The next question again would be at b and rails course that needs to be checked over here. Okay. So if I'll go through this one, uh, before action filter, and it would be performing the action to introduce the same. So before action filter, Ruby All Rails is used to execute a method before certain controller actions are called. Yeah. That's clear. It's commonly used for tasks like authentication and authorization for data loading data loading that ensures that the task are performed consistently before the association actions are executed. Right? So in the provided code snippet, we are having a before action required and only new and create. This filter ensures that the required admin is called before the new and create actions in the controller. So potential issues with this particular thing would be the order of filters, the order in which the before action filters are defined matters. Filters are executed in the order that they are defined in the controller. If the find user if the find user filter relies on the current user being said, it should be defined after by after any authentication or authorization filter, are, like, required. It would be, uh, of the the other issue that we can find in this would be authorization. It would be it requires admin filter restricts access based on the admin status. Uh, depending on the application requirement, it may be necessary to further, uh, refine the authorization logic to ensure that only authorized users can perform certain actions. Uh, the other main thing, uh, is would be error handling. There is no error handling provided in the find user method. If the user with the specified ID doesn't exist, active record and ground call not found exception will be raised, which could result in an error rate being displayed to the user. It's important to handle such scenarios gracefully, perhaps surrendering a page or redirecting to an appropriate location. By addressing these potential issues, we can make the application more robust and important and, uh, clear to work with.

It would be the other question would be? How would you apply object oriented programming, which are the refactor, the Ruby on Rails services, service object. So refactoring Ruby on rail service object, uh, using object oriented programming principle involving to restructure the code to improve the organization, readability, maintainability, and adherence to OOP principles such as encapsulation, emittance, polymorphism, and abstraction for the same. Here's how we can do using encapsulation. Ensure that the service object encapsulates single responsibility to our task, encapsulate data and behavior within the service object, limiting external access to only what is necessary. It would be single responsibility principle would be one of the most important data I skipped. So that would be SRP, ensuring that the user object has a single responsibility or reason to change. We factor the service object to perform only the cohesive task such as handling a specific business logic, operation, or interacting with the external service. That's most important. Like inheritance and polymorphism, identify the common behavior functionality shared among multiple services object. Then, uh, using that particular then we can defactor common functionality into a base service object or module to promote code reuse through an edit and call composition using polymorphism to allow different service objects to implement variation of shared behavior while adhering to common interface. Abstraction. Abstraction of the implementation, details that are not relevant to the service object, interface, or consumer. We can hide, uh, complex, uh, complex implementation logic behind simple and intuitive interface to make it easier for to use and maintain. Dependency injection. Defactor the service objects to rely on dependency injection for its dependency. That would be one of the major cause, uh, major things to be looked at. Injection dependencies such as database collection, external services, or other objects into the service objects, uh, constructed or the method parameter rather than creating them internally. It would be, uh, this most important would be, uh, testing. By unit test for each component, uh, of the service object to ensure that the way they behave and expect an isolation. More custom dependencies in test will isolate the behavior of the service object and promote faster and more focused text execution. So by applying these particular hoops cons uh, by applying these particular hoops concept, we can ensure that the issues that we'll be facing would be

How can you highlight techniques for ensuring JavaScript for poor quality improvement during ROR? So yeah. What let me frame it. If I talk about ensuring the things in ROR, Ensuring JavaScript good quality code is crucial when developing an ROR application, and JavaScript often plays a significant role in ensuring user experience and interactively on the client side. Here are some techniques. Linting. Linting would be one of the most important techniques, which will just simplify which will make us to look the code more simplified using a JavaScript landing tools like ESLint to enforce coding standards and identify syntax errors to detect potential bugs. Integrating AS link into a Rails, Ruby on Rails application will process to automate, analyze JavaScript code as a part of development workflow. Code formatting, consistently formatting JavaScript code using tools like Prettier to enforce a consistency coding style for the same. Modernization. Organization JavaScript put into modular components, uh, into modular components following best practices like modern patents, e s 6 for component based architecture side, encapsulate the related functionality into separate models or a component to promote reusability and maintain ability of the test. Testing. Writing a test by integration by integration test or for JavaScript code using framework like just mock up would be important, uh, by more and the most important would be error handling, uh, implement error handling mechanism, uh, improving error handling mechanism, uh, into a JavaScript code by gracefully handling run time errors, exceptions. Yeah. We we can use try and catch block for the same for error bound with the impact application and error logging libraries to catch and log errors by debugging and monitoring for purpose. Performance optimization in JavaScript perform by minimizing the DOM manipulation, building unnecessary renders, utilize performance, profiling tools like Chrome DevTools for the same, uh, for security, uh, for by by increasing the by increasing the security, we can remove the track like CSRF, cross site recurs forgery, and some injection attack. Sanitizing the user input, uh, validate data on client server side, implement proper security, hide those protocols to protect again data security. By keeping this thing in proper documentation, we can just have a look over that these are the functionality, these issue that we are facing and can resolve in a quick moment of time.

How would you leverage AWS Lambda in our application? So yeah. If I'll be talking about managing AWS Lambda in my Ruby on Rails application, So that would be quite different process to look over, uh, to improve the performance of Ruby on Rails application without managing servers. You can offend you can offload specific task or functions of AWS Lambda functionality, allowing them to execute independently and scale automatically based on the demand on how you can utilize Lambda to enhance the performance of our application. By it it would be the first thing we can do, we can identify the performance bottleneck. It what would the issue that we are facing with the performance? Analyze your ROR application to identify specific task or functionalities that are performance bottleneck and can benefit offloading of AWS and the uh, we can define Lambda function to to perform and identify the task or functions independently on your other application. But we can also write under functions in a supported language such as Node. Js, Python, uh, as Ruby is not currently supported directly by AWS lambda. Even trigger we can trigger the events, configure even triggers to invoke the lambda function in response to specific events or triggers, uh, within, uh, any other application security services. Integrating the other application into Lambda functions using by invoking them asynchronously and synchronously using AWS SDK for Ruby. Use AWS SDK to involve to invoke Lambda function directly from your Ruby on Rails application, uh, passing input parameters and processing the result as needed. Yeah. That thing can be done.