Dilip Durge

How do you see the file? So, basically, whenever, uh, I need to, uh, create any system design, uh, for any problem, I'm thinking about first, uh, or analyze, uh, the problem statements. What what are the requirements? Uh, basically, how it handles the customers, whether it has, uh, a a third API. If required a third API third party API, basically, it, uh, required the third party implementations and where it has handled the payment gateways and all. So these are the first thinking about system design. And in initial approach, uh, whenever I'm thinking about the system design, I'm, uh, go with all the necessary requirements, uh, uh, regarding the, uh, whatever, uh, the customers it has, whether it's in a vast way or it's just, uh, in a small, uh, you know, small count amount of customers. And, uh, so all these requirements, uh, I gathered. I even, you know, has a discussion with, uh, stakeholders, uh, uh, to get more understand about, uh, the requirements, uh, and the clarity of their requirements. Uh, if there is any possibilities to change or, uh, something, uh, which needs to be implement or any, you know, changes that needs to be handled before, uh, going for the final, uh, requirements. So I has a we're discussing with the stakeholders and all. Uh, after that, I, uh, you know, uh, also taking, uh, some suggestions from the sales team, uh, so that I can get, you know, the clear picture of what I need to be, uh, design, what I need to to to, you know, design the solutions. So these are, uh, you know, the initial approach for me to, you know, solving any system design problems.

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

Okay. What design consideration should be made? Okay. What design consideration should be made when deciding between throwing a checked exception, like, I exception versus wrapping it in and unchecked exceptions? Mhmm. File process. Okay. Okay. Okay. Okay. I mean, deciding, uh, between the throwing eject exceptions versus, uh, the wrapping exceptions, the, you know, like, uh, to I you know, like, there are some, uh, key considerations which I need to, uh, think about before, uh, this, uh, you know, this needs to be handled, uh, like, the some design factors which I need to think about, like, you know, uh, can the, uh, the caller meaningfully recover? I mean, basically, it is handled forcefully or not. Uh, so the and then, uh, is the failure part of expected business flow? And then, uh, is it a violation of any conditions which are preconditioned now? Uh, does the exception, uh, belonging in the methods, uh, of public APIs, uh, contacts or not? And, uh, is it a low level, uh, infrastructure exception, uh, bubbling for higher level. So and, also, the last, but not the least, is the the performance, uh, critical part. Uh, so these are, uh, the things, uh, which I need to you know? Uh, basically, these are the things that I need to consider. Uh, and, uh, as a you know, as my as an experienced developer, I'm, you know, uh, use, uh, the checked exceptions for, uh, you know, recoverable or expected conditions. And, like, for the public file, uh, read config, uh, in which the file path and through exceptions, like illegal accession or, you know, any any exceptions which we need to, you know, those. It's unchecked and use unchecked restrictions, uh, for program errors, uh, or infrastructure failures, in which, uh, wrapping, uh, the low level checked exceptions when they leak abstractions, uh, like, uh, the data access data access exceptions. And and if I use the checks suggestions, then definitely, uh, you know, I go with the checks expressions rather than, uh, 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, uh, 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, uh, whenever, uh, I'm, uh, going to design any APIs in Java, the choices, uh, you know, whatever that I have in between, uh, the checked and unchecked exceptions, uh, that, you know, should be contacted contact decisions, and, uh, it's not, uh, regarding the any coding or something. The the the checked exception, uh, when we used, uh, basically, uh, the error says recoverable, and the caller can, uh, uh, you know, reasonably react so that we can use in that in this situation, we can use, uh, the checks sections. And, uh, so the, uh, the failure is known, uh, part of the business flow, uh, and not not a program, not, uh, related to program box or something. And when we want to make, uh, in, uh, make it explicit, uh, in the, uh, metal contract, So, like, tools and all. So I will get the checked exceptions. Uh, for example, uh, uh, suppose, uh, I have, uh, you know, in interface for storing any file and, uh, in which I used a, uh, a method, uh, which throws, uh, like, uh, suppose I have a file, uh, file storing, uh, interface, uh, where I use the class, uh, object, right, method, uh, input string, uh, open file in which I provide the system, uh, string path, uh, which throws the file not formed exceptions. So this is the, uh, example of checked exception. And, uh, while using, uh, means unchecked exceptions, uh, basically, uh, when, uh, the error represents a programming mistake, uh, misses of the APIs or, uh, any invalid state. And, uh, the caller, uh, cannot meaningfully recover. Uh, basically, it's the forcing tryout catch, and, uh, you know, it would very difficult. And it's a system failure you to, you know, handle. So these things needs to be handled, uh, with the unchecked sessions. Uh, For example, uh, like, the update user, uh, email where, uh, the user ID and email are null, then, uh, I throw, uh, illegal sessions. So these are the unchecked sessions. So the use of checked sessions is, uh, the, you know, more appropriate while, uh, creating, uh, 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 system. Okay. Java seven. Actually, before Java eight, there are very less options in options for developers. So, basically, there are not lot more updates in Java seven, uh, which are, you know, used for programming easily or easefully. So, you know, uh, because, uh, while, you know, designing, uh, the modern, uh, backend system like we have right now, uh, it's crucial to, you know, understand, uh, the features which are provided in, uh, the Java. And, uh, like, uh, I remember when the Java seven has a string in switch switch, I think, yes, is in a switch statements, uh, try with the resources block and, uh, multiple catch and the throwing exceptions. And, uh, and, also, some features are there. And in Java, uh, Conting Fun, uh, the features like the virtual threads, uh, which, you know, introduced basically the use for the live web threads managed by the JVM and sequence collections added, uh, in the Java 21. Then the record pattern and the type button also is there. And the garbage collections is enhanced in Java 21. Uh, in Java 22, I think stream is there, but, uh, not sure. Stream stream gathers and stream gathers or stream Yes. Stream gathers stream stream gathers out there, which introduce the stream gathers in the alternative tool. And then, uh, and, also, uh, it has the features added in the alternative tool, uh, like, the we can add the you know, or we can write any statements before, uh, uh, the calling the super meter, uh, in construction in constructor, uh, which, you know, provides the more flexibility, uh, in the construction logic. And, uh, class file API is there. And, uh, like in Python, there are declaration of variables are simple. Uh, the same way, I think in in. I'm not sure if an unnamed variable is introduced, uh, in. And, uh, and, of course, uh, the the garbage collection also is implemented in, uh, you know, better way in Java 22. So these are the key differences in Java seven twenty two and twenty two, twenty one and twenty two, uh, and the system.

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

What potential issue could arise with this implementation if very large input stream are given, and how would you optimize it? Okay. Public class balanced parenthesis. Okay. It's time. Still stuck. Okay. No mistake. Forecast c c stuck. Okay. What potential issue could arise with this implementation if very large input string are given? And how would you optimize it? So for this, public class balance forces. Parenthesis, uh, stack stack. K. Just throw me this. Okay. Okay. Okay. Stream check. Okay. Mhmm. Uh, for optimization, I'm a go with the string, uh, builder other than string or string buffer, uh, so that, uh, you know, the whatever the congregations of the repeated symbols or any patterns. Uh, so I am going with the string window. And then the stream processing, uh, for, uh, you know, uh, very large input, uh, to, uh, process incrementally rather than, uh, loading all in a memory. Uh, so I'm going with the string. And, uh, and also okay. Okay. So byte buffer. And, uh, also, I can impose the maximum, uh, maximum length of maximum length. Basically, the limit of the, uh, string for the API safety. And this these are the keys I need to handle or I need to implement in 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, uh, whenever we, uh, talking about the relational databases, there are primary keys, and unique keys are there while creating the tables. When, uh, we talk about the primary key, uh, like, it, uh, you know, is used for, uh, to uniquely identify us, uh, of each row in a table. And, uh, it should be, uh, unique. And it has a characteristic like unique. It should be unique. And, uh, basically, it must be unique. Not it should be unique. It must be unique, and it cannot be null. And, uh, it implicitly create a clustered index in relational databases. So the primary key is this. Uh, for for example, uh, if we create a write a query like, uh, a create a table user, uh, so the ID, uh, which needs to be defined as a primary key so that, uh, it is, uh, you know, you know, identifier, uh, for every user, uh, and it cannot be null. And, uh, while, uh, the unique key or unique also, we can call this unique constraint. Uh, basically, unique key, uh, you know, ensures that, uh, any column constraints, uh, what are the unique values, uh, but it is, uh, not necessarily, uh, the primary identifier. Uh, like, uh, you know, uh, it must be unique, uh, but it can allow one null, uh, in, uh, the databases. Like Oracle and MySQL, uh, it can be multiple per table, and it can be composite, uh, like, on multiple columns. Uh, like, uh, for example, uh, the create table user, uh, their ID, enter primary key, uh, username, uh, varchar, uh, 100, unique, and email, uh, varchar, uh, 100, unique. So basically, the username and emails are are unique. It can be null, but it can used in different, uh, way. So these are, uh, the primary key and unique key integration methods.

Can you explain a situation where you applied a design pattern? Example, singleton factory, or server in microservices. Why did you choice that pattern, and what benefits did it provide? So, basically, uh, while So, basically, uh, while implementing the microservices, uh, I, uh, also use the singleton where I have I remember that, uh, we had a situation, uh, you know, uh, where we had a configuration service in a microservices ecosystem, uh, you know, uh, that reads service level configurations from the database, uh, and expose them to multiple services, uh, models at runtime. Why singleton in this? Uh, because, you know, uh, we wanted only one, uh, instances, uh, of the configuration one instance of the configuration loader per service, uh, instance to avoid redundant database calls. Uh, uh, and, uh, it had to be, uh, you know, and accessible across different components without, uh, creating objects. And I'm creating, uh, using the Java plus. And in a you know, when whenever I create any, uh, config class, uh, which is used as a component class to ensure, you know, the singleton scope. Uh, for that, I used the annotation, uh, add the red component, uh, for that class, uh, to ensure the singleton scope by default. And it has, you know, in that situation, you know, it, you know, reduce the database load because it, uh, you know, only switching the whatever the required configuration, uh, for service. It's one switching one services, uh, for each service instance, And it's a centralized, uh, conflict access so that, you know, uh, we avoid multiple projects in, uh, in instantiation exchange instantiations. And it also gives us a case of, uh, and transistor across service model. So I used a singleton overlay. Uh, factory factory pattern I used, uh, but, uh, not remember as such. So, yep, singleton, uh, I used only.