Parul Setia

Hi. So I have basically 8 years of experience currently working into, uh, throughout my career, I've worked on the back end side of things, like, mainly into Java server side. Currently, I'm working with a company called Netomi. It's sent to AI chat domain. Uh, so here I'm working with a team called platform and infra team. Uh, so, basically, what we have built is, like, we built some kind of a orchestrator to orchestrate the state of request. The tech stack I'm working on is, uh, basically, um, Java, Springboard, Kafka, Redis, AWS. Um, in AWS, it is, uh, AWS, SNS, s 3, uh, SQS, ECS, uh, Kafka, CloudWatch, EC 2, IoT. Yeah. These are the main service of the AWS which I work with. Like, the major interest area which I like to work is mainly on microservices and distributed system. Yeah. So this is basically about me. So I currently live in. And, uh, so I have been working, uh, have been living there for past 3, three and a half years. And, yes, I am very excited about the opportunity. Thank you.

I mean, Narrate an instance where you had to leverage both Java and Python to solve. Yeah. So there was a requirement. Though the functionality was the functionality of a feature was being done in Java. But to make it backward compatible feature with the uh, so so mainly, like, there were 2, uh, multiple versions of a feature, like version 1, version 2, and version 3. To make version 2 compatible with version 1 and version 3 compatible with version 2, We needed to have some kind of a database changes database table changes. Uh, so for that, like, what we did, we got some kind of a Python script. So that script, basically, what it does, it it used to make a connection with our database, and then it will change the certain rows in particular DB. And then it will update the rows, and it the only thing the script functionality, which was written in the Python, was to make a connection with DB and update your rows and make it compatible with your version 2, uh, where earlier the it was only compatible with version 1. So that is the experience.

Can you describe how you apply solid principle in a Java based microservice to improve maintainability? So, yeah, so in day to day life as well as whenever there is a new feature requirement, there is active development of features, which is, um, which is required. So to make that feature, uh, the development is more extensible, so we try to use it as far as much as, uh, solid principles and design veterans into it. So how we did it, like, first of all, if it we are dealing with some kind of models, we all the operations related to our models or all the operation related to the model service, uh, they are into one class only. Then the next principle, it suggests, like the first principle was a single responsibility feature. The next is, like, open for modify open for, like, extension and close for modification. So I implemented something called as a strategy pattern where there were different kind of a strategy. So if I want to add a new strategy, I need to only extend only a class and add that strategy would be added and only add one of the possible strategy onto my factory class, which will initiate that particular strategy. Uh, and then, uh, you can you are not allowed to modify your existing any strategy. You can uh, only extend it. So this scope principle is applied where, like, there was a requirement where, um, I, um, so there was a requirement. There was, like, one interface, and then there was a class, uh, parent class. It had, like, multiple methods into it. There was another class of the same type, but it only extended only one type of a class. It did it didn't, uh, in the interface. Like, it was, like, 3 or 4 methods, but only one method the, uh, the child is lost of type to lead it to support. So in this case, like, uh, one approach is, like, to throw implement all the methods and throw kind of a null response. But here, we didn't throw, like, a null response because, um, so, like, what we did we do is, like, rather than throwing a null, we pass some kind of, uh, either custom object or pass some kind of optional response. Or, um, then wherever possible, we also created some kind of interface to support that functionality so that I should not return null as a output. Then, uh, apart from other, like, interface segregation is, like, I try to make all the methods, uh, as a interface first and then the class which is implementing that those method can implement that particular interface. Uh, so this was a brief about interface segregation, about dependency injection. Normally, we are using a spring boot application. So we are auto wiring our dependency at several places in a form of, uh, in the form of a constructor based injection. So this is how dependency injection is being supported.

So what we did is, like, we use a sidecar based pattern design pattern for this. So there was a utility, like, there was a masking based utility. The the the utility feature was to mask the logs mask the logs according to your user user information. Like, for example, the user mobile number or email has had to be masked. So what it is, we created some kind of a sidecar, uh, a utility, uh, and then the internal communication would take place via gRPC. And then Python and, uh, your Java code was bundled into one kind of, uh, package and then was deployed.

Why Python tools and frameworks would you employ for monitoring and logging the frameworks? Would you employ for monitoring and logging the health of a micro? So how we did it now was always to expose some kind of a health checkpoint, and the load balancer, like, pings to that health checkpoint, and then we can know the health of our microservice. Yeah.

In a centralized logging approach for microservice that aggregates login of searchability. Uh, so this can be done via your sidecar pattern. Um, so, basically, so there could be, like, different kinds of, um, um, so there could be a sidecar which is responsible for logging purpose. Uh, like, if you want to create a centralized logging approach, so what we can do is, like, this, uh, Sidecar will push these logs in a sync way to, uh, centralized app, which will then receive, um, in a sync way and then log it. To search the log, like, we can have some kind of a search inverted search based engine such as Elastic, um, where your logs could be indexed based on your service. And moreover, you can enable your text based semantic spec searches.

Sam, in the following Java code, it is intended to lazily initialize an instance of a service. Can you explain what is wrong with this code and what could happen in multiple threads for a quick test ticket service instance? So I think in this instance, the your your so there should be a synchronized block, uh, and then there should be a double lock kind of a check to support, uh, this this is this basically is a singleton pattern where you are lazily initializing your object. So what we can happen add is, like, add one more kind of null check and then add, um, a synchronized block here.

Review the block of a Java code for the restful channel support. They should have might arise from the exception handling as how this could be potentially compromised the web service reports. Yes. When the exception occurs. Okay. So, um, here, like, what you we are doing is, like, we whenever your exception is thrown by your service layer, it will be catching on your controller layer and then internal server is being returned. Okay. It's called the issue that might arise from the exception handling and suggest how this could be potentially compromised to your service robustness and exception. So, basically, we don't know here at which point the exception has occurred, uh, and we are only returning, um, you are we are only catching the exception and returning internal server error. But we are not logging any exception and all, logging any stack trace and all. Uh, so we will not be able to catch our exception, like, what occurred and all. And, also, like, yeah, I think the re one thing is sure, like, we could have recorded like, we could have logged this exception. Yeah. Also, like, there could be, like, different kind of a run time exception which would occur. Then at this is our run time exception. What you are trying is, like, an internal server error. Okay. Yeah. Possibly, like, what I think should there there should be log statement which by which we can know, like, uh, what is the exception.

Device a matter to ensure consistent data across multiple microservice handling persistent data. Device a method to ensure that consistent data across multiple microservices handling, uh, persistent data. 1 is, like, uh, to ensure a consistent data. Like, one thing is, like, use a way, uh, something like as a distributed transactions for it. For example, your saga or, uh, choreography method, which is used. The other is, like so whenever we, um, one of the transaction like, one of thing fails, like, there is a rollback on every step. So this rollback will make sure, like, you are having your consistent data, and your transaction will either get complete or there will be a rollback for, uh, this. So at the end of the distributed transaction, your transaction would be consistent state. The other way is having some kind of a 2 phase commit scenario. So with 2 phase commit scenario is, like, a little difficult to implement and your if your 2 phase commit scenario fails, then your data will be in an inconsistent state. So the better thing is, like, having some kind of a soccer veteran or sync way, which where if your application also failed, um, the data gets stored, which has to be all bad or it has to do transaction in your Kafka. And, eventually, when your application comes up, like, your either your old back or your transition can continue from there. Yeah. Thank you.