Rakesh Sagar

So about me, it's about me, it's like, sorry. I went back. For instance, when you had a leverage book. So I was. So I recently went through this. So what we do in our project is we process emails, and the emails have subjects. And if you're doing any online purchase, we have items, and then we have totals that we pay for the bills. So when we process the email files and extract data out of it. So the email files that we were receiving had a lot of metadata or bad data, basically, with the subjects. And we identify our files through the subjects only. So in order to remove the bad data and clean up the subjects, I had to make an application which involved both Python and Java. So through Python, I downloaded all the files from the production to my local, and then I ran a utility which was built on Java. So that utility would clean up the email files or the subject. And then once the subject is cleaned up, we had to group the subjects together, their counts, and the dates in which they were received and all. And once that was done, a 1000000 records could be reduced to a group of, like, 10 subjects or 20 subjects like that. So I built a utility of that kind.

So to start with, as for single responsibility, basically we have to do whatever we are doing, like if we are making an application, which is an e-commerce application, so e-commerce will have different participants in that and let's say a participant is a customer, a participant is a delivery boy, a participant is a restaurant. One particular set or class should only represent one particular participant. So if I am making a class, which is for ordering food or ordering, let's say anything, it should have only order related data and when it comes to payment, a payment class should have only payment related information, both should not be mixed. That would be our single responsibility and O for open close means we should be open for extension, closed for modification. So if I want to add some more details to the order, I should be able to add it through some other means and I should not be modifying what already exists and what's already working. So it should be written in such a way that it could be extended and let's call it the substitution principle. Basically, if we do coding to interface, we should write code in the way of coding to interfaces. So if we are writing something like a car, and a car is an interface and it is implemented by say an auto, we should be able to put an auto into a car and we should also be able to put a polo into a car, and the things below it, which is like extending it or whatever is written to support, should not be broken. This is basically the principle of I forgot the extension or the abbreviation, but this is basically when we are making an object for something that is going to be used in my current class, we should not be passing or making the new object itself. So it should be passed as a parameter, meaning so that the two objects or two classes remain independent of each other. So it is basically the inversion of control thing that we use in Spring. I forgot the abbreviation, but it's for dependency injection. Okay, D is for dependency injection. The first one I said, before the statement I just read, is about dependency injection and we pass an object as a parameter to another object, not directly make a new object.

I'm not sure on this, I haven't worked on the AI models yet so as far as the microservices itself are concerned we could have microservices in different languages and that could work together. So all I can think of over here is inside a Java microservice we can call another microservice through a URL and that could do things we want to do, but AI models itself is not a familiar ground to me as of now.

so first up, an introduction of a new microservice should not disturb the existing ecosystem so basically it should run independently of the existing ecosystem and be a complete entity in itself and could be deployed in a separate server which could start communicating with the existing ecosystem through URLs and for the existing system, whatever communication happens, we should have a failsafe design so if the API call is not successful, then it shouldn't break the system or other APIs shouldn't get affected by it so when we are introducing a new one, basically it should be as non-intrusive to the existing ecosystem as if it was never present so the considerations I can make here are that I should just be aware of what APIs are being exposed by the existing system which I can use in my new microservice that I am going to introduce and I should have the documentation of the existing ecosystem APIs, meaning how it can be used and what things need to be passed to access the microservices in the existing ecosystem basically it's documentation I can think of that only

Then should you opt for monolith architecture or microservices, personally concerning Java and Springboard application, So I should consider a monolith over microservice if my maintenance means there are several things over here that need to be considered. So the first one would be the size of the application, and that means as the size of the application increases, it basically becomes hard to maintain and it becomes tough to deploy or maintain the application itself. If the first point to consider is monolith over microservice is if my application is small enough to be deployed and the damage on stopping the service should be minimal, then yes, monolith is fine, like we do in our current project. The second could be the cost related to microservices means, so if we are using microservices architecture, then we probably are going to think of the infrastructure where we will be using multiple servers, and then there will be different infrastructure involved in maintaining those microservices or monitoring those microservices. So those things come at a cost, then there will be minimal downtime, but then the maintenance means maintaining the logs or just going through the logs itself if something goes wrong becomes a little more challenging than what we can have in monolith, where it could be straightforward. Another reason to choose monolith is when it comes to the development or creation of the deployment, it becomes much easier for the developer himself because he won't have to go here and there and he won't have to think of ways to make the downtime minimal or for the failure to be minimal.

Private static service Public static service get service instance If service instance equals null Then new service returns service instance Service instance of service So what's happening here is it's not synchronized, it's not thread safe. So it could happen that a thread accesses the service factory and goes to the line 'private static service instance', and then it doesn't reach the next line. The next thread accesses the class and then it also sees the service instance as null, then goes on to initialize the service and then it doesn't return. Then it basically goes back to the first thread. So the first thread means now the service instance has been initialized and it's a static variable so the second thread will also see the service instance as initialized. The second thread has its service instance still as null, it will go inside and then it will try to initialize. So the service instance has been initialized by two threads and now there could be a conflict over here. Since it is static, basically there will be two instances which haven't been synchronized. The way we are looking at we don't want to initialize the service instance twice. So this public static service get service instance method, this needs to be synchronized, this needs to be made thread safe. Private static service Public static synchronized service get service instance If service instance equals null Then new service returns service instance Service instance of service

Given the java snippet below, can you identify the problem with the singleton design pattern implemented here and suggest how it could lead to issues in the multi-threaded environment? Okay, private static singleton instance for get instance. So it's again, I'm looking at the same problem as it was in the previous one. So since get instance method is not synchronized, it is not thread safe. So there could be like two threads coming in. One comes till the private constructor or private singleton line and then the control could go to the next thread and then it will come and we'll see that instance is not initialized. It will go inside the method, get instance, it will try to initialize and then the control, it will initialize the instance and then the control may go back to the first thread and then the first thread will also initialize the instance with new singleton. So instance will be initialized twice, which we are trying to avoid and so we should make it thread safe so that once it has been initialized, once the instance variable has been initialized, it doesn't need to be initialized again, no matter how many threads try to access this, it should get, all the threads should get the same instance of the singleton class.

So when we're talking about the microservices ecosystem and multiple data stores, a backup strategy for a microservice ecosystem that spans multiple data stores is needed. Having worked on the data protection ecosystem for five years, I could think of the easiest way is to backup each server where every microservice has been deployed, and each data store will have its own backup. So as soon as a microservice goes down, it can have a backup, meaning each microservice needs to be deployed in different servers. The number of servers depends on the size of the application, the might of the service provider itself, and how much money the owner of the application has, which determines how many servers they can access or afford. We can have multiple servers for one microservice, and for backup, we can have each server backed up in different places. For example, I had worked in an organization where all the data were backed up in at least two places in different geographies so that even if a disaster happens in one place, all the data could be restored. First, to make sure the application doesn't go down, we should have each microservice in the ecosystem running on multiple servers. If we have 10 microservices in the ecosystem, we should have 40 servers running, four for each microservice, and the data stores should have their own backup running parallelly. If one server fails, the others could be used as a backup immediately. Additionally, the data store itself and the server itself could be backed up in a different place, not meant for running the application, but just for backup. So as a server goes down, we replace it with a new server, copy all the data from the backup, and then we're back in business. There are different ways to think of this, but these are a few things we can consider.