Anshul Jain

Hi. Myself Anshul, and I am working as a engineering manager with Expedia, and, I am having good experience working on the microservices architecture in the distributed ecosystem. Also, I have good knowledge on Kafka. But tech stack wise, I am well versed with Java, Spring Boot, REST API, and, Databases, I'm having, uh, good experience with relational no NoSQL NoSQL like Mongo Dynamo. Yeah. That's it about myself.

What apologies would you use to monitor and auto scale Java application within a Kubernetes ecosystem? So in the Kubernetes, there will be ports. So what I would be very much interested to know is the CPU or the memory usage of these pods. If the CPU usage is exceeding beyond 80%, Might be that is a good point wherein I can spin up a new board. Or if my memory usage has reached 60%, That is the chance that is the point when it where I would definitely looking out for a new port in my Kubernetes. Right? How would I monitor these? I can use some metrics which would be emitted for okay. Like, what are the CPU and the memory usage for these ports. Right? So that could be monitored.

How do you prioritize features when designing restful APIs following the best practices of API evolution? So prioritizing feature would be, like, first of all, I would plan the MVP, which is the minimum viable product for an API. Let's say if we are building an API, which needs to comprise of in functionalities at the core level. Right? So I would be releasing a versioning for the same, but this would be a version v one. And any subsequent features which I'm adding to these APIs will be made in order to so that the clients Do not break. So I will be ensuring that there is a backward compatibility always. And, uh, maybe I would select a URL based versioning wherein I would have different different URLs for the new versions which are released so that clients can adapt to their needs if they want to utilize their feature for the next version.

What techniques do you use for managing state in serverless architecture on AWS Lambda? I would prefer to use a distributed cache, a kind of a key value store in order to maintain some sort of a state in my serverless architecture. So this distributed key value pair could help in maintaining the state. And, uh, definitely, I would prefer some sort of a consistent hashing so that I can have my nodes getting added to this cluster or they can be removed. Plus, I would also ensure that these are highly available so that I will be replicating these nodes. And, uh, I think the distributed cache would be good enough source in order to maintain the cache since it is highly available. And definitely, we will be using the sharding in order to select which node the data should be pointing

How do you apply the Solid Design Principles to improve the deployment process using CICD tools? Solid design principles are in, like, Uh, Solid, list cost substitution, physical interface aggregation, dependency inversion. So these concepts can be applied to the deployment process. How will I apply these design principles to the deployment process? So definitely, I would be for c I means the build part and the CD means the deployment part. Right? So these chunks needs to be built in such a manner so that Once the artifacts are built, they are pushed to s 3. And then from there, it is getting picked up for a deployment. Right? This is where the how the dependencies needs to work across. That needs to be figured out. And then all of these are separated as a Stunk wise pieces, wherein okay, like this particular piece is responsible for building the solution. This particular piece is responsible single responsibility would be, uh, just running the unit testing part in order to ensure that we are having a good code coverage and all the test cases are passing fine. Then there is gonna be a separate module for running the integration tests. So all of these needs to be done in a sequence and they can have a clear cut dependency based on whether the earlier step has run successfully or not. So this is why I think we can apply the Solid Design Principles even to improve our deployment processes. What whatever CICD tools we are using.

What would be your approach to refactor a large codebase from Java to Scala, ensuring minimal downtime and performance impact? What would be your approach to refactor a large codebase from Java to Scala? Ensuring minimal downtime and perform callback. First of all, I am assuming that this codebase is exposing some sort of a REST APIs, and we can target we need to, first of all, modularize, like, how which 1 modules will be going for the 1st iteration then the next iteration. Right? And the experiences of each and every iteration needs to be applied onto the next one. So let's say we selected 1 of the API which we want to migrate from Java to Scala. Right? So we will have all the the same API available by the Scala code as well. And we would have a top goal kind of capabilities where we would be switching from the old code to the new code. And then if we figure out there is issue in the new code, we can quickly fail over through the old behavior. So it could be we can use a blue green deployment or canary deployment, any sort of a deployment in order to ensure that whatever migration is happened, that is performing fine. Right? So this could be one of the and, uh, even before launching, right, we would also ensure that whatever test cases have been written, These test cases still operate integration test cases still operate and give the same results even when we have moved to Scala. So this will be my approach to refactor a large code base on, uh, module by module basis in order to ensure we are not, uh, bringing a new good amount of downtime and any performance impacts. We would we always be doing their performance testing p 99, p 95 numbers order to trace, okay, like, how much time each and every API is taking for us with the new migration as well.

Here's a simple Java code snippet. An error occurs when trying to execute this code. Can you identify the problem and suggest a solution? So in the main class, we have the main method. We are initializing our Interim to null and then we are trying to so we have a value type int and then we are assigning null to the value type. So null can be only assigned to the reference type. So, uh, in a value type, we'll be expecting a number which should be assigned to that number. So I think, uh, we can't assign null to a integer value type. Either we can fix this with the reference type of boxing it to integer, capital integer.

What is your strategy for data partitioning in a distributed system to optimize performance and availability? So we need to formulate the strategy for how do we want to partition the data in a distributed system. Right? So we need to select our sharding key, partition key, so that the data should be landing into the correct shard always. Now how do we select this partition key? Right? It should be a unique so that whenever we do a hashing on this key itself, we should be able to get which node In our consistent hashing, the shard which shard of the cluster it goes into. And, I think, uh, we need to ensure while selecting this partition key so that the data is evenly distributed across all the chart. It is not that okay, like, All the data for this partition key, the the way the partition key is getting created, all of the data is landing up into 1 single node itself. Right? We also need to ensure that we are not there will be times when the partition key will be hot, Wherein that traffic for a read traffic would be more on one particular type of a node. So this can be avoided by ensuring that we are replicating the Sharded nodes in order to ensure that the read traffic is some from the read replica rather than the same cluster node itself. Right? So this will be my strategy for ensuring the I'm meeting the performance so the data is evenly distributed and availability by replicating the data so that It is always available highly available.

Be hard. How do you design a release process to smoothly transition from a legacy system to a new Java's Kala service architecture. So I'm assuming that legacy system would be some sort of a monolith, and the new Java's service architecture would be, uh, API based architecture or microservices based architecture. So how do I design a release process? Release process needs to ensure that none of my critical pieces are breaking. As in these systems are already in use by different client, there is an adoption. So the clients should not be impacted if we change anything from legacy to a new Java architecture. I think the best example would be identifying the core functionality of the modules or the single responsibilities of each and everything, and then be able to expose these by the new architecture? And then how do we ensure there is a interaction between the legacy to the new? And Slowly, we will be like, first of all, we'll cut over 20% of the core piece into the Java architecture. Right? And be calling those 20% of the modules from inside of the legacy components itself. Right? So we need to figure out a way also for how do we make Earlier, the call which used to be monolith. Right? How do we transition them in order to call through the network? Right? So all these things needs to be insured in order to ensure that we have a reduced process. And then we take it chunk by chunk, and there is always a mechanism wherein we can switch those calls from pointing to the new code versus the existing old code itself. Right? So there is some sort of a toggle in place wherein we can ensure that, okay, if the

What method would you use to optimise a JVM performance for a Java application in a containerized environment? To optimize Java performance, JVM performance for a Java application in a containerized environment. We will allocate the heap size to be appropriate. Right? Sometimes I have seen in the JVM, we don't have an appropriate heap size of the container. Due to which, the applications continue to choke up, and they are not able to perform. So there should be a good amount of a heap Memory available in the container and when executing the JVM, we will assign that heap to that, uh, container itself. Right? That would be one of the things, which I would definitely take into consideration. And, uh, performance would be how many threads are there available. So from the Spring Boot aspects, right, like, how many number of threads a request can take up? We have a dedicated connection pool available or a thread pool available in order to serve the Multi threaded request within the JVM kernel, so all these things needs to be taken into consideration when we are optimizing our JVM

Outline a strategy for integrating a sophisticated machine learning model into an existing AWS powered data pipeline. Outline a strategy for integrating a sophisticated ML model into an existing AWS powered data pipeline. So we can have one of the API node kind of a component, which can call in, Uh, to that, APIs which are backed by these ML models. I'm assuming these ML models have already been trained on the data. So that data training is not an issue over here. It is just that how do we integrate that. Right? So We can get some outputs from that API node and then be able to process, plug in those learnings from the ML model into this AWS powered that link. Maybe we can populate some of the JSON payloads from the ML model, This could we were populating through traditional ways, but now we are already able to get those details, and then we can short circuit some of the components with this data pipeline as well. So, again, think of API node based integration to call into our ML model. Or maybe some sort of eventing could also be used wherein we publish an event and this event is consumed by our ML model in order to and then Corresponding to that, these events are enhanced further and then published onto the pipeline in order to be used, consumed further.

Explain a method for improving Java application performance through the use of AWS caching mechanisms. Explain a method for improving data through the use of AWS caching. So AWS offers 2 sort 2 different types of caching, either it is a Redis or a Memcache. And cache will serve you a very simple key value kind of for caching things. And Redis can offer you, uh, key value, which could be like we can have a Map, a list, or an object kind of a storage as well. Right? So depending on the use case, you can select for any of the AWS caching mechanism. Uh, each and every mechanism will come up with their own cluster. We can have Appropriate read, write, replicas configured for that cluster itself. And we can have a write through cache or a write Read through cache mechanisms build across, wherein the data hash would be, first of all, searching the cache. If it is not there. There will be a call to the origin server. And then while serving the client, it will also be cached in the system itself. Right? So this is the read through cache wherein the data will be always read through our cache system itself. Right? And whenever we are updating the database, We can ensure that, uh, these entry do gets invalidated or we are setting some TTL. And while writing also, So we ensure that, uh, we are writing through the cache, and then we update our cache whenever we are updating the DB as Right? So the keys do not get redundant, and these keys will have a TTL time frame of, okay, the time to live, which could expire the data once the, uh, time duration is