Ramanuj kumar

Hello. Good morning. This is Ramanuj. I have around 7 years of experience in the IT industry, and I have played the role of senior software engineer.

Project management system, contract management system, and others. I've used languages such as C#.NET, VB.NET, S#.NET, and SQL Server, JavaScript, jQuery.NET Core, and MVC as well. If we have all the documentation and everything in place, and if we're unable to develop it and receive all the support that's needed, then I think we should be accountable if the project fails. Other than that, I think if everything is in place – documentation, proper planning, proper requirements gathering, and the proper setup needed to achieve the clear goal – then I think it can be achieved.

Views are virtual tables and the data is stored virtually, it's like data is not physically stored there. And functions are the routines that must return some value, one value. And stored procedures are SQL saved pre-compiled statements. So we use views to fetch the data from 2 or more tables and keep it temporarily. And functions, we need to write if we need to return some value, then we need to use concerns. Whereas stored procedures, we use stored procedures for writing the select statement, writing all those statements whether we are joining 2 or more tables. We are writing the queries. It's like subqueries, correlated queries, and more. Alright. So, it's like a function can be called inside a stored procedure while a stored procedure cannot be called inside a function. And views are of two types. One, which we can store the data physically, that is materialized view and, other that is a virtual table, so we cannot store the data physically there. It is virtual. A stored procedure is very broad, other than two. It's like, we can use, for security purposes also, we can use inside it triggers and use functions, anything. And for security, we use a stored procedure while we cannot use functions for security purposes as compared to a stored procedure. While views can be used for security to some extent. Yeah. So we can use the deal and the email statement in the stored procedure.

First of all, we need to focus on the data, what we are going to validate. Right? The requirement for a clear picture is what we need to have clear. So, what are the sources we have used to collect the data. Then, after that, we need to determine if the source is legitimate. To analyze it again, we need to confirm the sources we are referring to. So that, it could lead to 100% accurate results. And we need to double-check the data that we are going to present in a meeting. So we have to speak about whether this is the correct data or we are taking it from a specific site for the data, or we are presenting the data because we are accountable for the accuracy and reliability of the data. So we need to verify it from various or different panels. Different sources. I think this will help to validate the accuracy and reliability of the data, and we need to analyze it thoroughly.

Yes. Yes. We have used the I have worked with PVPI and used the Razor templates. So, if we are writing the Razor, then we are writing the CSAP and the HTML code, moving the code in parallel. And to present our UI, we can write the result templates. And actually, what happens is that BVPIS is used to return the data while MBC is used to return the views. Alright. So to show the views, the data we have collected in the present year earlier, we can use the result template. Yes. We have used the Razor templates frequently to present our UI or to showcase our data, building web pages.

The best practices that we need to follow or have followed include various design patterns, right. We need to follow the repository design pattern, singleton design pattern, and mediator design pattern. And we also need to follow the principles of SOLID. Like, right, it's like SRP, single responsibility principle. O for open close principle, L for Liskov substitution principle, I for interface segregation principle, and D for dependency inversion principle. Now it's like, we need to understand the scenario on which to apply so that our project, when it grows bigger, does not get any hurdles on the scalability side or the performance side. Right? And we can scale it better. So one example is the code we've written. Next thing, we need to add more functionality. And we need to add it without breaking some code. Alright? Or it just has the previous part that we have written to implement the new features, then it's very dangerous because we would not be able to maintain those applications. Right? That's why we use SOLID, and it has a lot of things that we cannot complete in 2, 3 minutes. It's like a lot of things are there in the SOLID principles. And we can also use various guidelines, like, for naming variables, classes, and other things. Right? Means we need to follow all those guidelines whether in the kernel case or in

Yeah, so we were working in the team, and the team members asked me for some code and some help. So he was not in my team, but yes, he was sitting with me. So he asked me to write code for him. And I had the time, so I wrote for him. And it worked. So he told me, "Thank you." Right? These are the things we need to do if we are not responsible for writing the code, even then the juniors ask, then we need to help them because we are working in a team, so somebody is helping us. So we need to help others if we have the time. And we need to provide suggestions and guidelines to team members and other people also if they ask me. Because we are social human beings. So it's like and it worked fantastic. Many times, it happens that some juniors ask for some advice or some code. It's right to help them. It happens.

To choose between an abstract class or abstract functionality, we need to see what our requirements are. Alright. So abstraction can be achieved by abstract class encapsulation also, and interface also. So let's understand that if we have some common things, we need to put it on the base class so that the derived class can access it. All the common things, we put it in the abstract class, and later we can inherit it into the derived class. And also, we cannot make an object of the abstract class. So we need to inherit it. And after that, we can use the functionality of the abstract class. So, can you explain the approach to this ID? There is something. It's like let's take an example: there is one company. In one company, there are multiple employees. Some employees are on a contract basis, and some are on a permanent basis. Right? So let's say every employee has some common properties. Right? It's like name, designation, and age. Right? But the salary or the type of time that he works can be different. So we can manage that. Understand, please, take it that the example I've given could be the common things that we can put into the abstract class, and the rest, like permanent employees getting a permanent salary on a monthly basis, and on the other hand, contract basis employees getting paid on an hourly basis. So the function would be different for both types of employees. Right? So, all the common things

Can you explain the delegates and events? So, delegates are function pointers. They can point to different functions. Let's say we have created a delegate. We can point multiple methods to it, and we can take work off of it. Events are like actions. We create an event. When something happens, like a button click, we want to get the data submitted or anything could be, depending on the situation. So, an action happens, and the event is triggered in the system. It can be a postback or a post web request. It would be used in a main project for submitting data or a click event. Abstract classes are like we put all the common parts in them. But, what happens is that we have one incomplete abstract method, and one abstract method must be there while one complete method could be there. An interface is like a contract. We only declare the methods and properties, but we cannot define them there. We need to inherit or implement it into a class and write all the code. An interface gives more flexibility and more security.