Low Level Design Practise

This repository contains

• Low-level design implementations for various applications,
• Design Patterns,
• Design Principles.
• Questions asked in Interviews.

Each case represents a specific system or problem domain.

Learn how to design and implement large-scale systems. Prep for the system design interview.

Status

• ⏳ Undergoing
• ✅ Implemented
• ❌ Still to do

Application Implementations

1. Library Management System ❌ Still to do
2. Chess Implementation ❌ Still to do
3. Food Delivery ✅ Implemented
4. Parking Lot ❌ Still to do
5. Json Parser ⏳ Undergoing
6. Stock Trading ❌ Still to do
7. Design Logger ❌ Still to do
8. Elevator Design ❌ Still to do
9. In-Memory Sql ❌ Still to do
10. Ecommerce-Design ❌ Still to do

Design Patterns

This repository contains implementations of various design patterns. Each design pattern is categorized by type and labeled with its implementation status.

Creational Patterns

• Abstract Factory: ✅ Implemented
• Builder: ✅ Implemented
• Factory Method: ✅ Implemented
• Prototype: ✅ Implemented
• Singleton: ✅ Implemented

Structural Patterns

• Adapter: ✅ Implemented
• Bridge: ✅ Implemented
• Composite: ✅ Implemented
• Decorator: ✅ Implemented
• Facade: ✅ Implemented
• Flyweight: ✅ Implemented
• Proxy: ✅ Implemented

Behavioral Patterns

• Chain of Responsibility: ✅ Implemented
• Command: ✅ Implemented
• Interpreter: ✅ Implemented
• Iterator: ✅ Implemented
• Mediator: ✅ Implemented
• Memento: ✅ Implemented
• Observer: ✅ Implemented
• State: ✅ Implemented
• Strategy: ✅ Implemented
• Template Method: ✅ Implemented
• Visitor: ✅ Implemented

Design Principles

This repository provides an overview of important design principles that every engineer should know. Understanding and applying these design principles can significantly contribute to creating high-quality, maintainable, and scalable software systems.

SOLID Principles

1. Single Responsibility Principle (SRP)
2. Open-Closed Principle (OCP)
3. Liskov Substitution Principle (LSP)
4. Interface Segregation Principle (ISP)
5. Dependency Inversion Principle (DIP)

Other Design Principles

1. DRY (Don't Repeat Yourself) Principle
2. KISS (Keep It Simple, Stupid) Principle
3. YAGNI (You Ain't Gonna Need It) Principle
4. Composition Over Inheritance Principle
5. Law of Demeter (LoD) or Principle of Least Knowledge
6. Separation of Concerns (SoC)
7. High Cohesion and Low Coupling
8. GRASP (General Responsibility Assignment Software Patterns)
9. Design by Contract (DbC)
10. Dependency Injection (DI) and Inversion of Control (IoC)
11. Test-Driven Development (TDD)

Please refer to each principle for a detailed explanation and guidelines on their application.

Contributing

Contributions to improve the project is appreciated and I encourage you to follow these guidelines:

1. Fork the repository and clone it to your local machine.
2. Create a new branch for your feature or bug fix: git checkout -b feature/your-feature or git checkout -b bugfix/your-bug-fix.
3. Make your changes, including appropriate tests if applicable.
4. Ensure that your code adheres to the project's coding standards.
5. Commit your changes and push to your forked repository.
6. Submit a pull request to the main repository, explaining your changes in detail and referencing any related issues.
7. Be responsive to any feedback or questions during the review process.

By contributing to this project, you agree to abide by the [Code of Conduct]. Please ensure that you follow the guidelines above and maintain a respectful and inclusive environment for everyone.

Contact

If you have any questions, suggestions, or feedback, please feel free to reach out to me. You can contact me via:

• Email: [email protected]
• Likedin: @ashish1500616
• GitHub Issues: Repository Issues

I appreciate your interest in this project and welcome any contributions or feedback you may have.