S.O.L.I.D.

O SOLID é um conjunto de princípios de design de software que foi introduzido por Robert C. Martin, também conhecido como "Uncle Bob", na década de 2000. No entanto, os conceitos subjacentes aos princípios SOLID têm raízes que remontam às primeiras décadas da história da programação de computadores.

A evolução do SOLID está relacionada ao desenvolvimento da programação orientada a objetos (POO). A POO começou a ganhar popularidade na década de 1960 e 1970, com a criação de linguagens como Simula e Smalltalk. No entanto, foi nos anos 1980 e 1990 que a POO começou a se tornar uma abordagem amplamente adotada para o desenvolvimento de software, com linguagens como C++, Java e C#.

À medida que a POO ganhava popularidade, os desenvolvedores enfrentaram desafios crescentes ao escreverem software complexo. Foi nesse contexto que Robert C. Martin desenvolveu os princípios SOLID. Uncle Bob, juntamente com outros engenheiros de software influentes, buscou fornecer diretrizes claras para criar código orientado a objetos mais eficiente, flexível e fácil de manter.

Os princípios SOLID foram apresentados pela primeira vez no livro "Design Principles and Design Patterns" (Princípios de Design e Padrões de Design), escrito por Robert C. Martin e outros autores. No entanto, foi no livro subsequente de Uncle Bob, "Clean Code: A Handbook of Agile Software Craftsmanship" (Código Limpo: Um Manual de Artesanato de Software Ágil), publicado em 2008, que os princípios SOLID ganharam grande destaque e reconhecimento na comunidade de desenvolvimento de software.

A sigla SOLID foi cunhada por Michael Feathers, um renomado autor e engenheiro de software, em um artigo escrito por ele em 2004. Embora os princípios SOLID tenham sido propostos por Robert C. Martin, foi Michael Feathers que os agrupou sob essa sigla, tornando mais fácil lembrar e referenciar esses princípios.

A sigla SOLID é composta pelas iniciais de cada um dos cinco princípios:

• S - Princípio da Responsabilidade Única (Single Responsibility Principle - SRP)
• O - Princípio do Aberto/Fechado (Open/Closed Principle - OCP)
• L - Princípio da Substituição de Liskov (Liskov Substitution Principle - LSP)
• I - Princípio da Segregação de Interface (Interface Segregation Principle - ISP)
• D - Princípio da Inversão de Dependência (Dependency Inversion Principle - DIP)

A sigla SOLID tornou-se uma forma conveniente de se referir a esses princípios e ajudou a promover sua adoção e disseminação na comunidade de desenvolvimento de software.

Desde então, os princípios SOLID se tornaram um conjunto de diretrizes fundamentais para muitos desenvolvedores e equipes de engenharia de software. Eles ajudam a criar sistemas mais robustos, flexíveis e fáceis de manter, promovendo a escrita de código de alta qualidade.

Além disso, os princípios SOLID são frequentemente ensinados em cursos de programação e design de software e são considerados parte integrante do repertório de conhecimento de qualquer desenvolvedor de software moderno. Eles contribuíram significativamente para o avanço da engenharia de software e a criação de software mais confiável e escalável.

 

Os Princípios SOLID:

Agora, vamos olhar para cada um dos princípios SOLID com explicações mais simples e exemplos:

1. Princípio da Responsabilidade Única (SRP): Isso significa que uma classe deve fazer apenas uma coisa, ou seja, ter apenas uma razão para mudar. Imagine uma classe que gerencia o registro de funcionários em uma empresa. Se ela também cuidar da geração de relatórios, estará violando o SRP. Em vez disso, devemos ter uma classe para registrar funcionários e outra para gerar relatórios.

2. Princípio do Aberto/Fechado (OCP): Este princípio nos diz que o código deve estar aberto para extensões, mas fechado para modificações. Por exemplo, se temos uma classe que representa formas geométricas, podemos adicionar novos tipos de formas sem alterar a classe existente. Isso é alcançado usando herança ou interfaces.

3. Princípio da Substituição de Liskov (LSP): O LSP diz que classes derivadas devem poder ser usadas em vez de suas classes base sem problemas. Por exemplo, se temos uma classe "Pássaro" e uma classe derivada "Pinguim", o código que funciona com pássaros deve funcionar corretamente com pinguins, pois eles são tipos de pássaros.

4. Princípio da Segregação de Interface (ISP): Esse princípio nos diz para não forçar as classes a implementar métodos que não precisam. Suponha que tenhamos uma interface "DispositivoMóvel" que tenha métodos para fazer chamadas e enviar mensagens, mas um dispositivo como uma calculadora não precisa desses métodos. Em vez disso, devemos criar interfaces menores e mais específicas.

5. Princípio da Inversão de Dependência (DIP): O DIP nos ensina a depender de abstrações, não de implementações concretas. Em vez de uma classe de alto nível depender diretamente de uma classe de baixo nível, ambas devem depender de interfaces ou abstrações. Isso torna o código mais flexível e facilita a substituição de componentes.

Em resumo, o SOLID é um conjunto de princípios que ajuda os desenvolvedores a escreverem código mais organizado e sustentável, evitando problemas comuns de design. Esses princípios têm uma longa história de aplicação bem-sucedida na engenharia de software e são amplamente aceitos como melhores práticas na indústria. Eles ajudam a criar sistemas de software mais robustos e fáceis de manter ao longo do tempo.