💥💥 SOLID Design: qual a regra mais importante?

A qualidade do código é um fator crítico no desenvolvimento de software. Neste artigo, vou explorar a regra mais importante do Clean Code e tentar explicar da maneira mais simples possível para que não reste dúvida sobre o tema, tudo centrado na aplicação dos princípios SOLID. 

Para tanto, entenda que os princípios são diretrizes essenciais para escrever código robusto, legível e facilmente mantido. Eles foram apresentados pela primeira vez por Robert C. Martin e posteriormente consolidados por Michael Feathers, visando melhorar a arquitetura de software. São eles:

S - Princípio da Responsabilidade Única (Single Responsibility Principle)

O - Princípio Aberto-Fechado (Open-Closed Principle)

L - Princípio da Substituição de Liskov (Liskov Substitution Principle)

I - Princípio da Segregação de Interfaces (Interface Segregation Principle)

D - Princípio da Inversão de Dependência (Dependency Inversion Principle)

Cada princípio SOLID visa resolver problemas específicos no desenvolvimento de software, promovendo a coesão, a flexibilidade e a extensibilidade do código.

Para entender melhor, existe uma diferença entre Programação e Boa Programação. A programação tradicional visa apenas a funcionalidade. A boa programação se baseia nos princípios SOLID. Ela busca ir além da simples funcionalidade e foca na legibilidade, manutenção e escalabilidade do código.

Um código limpo é caracterizado por várias qualidades. Ele é claro, o que significa que sua intenção é facilmente compreendida por outros desenvolvedores. A simplicidade também é uma característica importante, já que um código simples é mais fácil de manter e menos propenso a erros. 

Além disso, um código limpo é modular, dividido em pequenos componentes independentes que podem ser reutilizados e testados separadamente. A formatação adequada também é crucial para manter um código limpo. O uso de nomes descritivos para variáveis e funções torna o código mais legível. 

A indentação consistente e o alinhamento adequado de blocos de código facilitam a compreensão da estrutura do programa. Além disso, a adesão a convenções de nomenclatura, como o CamelCase ou o snake_case, melhora a consistência do código e torna-o mais acessível a outros desenvolvedores.

O polimorfismo é um dos pilares da orientação a objetos e desempenha um papel significativo na criação de código limpo. Ele permite que objetos de diferentes classes sejam tratados de maneira uniforme por meio de interfaces e herança. Isso promove o reuso de código e reduz a duplicação.

Pode-se usar polimorfismo ao substituir estruturas condicionais (ifs) por implementações polimórficas. Isso evita blocos de condicionais aninhados complexos. Para isso, pode-se criar classes específicas que implementam um mesmo contrato e delegar o comportamento apropriado a essas classes.

Agora que abordamos esses tópicos, podemos ver como os princípios SOLID se alinham com a criação de código limpo e eficiente. Vamos explorar um exemplo prático de como aplicar essas diretrizes.

Vamos considerar um exemplo de sistema de pagamento. Na programação tradicional, o processamento de pagamento pode ser realizado com um bloco de condicionais para determinar o método de pagamento e executar a lógica apropriada. Isso pode levar a código confuso e difícil de manter:

if metodo_pagamento == 'cartao': 
  processar_pagamento_cartao() 
elif metodo_pagamento == 'paypal': 
  processar_pagamento_paypal() 
elif metodo_pagamento == 'bitcoin': 
  processar_pagamento_bitcoin()

Agora, vamos aplicar os princípios SOLID, em particular o Princípio da Responsabilidade Única (SRP) e o Princípio Aberto-Fechado (OCP). Em vez de usar condicionais, criamos classes separadas para cada método de pagamento, cada uma com uma responsabilidade única:

class PagamentoCartao: 
  def processar_pagamento(self): 
  # Lógica de pagamento com cartão 
class PagamentoPaypal: 
  def processar_pagamento(self): 
  # Lógica de pagamento com PayPal 
class PagamentoBitcoin: 
  def processar_pagamento(self): 
  # Lógica de pagamento com Bitcoin

Agora, podemos escolher facilmente o método de pagamento desejado sem alterar o código existente, seguindo o Princípio Aberto-Fechado (OCP). Além disso, a lógica de pagamento para cada método está contida em sua própria classe, cumprindo o Princípio da Responsabilidade Única (SRP).

Essa abordagem torna o código mais legível, extensível e de fácil manutenção, alinhando-se com a regra mais importante do Clean Code: manter o código limpo aplicando os princípios SOLID.

Em resumo, a regra mais importante do Clean Code está intrinsecamente ligada à aplicação dos princípios SOLID. Ao adotar os princípios SOLID, os desenvolvedores podem criar código limpo que seja mais legível, sustentável e eficiente. 

Estes princípios promovem a coesão, o baixo acoplamento, a extensibilidade e a simplicidade do código. Através da aplicação dessas diretrizes, o desenvolvimento de software se torna uma tarefa mais organizada e eficaz.

Portanto, a regra mais importante do Clean Code é adotar os princípios SOLID. Isso resulta em sistemas mais confiáveis, fáceis de manter e mais bem adaptados às mudanças da programação. Ao seguir essas diretrizes, estará no caminho para escrever código limpo que atenda aos padrões de qualidade.

🚀 https://github.com/mdsjjorge

Referências:

1. "Clean Code: A Handbook of Agile Software Craftsmanship" - Robert C. Martin
2. "Refactoring: Improving the Design of Existing Code" - Martin Fowler
3. https://www.youtube.com/watch?v=CpfbAfidVeA
4. https://www.freecodecamp.org/news/solid-design-principles-in-software-development/#:~:text=SOLID%20is%20a%20set%20of,while%20developing%20the%20software%20systems.
5. https://www.bmc.com/blogs/solid-design-principles/
6. https://blog.betrybe.com/tecnologia/clean-code/
7. https://medium.com/@ibraheem.ahmed/good-coding-practices-and-writing-clean-code-b13e710f31ec