10 princípios básicos de programação que todos os programadores devem seguir

Sua função como programador é escrever um código que funcione conforme o esperado e forneça o resultado desejado. No entanto, o código também deve ser fácil de entender, manter e estender. Para fazer isso, você precisa combinar os principais conceitos de programação com os princípios de uma boa codificação.

Nesta postagem, compartilharei meus 10 principais princípios de programação que ajudarão você a melhorar a maneira como escreve código, tornando a vida mais fácil para você, seus colegas desenvolvedores e seus usuários finais.

Por que os princípios de programação são importantes?

Ao aprender alguns princípios de programação e usá-los em seu código, você se tornará um desenvolvedor melhor. Seguir essas diretrizes melhora a qualidade geral do código e torna mais fácil para você ou qualquer outra pessoa fazer alterações ou adicionar recursos no futuro.

Fonte da imagem: Generoso

Os princípios de programação o ajudarão a evitar problemas como código confuso ou excessivamente complicado, programas que quebram após um ajuste e variáveis ​​que não fazem sentido. Segui-los também permitirá que você colabore com mais sucesso, garantindo que outros programadores possam entender seu código.

Esteja você criando um programa básico ou um aplicativo de nível empresarial, vale a pena se familiarizar com esses 10 princípios.

Dez princípios de programação a seguir:

1. BEIJE (seja simples, idiota!)

Manter o código simples e limpo é um dos princípios de programação mais importantes. empreendedoresAlguns desenvolvedores gostam de se exibir escrevendo códigos muito longos ou complexos, mas mesmo que pareça inteligente, o código pode não ser muito claro.

Você deve sempre se esforçar para tornar seu código fácil de entender – se você pode escrever um script em uma linha, faça-o! Você pode dividir um problema complexo em partes menores ou remover códigos desnecessários. O objetivo é reduzir a complexidade e resolver problemas, não impressionar as pessoas.

Usar nomes de variáveis ​​amigáveis ​​é outra maneira de facilitar as coisas. Não se esqueça de usar bibliotecas de codificação e ferramentas existentes.

2. Não se repita (DRY)

Os programadores adoram a sigla, certo? Isso é apenas para lembrar – ele diz para você não repetir o código. A repetição é um erro comum porque se você duplicar dados, lógica ou função, seu código ficará longo e levará mais tempo para manter, depurar ou alterar.

A repetição de si mesmo envolve copiar e colar código em seu programa. Em vez de duplicar linhas, é melhor encontrar um algoritmo que use um loop, pois é muito mais fácil depurar um único loop que lida com 20 repetições do que 20 blocos de código, cada um com uma repetição.

O oposto do princípio DRY é WET (é claro), que significa “Escreva tudo duas vezes ou desperdice o tempo de todos”. Nenhuma das duas é uma boa ideia.

Fonte da imagem: TechTarget

3. Você não vai precisar (YAGNI)

Em um tópico semelhante, você não deve escrever código apenas para o caso de precisar dele no futuro. Em outras palavras, o princípio YAGNI diz para você apenas escrever código para a situação atual, em vez de tentar resolver um problema que não existe.

Recursos e funcionalidades só devem ser adicionados quando necessário. Caso contrário, seu software ou programa ficará maior e mais complexo do que o necessário. YAGNI vem da metodologia de desenvolvimento de software Extreme Programming (XP), que visa reduzir ineficiências.

Às vezes, os programadores quebram esse princípio ao tentar seguir as práticas de codificação DRY, portanto, lembre-se de ambos.

4. Documente seu código

Então você escreveu seu código e o entendeu (espero!). Mas só porque faz sentido para você não significa que será entendido por outra pessoa. Você pode ajudar seus colegas desenvolvedores documentando seu código com comentários e melhorando os nomes de suas variáveis ​​e funções.

Por exemplo, se você estiver desenvolvendo um algoritmo de roteamento de chamadas para uso em soluções de call center VoIP, poderá deixar comentários para explicar os vários recursos e torná-los mais fáceis de entender por outros desenvolvedores ou testadores.

Todas as linguagens de programação permitem que você adicione comentários ao seu código, então você deve tornar isso um hábito. Sim, é um pouco de trabalho extra, mas é importante ao colaborar com outras pessoas. Além disso, se você voltar para alterar o código em alguns meses, ficará feliz por ter feito isso!

Fonte da imagem: SheCanCode

5. Composição sobre herança

Se você estiver reutilizando o código que já escreveu, há duas maneiras de fazer isso: herança e composição. A maioria dos programadores prefere a composição (embora a herança tenha suas vantagens, então não a ignore completamente).

O princípio de composição sobre herança é especialmente útil se você estiver usando programação orientada a objetos ou OOP (que na verdade tem seu próprio conjunto de princípios). Ele diz que objetos com comportamento complexo devem conter instâncias de objetos com comportamento individual – eles não devem herdar a classe e adicionar novos comportamentos.

Com a herança, as estruturas de classes rapidamente se tornam pesadas, resultando em muitas classes que podem ou não atender às suas necessidades. Hierarquias de classe são difíceis de mudar depois de implantadas porque você não pode mudar a superclasse sem correr o risco de quebrar a subclasse do usuário. E menos flexibilidade para definir o comportamento em casos especiais.

A programação composicional é mais fácil de escrever e manter, fornecendo uma base de código mais simples e testável. Isso permite que você defina o comportamento que define a flexibilidade – você pode criar classes para adicionar ou alterar facilmente e adiar a criação de componentes até que você precise deles.

6. Abrir/Fechar

Se você estiver lançando uma biblioteca ou estrutura que outros usarão, Aberto/Fechado é um princípio importante. Isso significa que os artefatos de software, como classes e módulos, estão abertos à extensão, mas fechados à modificação. Isso torna o código mais estável e fácil de manter.

Digamos que você foi solicitado a escrever o código de um modelo de contrato de agência para uma empresa de software de assinatura digital>. Você libera uma versão da estrutura para que os programadores possam modificar e integrar diretamente o código que você libera. Mas se você lançar uma atualização importante no futuro, o código será interrompido. É melhor lançar um código que incentive a extensão, mas evite a modificação direta, minimizando o risco de introduzir novos bugs.

7. Responsabilidade exclusiva

Esse princípio afirma que cada classe ou módulo em um programa deve fornecer apenas uma funcionalidade específica e não deve haver mais de um motivo para alterar uma classe. O objetivo é evitar a multiplicação de efeitos colaterais ou responsabilidades no mesmo método ou classe.

Fonte da imagem: meio

As classes ficam mais complicadas se você adicionar muitas responsabilidades e é mais difícil criar funcionalidade extra para um módulo específico. É melhor dividi-los em classes e módulos menores para facilitar o isolamento de um módulo específico para solução de problemas.

Responsabilidade única e aberto/fechado fazem parte dos princípios SOLID descritos por Robert S. Martin (os outros são substituição de Liskov, separação de interface e inversão de dependência).

8. SoC – separação de preocupações

Este princípio de programação é uma versão abstrata da responsabilidade única. O SoC afirma que o programa deve ser desenvolvido usando contêineres diferentes, que não devem ser capazes de acessar uns aos outros. Cada pedaço de código é completamente independente.

É uma maneira de dividir um aplicativo complexo em diferentes seções ou domínios, cada um dos quais executa um trabalho específico ou executa diferentes tarefas. Isso torna mais fácil manter, atualizar, reutilizar e depurar seu código.

Um exemplo bem conhecido é o design Model-View-Controller (MVC) usado atualmente em estruturas populares da Web. O programa é dividido em três seções separadas: dados (modelo), lógica (controlador) e o que o usuário final vê (visão), e cada seção é processada de forma independente.

9. Minimize a comunicação

A vinculação de código ocorre quando dois módulos ou dois níveis têm algum grau de interdependência, como compartilhar código ou acessar os mesmos dados. Isso pode criar problemas, incluindo código difícil de rastrear e manter.

Por exemplo, se um desenvolvedor vincular seus terminais de API a uma visualização específica em um aplicativo externo, como um sistema telefônico multilinha, o terminal não poderá ser reutilizado para outra visualização, como um aplicativo móvel. (Você deve estar se perguntando: o que é um sistema telefônico multilinha>?)

Os programadores precisam entender como o código está vinculado para minimizar a comunicação, o que inclui entender as responsabilidades de cada camada. A responsabilidade única também reduz o acoplamento entre software separado e componentes de código.

Fonte da imagem: Tripulação

10. Refatoração

As bases de código estão em constante evolução, portanto, haverá momentos em que você precisará revisitar, reescrever ou redesenhar trechos inteiros de código. Em vez de ver isso como um fracasso na primeira tentativa, pense nisso como uma oportunidade de aprendizado.

Refatorar o código significa analisá-lo e procurar maneiras de otimizá-lo, torná-lo mais eficiente e manter o mesmo resultado. No entanto, a otimização prematura deve ser evitada. Não otimize seu algoritmo no início do desenvolvimento porque você não pode prever gargalos e requisitos podem mudar.

Pensamentos finais

Se fôssemos resumir esta lista a um princípio-chave, seria: torne seu código fácil de entender e manter. Vários princípios de programação em nossa lista atendem a esse propósito, desde KISS e DRY até responsabilidade única e documentação de seu código.

Se você seguir esses princípios, poderá criar um código simples que faça o que deve fazer e seja compreensível para outras pessoas. E você saberá quando otimizá-lo. E o último conselho – continue aprendendo para continuar melhorando.