Dilip Durge

Whenever I need to create any system design for any problem, I'm thinking about first analyzing the problem statements. What are the requirements? Basically, how it handles the customers, whether it has a third API. If required a third-party API, it requires the third-party implementations and where it handles the payment gateways and all. So, these are the first steps in thinking about system design. In the initial approach, whenever I'm thinking about the system design, I go with all the necessary requirements regarding the customers it has, whether it's in a vast way or just in a small, you know, small count of customers. And so, all these requirements I gather. I even have discussions with stakeholders to get more understanding about the requirements and the clarity of their requirements. If there are any possibilities to change or something that needs to be implemented or any changes that need to be handled before going for the final requirements. So, I have discussions with the stakeholders and all. After that, I also take some suggestions from the sales team so that I can get a clear picture of what I need to design, what I need to design the solutions. So, these are the initial approaches for me to solve any system design problems.

System process, how would you safeguard against them. Okay. Oh, for out-of-memory errors, you know, I've been mostly in job applications, like the Spring root and microservices. I increase the heap sizing so that it doesn't get any out-of-memory errors. And I also use circuit breakers, bounded thread pools, and connection pools as well. And then, I limit the rate and request throttling, and also memory leak detection. So I need to use any weak references or static collections. And I also check that. And using Kubernetes, so basically, Kubernetes OOM kill safeguards. You know? So it really limits the whatever problems are there. So these are the things I need to take care of while implementing the safeguards to prevent out-of-memory errors.

When deciding between throwing a checked exception, like I exception, versus wrapping it in an unchecked exception, what design consideration should be made? What design consideration should be made when deciding between throwing a checked exception, like I exception, versus wrapping it in an unchecked exception? File processing. Deciding between throwing checked exceptions versus wrapping exceptions, there are some key considerations which I need to think about before this needs to be handled. The some design factors which I need to think about, like, are there some design factors which I need to think about, like, can the caller meaningfully recover? I mean, basically, is it handled forcefully or not. So then, is the failure part of expected business flow? And then, is it a violation of any conditions which are preconditions now? Does the exception belong in the methods of public APIs, contacts or not? And, is it a low-level infrastructure exception, bubbling up to higher levels? So also, the last, but not the least, is the performance critical part. So these are the things which I need to consider. And, as an experienced developer, I'm used to using checked exceptions for recoverable or expected conditions. And, for public file read config, in which the file path and throw exceptions, like illegal access, or any exceptions which we need to handle. It's unchecked, and use unchecked exceptions for program errors, or infrastructure failures, in which wrapping the low-level checked exceptions when they leak abstractions, like data access exceptions. And if I use checked exceptions, then definitely I go with checked exceptions rather than wrapping in runtime.

Okay. What problem can occur in this implementation when processing thousands of messages per second? And how would you redesign it to ensure scalability? Our duplicates processing and handle failures. So this will be class of all the concern here. What problems can occur in this, implementation? What problems can occur in this implementation when processing thousands of messages per seconds? And how would you redesign it to ensure scalability? Avoid duplicates processing and handle failures. As we say, we can solve consumer any topic or the events. Okay. And we could access Okay. For this. So

When designing API in Java, how do you decide whether to use checked or unchecked assertions? Can you give an example of when each is more appropriate? K. When designing the API itself. Okay. So, whenever I design any APIs in Java, the choices between the checked and unchecked exceptions should be contact decisions, and it's not regarding the any coding or something. The checked exception, when we use, basically, the error is recoverable, and the caller can reasonably react, so we can use the checked exceptions. And the failure is known, part of the business flow, and not related to program box or something. And when we want to make it explicit in the metal contract, so like, tools and all. So I will get the checked exceptions. For example, suppose I have an interface for storing any file and in which I used a method which throws, like, suppose I have a file storing interface where I use a class object, method input string, open file in which I provide the system string path, which throws the file not found exception. So this is the example of checked exception. And while using means unchecked exceptions, basically, when the error represents a programming mistake, misuse of the APIs or any invalid state. And the caller cannot meaningfully recover. Basically, it's the forcing try-catch, and you know, it would be very difficult. And it's a system failure you to handle. So these things need to be handled with the unchecked exceptions. For example, like the update user email where the user ID and email are null, then I throw an illegal argument exception. So these are the unchecked exceptions. So the use of checked exceptions is more appropriate while creating any APIs in Java.

What are the key differences between Java seven, Java 21, and Java 22? The back end developers should be aware of when designing modern systems. Okay. Java seven. Actually, before Java eight, there were very few options available for developers. So, basically, there aren't a lot of updates in Java seven, which are used for programming easily. So, you know, because while designing the modern backend system like we have right now, it's crucial to understand the features which are provided in Java. And, I remember when Java seven had a string in switch statements, I think yes, it's in switch statements, try with resources block, and multiple catch and throwing exceptions. And, also, some features are there. And in Java, the Conting Fun features like virtual threads, which you know, introduced basically the use for live web threads managed by the JVM and sequence collections added, in Java 21. Then the record pattern and the type button are also there. And the garbage collection is enhanced in Java 21. In Java 22, I think streams are there, but not sure. Stream gathers and stream gathers or stream Yes, stream gathers out there, which introduced stream gathers in the alternative tool. And then, also, it has the features added in the alternative tool, like, we can add any statements before the calling the super method in construction in a constructor, which provides more flexibility in the construction logic. And, class file API is there. And, like in Python, there are declarations of variables are simple. The same way, I think in Java, unnamed variables are introduced. And, of course, the garbage collection is also implemented in a better way in Java 22. So these are the key differences in Java seven, Java 21, and Java 22, and the systems.

In microservices architecture, what design consideration do you make to ensure scalability and fault tolerance in services that communicate via REST or Kafka? Okay. So, basically, in microservices architecture, the small microservices are there to communicate with the back end and the front end. So whenever we need to design any microservices that communicate via REST or Kafka, The scalability and the fault tolerance are the most critical part. And I focus on mostly resilient patterns, proper abstractions, and operational safeguards rather than just coding the programming and all. So communication, in REST, HTTP, should be simple, synchronous, and easy to deliver. And while using Kafka, it should be asynchronously decoupled and highly scalable and also replicable. So, while considering the scalability, REST uses stateless services. And also, it employs connection pooling and time outs to avoid thread starvation and under heavy load. And we can consider bulk endpoints, one by one request. And we need to implement circuit breakers and rate limiting while using REST. And also, we use cache, basically, the HTTP caching or distributed caching to reduce the load on downstream services. While using Kafka, we need to think about partition topics or the parallelization of these topics. Then, we design the consumer to process events in a parallel manner and also use consumer groups to scale horizontally, then add important consumers or duplications to handle at least once delivery safely. And finally, we need to monitor all the consumer logs to detect any bottleneck causes. So these are the things for scalability and ensuring fault tolerance regarding REST. Basically, the timeouts and retries, circuit breakers, and fallback strategies like return default data if upstream is unavailable. Then the bulk hit pattern, isolated resources, all those new dependencies, and so on. So these are the things with REST and with Kafka, retry mechanisms, queuing, imperative transactional processing, and activation management.

What potential issue could arise with this implementation if very large input streams are given, and how would you optimize it? So, for this, public class Balance Forces. Parenthesis, stack. Just throw me this. Stream check. Okay. Mhmm. For optimization, I'm going with the string builder other than string or string buffer, so that, you know, the concatenation of the repeated symbols or any patterns can be done efficiently. So, I am going with the string builder. And then the stream processing for very large input to process incrementally rather than loading all in a memory. So, I'm going with the string builder. And also, I can use the byte buffer. And also, I can impose the maximum length of the string for the API safety. And these are the keys I need to handle or I need to implement to optimize this issue.

What is the difference between a primary key and a unique key in a relational database? Can a table have more than one of each? Okay. Basically, whenever we talk about relational databases, there are primary keys, and unique keys are there while creating the tables. When we talk about the primary key, it, like, is used for uniquely identifying each row in a table. And it must be unique. And it must not be null. It implicitly creates a clustered index in relational databases. So the primary key is this. For example, if we create a table user, the ID, which needs to be defined as a primary key, so that it is the identifier for every user, and it cannot be null. And while the unique key or unique constraint, we can ensure that any column has unique values, but it is not necessarily the primary identifier. Like, it must be unique, but it can allow one null in the database. Like Oracle and MySQL, it can be multiple per table, and it can be composite, like on multiple columns. For example, the create table user, their ID is a primary key, username is a varchar 100, unique, and email is a varchar 100, unique. So basically, the username and emails are unique. It can be null, but it can be used in different ways. So these are the primary key and unique key integration methods.

Can you explain a situation where I applied a design pattern? Example, singleton factory, or server in microservices. Why did I choose that pattern, and what benefits did it provide? So, basically, while implementing the microservices, I also used the singleton pattern where I remember that we had a situation where we had a configuration service in a microservices ecosystem that reads service level configurations from the database and exposes them to multiple services at runtime. I chose the singleton in this situation. Because we wanted only one instance of the configuration loader per service instance to avoid redundant database calls. And it had to be accessible across different components without creating objects. I'm creating using the Java plus. And whenever I create any config class which is used as a component class to ensure the singleton scope. I used the annotation to add the @Component for that class to ensure the singleton scope by default. In that situation, it reduced the database load because it only switched the required configuration for each service instance. It's a centralized configuration access so that we avoid multiple projects in instantiation exchange. And it also gives us a case of transparency across service models. So I used the singleton pattern.