Explain the principles of SOLID and why they are needed in development.

The SOLID principles are a set of five fundamental rules of object-oriented programming aimed at creating flexible, extendable, and maintainable systems:

• S (Single Responsibility Principle) — the principle of single responsibility. Each class should have one and only one reason to change, meaning it should be responsible for one specific task.
• O (Open/Closed Principle) — the principle of openness/closedness. Software entities should be open for extension but closed for modification.
• L (Liskov Substitution Principle) — Barbara Liskov's substitution principle. Subclass objects should be interchangeable with superclass objects without affecting the correctness of the program.
• I (Interface Segregation Principle) — the principle of interface segregation. Clients should not depend on interfaces they do not use; it's better to have several specific interfaces than one universal interface.
• D (Dependency Inversion Principle) — the principle of dependency inversion. High-level modules should not depend on low-level modules; both should depend on abstractions.

Why are SOLID principles needed:

• They improve code readability and maintainability.
• They simplify testing and refactoring.
• They make it easier to add new features without risking breaking existing code.

Example (Java):

// Violation of SRP
class Report {
    void generate() { /* report generation */ }
    void saveToFile() { /* save to file */ }
}

// Better separation:
class ReportGenerator {
    void generate() { /* report generation */ }
}
class ReportSaver {
    void saveToFile(Report report) { /* save to file */ }
}