Add Design Principles

Author: ashishps1

README.md

@@ -1,9 +1,15 @@
 # awesome-low-low-design
-This repository contains low level design (LLD) resources to improve object oriented design skills and prepare for interviews.
+This repository contains low level design (LLD) resources to improve object oriented design (OOD) skills and prepare for interviews.
 
-## Low Level Design Fundamentals
+## Design Principles
+- [Basics of OOPS](concepts/OOPS.md)
 - [SOLID Principles in Pictures](https://medium.com/backticks-tildes/the-s-o-l-i-d-principles-in-pictures-b34ce2f1e898)
 - [SOLID Principles in Code](https://medium.com/android-news/solid-principles-the-definitive-guide-75e30a284dea)
+- [DRY Principle](concepts/DRY.md)
+- [YAGNI Principle](concepts/YAGNI.md)
+
+## Design Patterns
+
 
 ## Low Level Design Interview Problems
 - [Design Parking Lot]

concepts/OOPS.md

@@ -0,0 +1,129 @@
+## Basics of Object-Oriented Programming (OOPS)
+
+Object-Oriented Programming (OOP) is a fundamental programming paradigm used in software development, defined by its use of classes and objects. 
+
+It’s built on four main principles: Inheritance, Polymorphism, Abstraction, and Encapsulation. 
+
+These principles not only help in creating structured and reusable code but also make it easier to understand, maintain, and modify.
+
+### Inheritance
+nheritance allows one class to inherit the properties and methods of another class. It's a way to form a hierarchy between classes, promoting code reusability.
+#### Example:
+```
+class Vehicle {
+    public void startEngine() {
+        System.out.println("Engine started");
+    }
+}
+
+class Car extends Vehicle {
+    public void openTrunk() {
+        System.out.println("Trunk opened");
+    }
+}
+
+public class Main {
+    public static void main(String[] args) {
+        Car myCar = new Car();
+        myCar.startEngine(); // Inherited method
+        myCar.openTrunk(); // Own method
+    }
+}
+```
+
+In this Java example, `Car` inherits from `Vehicle`. 
+
+Car can use the startEngine method from Vehicle, demonstrating inheritance.
+
+### Polymorphism
+Polymorphism allows objects of different classes to be treated as objects of a common superclass. It’s the ability of multiple object types to implement the same functionality, which can be achieved either by method overloading or method overriding.
+
+#### Example:
+```
+class Bird {
+    public void sing() {
+        System.out.println("Bird is singing");
+    }
+}
+
+class Sparrow extends Bird {
+    public void sing() {
+        System.out.println("Sparrow is singing");
+    }
+}
+
+public class Main {
+    public static void main(String[] args) {
+        Bird myBird = new Sparrow();
+        myBird.sing(); // Outputs: Sparrow is singing
+    }
+}
+```
+Here, `Sparrow` overrides the sing method of `Bird`. Despite referring to Sparrow with a Bird reference, the overridden method in Sparrow is called.
+
+### Abstraction
+Abstraction is the concept of hiding complex implementation details and showing only the necessary features of an object. It can be achieved using abstract classes and interfaces.
+
+#### Example:
+```
+abstract class Animal {
+    abstract void makeSound();
+
+    public void eat() {
+        System.out.println("Animal is eating");
+    }
+}
+
+class Dog extends Animal {
+    public void makeSound() {
+        System.out.println("Bark");
+    }
+}
+
+public class Main {
+    public static void main(String[] args) {
+        Animal myDog = new Dog();
+        myDog.makeSound(); // Outputs: Bark
+        myDog.eat(); // Inherited method
+    }
+}
+```
+`Animal` is an abstract class that provides a method `makeSound()`. 
+
+`Dog` provides the specific implementation of this method.
+
+### Encapsulation
+Encapsulation is the technique of bundling data (variables) and methods that act on the data into a single unit, often called a class, and restricting access to some of the object’s components.
+
+```
+class BankAccount {
+    private double balance;
+
+    public void deposit(double amount) {
+        if (amount > 0) {
+            balance += amount;
+        }
+    }
+
+    public void withdraw(double amount) {
+        if (amount <= balance) {
+            balance -= amount;
+        }
+    }
+
+    public double getBalance() {
+        return balance;
+    }
+}
+
+public class Main {
+    public static void main(String[] args) {
+        BankAccount account = new BankAccount();
+        account.deposit(1000);
+        account.withdraw(500);
+        System.out.println("Balance: " + account.getBalance());
+    }
+}
+```
+
+In this example, the balance of the `BankAccount` is kept private. It can only be modified through the `deposit` and `withdraw` methods and read through the `getBalance` method, showcasing encapsulation.

concepts/YAGNI.md

@@ -0,0 +1,47 @@
+# The YAGNI Principle
+YAGNI (You Aren't Gonna Need It) is a mantra in software development that encourages developers to implement things only when they are necessary.
+
+## Understanding YAGNI
+YAGNI, an acronym for "You Aren't Gonna Need It", is a principle that recommends against adding functionality until it is deemed necessary. 
+
+Ron Jeffries, one of the creators of Extreme Programming, coined this term to prevent over-engineering and to keep software development as efficient and straightforward as possible.
+
+### The Benefits of YAGNI
+- **Reduces Complexity:** By not adding unnecessary features, the codebase remains simpler and more manageable.
+- **Saves Time and Resources:** Time is not wasted on features that may never be used, allowing more focus on the current requirements.
+- **Easier Maintenance:** Fewer features mean less code to test and maintain.
+- **Increases Flexibility:** Without unnecessary code, it is easier to adapt the software to new requirements.
+
+## Implementing YAGNI: Practical Examples
+
+### Example 1: Avoiding Premature Generalization
+
+**Non-YAGNI Approach:**
+
+Imagine you are building a blog platform and decide to implement a complex tagging system that allows nested tags, even though the initial requirements only mention simple tags.
+
+**YAGNI Approach:**
+
+You implement a straightforward tagging system that meets the current requirements. If, in the future, the need for nested tags arises, you can extend the system then.
+
+### Example 2: Avoiding Unnecessary Features
+
+**Non-YAGNI Approach:**
+
+Developing a feature for exporting reports in five different formats when the client has asked for only one specific format.
+
+**YAGNI Approach:**
+
+You focus on creating a robust and efficient export feature for the requested format. If the need for additional formats arises later, they can be added at that time.
+
+## Tips for Practicing YAGNI
+
+1. **Focus on Requirements:** Always align your development efforts with the current requirements, not on what you think might be needed in the future.
+2. **Refactor When Needed:** Apply YAGNI in conjunction with refactoring. If a new requirement arises, refactor your code to accommodate it.
+3. **Continuous Feedback:** Regularly communicate with stakeholders to ensure that what is being developed is what is actually needed.
+4. **Avoid Speculative Generality:** Do not generalize the solution for potential future problems. Keep solutions specific to the problem at hand.
+
+## Conclusion
+The YAGNI principle is a powerful tool in the arsenal of a software developer. It encourages simplicity and efficiency, reminding us to focus on what is needed now rather than getting lost in the complexities of what might be needed in the future. 
+
+By adhering to YAGNI, developers can create software that is not only easier to maintain and extend but also delivers value faster to the end user.