What are pros of Monolith?
- more simple. easy to develop, test and deploy as all services in single codebase.
- performance. faster communication between since in the same process and memory space. no network latency
- centralized logging, monitoring, debugging
- easier to manage version and dependencies
- transaction management. easy to manage transaction as in the same application
What are cons of Monolith?
- Scalability. hard to scale individual service
- Resource utilization may be inefficient
- deployment. single bug can bring down entire application. longer deployment
What are pros of Microservices?
- Independent scaling
- Resource efficiency
- Technology flexibility
- Independent deployment
- Fault isolation
- Parallel development
- Fast deployment
What are cons of Microservices?
- Maintaining distributed system is more complex
- Inter services communication latency
- Transaction management
What is race condition?
A race condition occurs in a multithreaded or parallel program when two or more threads or processes access shared resources or variables concurrently, and the final outcome depends on the unpredictable timing or order of their execution. This can lead to unpredictable behavior, errors, or bugs that are difficult to reproduce and diagnose.
What is deadlock?
A deadlock is a situation in concurrent programming where two or more processes or threads are unable to proceed because each is waiting for the other to release a resource they need.
What is functional programming?
A programming paradigm that treats computation as the evaluation of mathematical functions and avoids changing state and mutable data. It emphasizes the use of pure functions, immutability, and declarative code, contrasting with the imperative programming paradigm.
What key concepts of functional programming?
- Focus on Functions:
- FP revolves around the concept of functions as the primary building blocks of computation.
- Functions are treated as first-class citizens, meaning they can be passed around as arguments, returned from other functions, and assigned to variables.
- Immutable Data:
- Data in FP is typically immutable, meaning once it’s created, it cannot be changed. Instead, new data structures are created.
- Immutability avoids side effects and makes programs more predictable and easier to reason about.
- Avoidance of State:
- FP emphasizes avoiding mutable state and side effects. Functions operate solely on their inputs, producing predictable outputs without modifying external state.
- Declarative Style:
- FP promotes a declarative programming style where programs are written by describing what should be computed rather than how it should be computed.
- This leads to concise and readable code that focuses on transformations of data through function composition.
- Recursion:
- Recursion is often used instead of looping constructs for repetitive tasks in FP. Recursive functions are a fundamental concept for iteration.
- Pure Functions:
- Pure functions have no side effects and always produce the same output for a given input, making them easy to test and reason about.
What key concepts of object oriented programming?
- Focus on Objects:
- OOP revolves around the concept of objects, which encapsulate data (attributes) and behavior (methods) together.
- Objects interact with each other through messages (method calls).
- Encapsulation:
- Encapsulation is a key principle in OOP, where objects hide their internal state and expose a public interface for interacting with other objects.
- Inheritance:
- Inheritance allows classes (blueprints for objects) to inherit behavior (methods) and attributes from parent classes, promoting code reuse and hierarchy.
- Polymorphism:
- Polymorphism enables objects of different classes to be treated as objects of a common superclass through method overriding and method overloading.
- State and Identity:
- OOP manages state and identity of objects, allowing objects to change their internal state over time (mutability).
- Design Patterns:
- OOP commonly uses design patterns like Factory, Singleton, Observer, and others to solve recurring design problems effectively.
What is diff functional vs object oriented programming?
Key Differences:
* Approach to Problem-Solving:
* FP focuses on transforming data through the composition of pure functions without mutable state.
* OOP emphasizes modeling real-world entities as objects with state and behavior, enabling abstraction and encapsulation.
* Mutability:
* FP encourages immutability and avoids mutable state to prevent side effects.
* OOP allows mutable state within objects, which can lead to more complex interactions and potential side effects.
* Core Concepts:
* FP revolves around functions, higher-order functions, and function composition.
* OOP revolves around classes, objects, inheritance, encapsulation, and polymorphism.
Choosing Between FP and OOP:
* Use Functional Programming When:
* Dealing with transformations of data.
* Avoiding mutable state and side effects.
* Emphasizing concurrency and parallelism.
* Use Object-Oriented Programming When:
* Modeling real-world entities and interactions.
* Encapsulating data and behavior within objects.
* Promoting code reusability through inheritance and polymorphism.
What is SOLID?
SOLID is an acronym that represents a set of principles for writing clean, maintainable, and scalable object-oriented code.
What keys of SOLID?
- Single Responsibility Principle (SRP)
* Definition: A class should have only one reason to change, meaning it should have only one responsibility or job within the system.
* Benefits: Promotes modularity, maintainability, and testability by keeping classes focused on specific tasks. - Open/Closed Principle (OCP)
* Definition: Software entities (classes, modules, functions, etc.) should be open for extension but closed for modification. This means that you should be able to extend the behavior of a module without modifying its source code.
* Benefits: Encourages code reuse, reduces the risk of introducing bugs in existing code, and promotes scalable and flexible designs. - Liskov Substitution Principle (LSP)
* Definition: Objects of a superclass should be replaceable with objects of its subclasses without affecting the correctness of the program.
* Benefits: Ensures interoperability of object types, promotes polymorphism, and helps maintain consistency in behavior across inheritance hierarchies. - Interface Segregation Principle (ISP)
* Definition: Clients should not be forced to depend on interfaces they do not use. This principle advocates for small, cohesive interfaces tailored to specific client needs.
* Benefits: Prevents the creation of “fat” interfaces that impose unnecessary dependencies on clients, leading to more modular and maintainable code. - Dependency Inversion Principle (DIP)
* Definition: High-level modules should not depend on low-level modules. Both should depend on abstractions (e.g., interfaces). Additionally, abstractions should not depend on details; details should depend on abstractions.
* Benefits: Reduces coupling between modules, promotes code flexibility and extensibility, and facilitates the application of other SOLID principles.
