Can you explain the principles of SOLID and how to apply them in software development?

SOLID principles are five fundamental rules of object-oriented design that help create flexible, extendable, and maintainable code:

1. S — Single Responsibility Principle Each class should have only one reason to change, meaning it should be responsible for a single task.

2. O — Open/Closed Principle Classes should be open for extension but closed for modification.

3. L — Liskov Substitution Principle Objects of subclasses should be interchangeable with objects of the base class without affecting the correctness of the program.

4. I — Interface Segregation Principle Clients should not depend on interfaces they do not use. It's better to have several specific interfaces than a single universal one.

5. D — Dependency Inversion Principle High-level modules should not depend on low-level modules. Both should depend on abstractions.

Example of application in Go:

// Single Responsibility Principle
// The class (structure) is responsible only for working with users

type UserRepository interface {
    GetUser(id int) (*User, error)
}

// Dependency Inversion Principle
// The service depends on an interface, not on a specific implementation

type UserService struct {
    repo UserRepository
}

func (s *UserService) GetUserName(id int) (string, error) {
    user, err := s.repo.GetUser(id)
    if err != nil {
        return "", err
    }
    return user.Name, nil
}

Applying SOLID helps write code that is easier to test, extend, and maintain.