O que significa escrever "bom código"? [fechadas]

Em esta questão perguntei se ser um mau dificulta escritor-lo de escrever código bom. Muitas das respostas iniciadas com "depende do que você quer dizer com bom código".

Parece que o termo "código bom" e "código incorreto" são muito subjetivos. Desde que eu tenho uma visão, pode ser muito diferente da visão dos outros sobre eles.

Então, o que significa escrever "bom código"? O que é "bom código"?

Um bom codificador é como um bom jogador de sinuca.

Quando você vê um jogador profissional de sinuca, a princípio você não fica impressionado: "Claro, eles conseguiram todas as bolas, mas só tiveram chances fáceis!" Isso ocorre porque, quando um jogador de sinuca está fazendo seu arremesso, ela não pensa em qual bola entrará em qual bolso, ela também está pensando em onde a bola branca vai parar . A preparação para a próxima cena exige muita habilidade e prática, mas também significa que parece fácil.

Agora, trazendo essa metáfora para o código, um bom codificador escreve um código que parece fácil e direto de fazer . Muitos dos exemplos de Brian Kernighan em seus livros seguem esse padrão. Parte do "truque" é apresentar uma conceituação adequada do problema e sua solução . Quando não entendemos um problema suficientemente bem, é mais provável que complicemos demais nossas soluções e deixaremos de ver idéias unificadoras.

Com uma conceituação adequada do problema, você obtém tudo o mais: legibilidade, manutenção, eficiência e correção. Como a solução parece tão direta, provavelmente haverá menos comentários, porque uma explicação extra é desnecessária. Um bom codificador também pode ver a visão de longo prazo do produto e formar suas conceituações de acordo.

( original )

EDIT: A idéia básica é que "Código de Qualidade" não pode ser colocado em regras, da mesma forma que você não pode colocar "Boa arte" ou "Boa poesia" em regras para permitir que um computador determine "Sim, boa arte" ou "Não, má poesia". Atualmente, a única maneira é ver quão facilmente é compreensível o código para outros seres humanos.

Realmente não há bons critérios além da rapidez com que você pode entender o código. Você faz com que seu código tenha uma boa aparência, encontrando o compromisso perfeito entre sucessão e legibilidade.

O "WTF por minuto" (acima) é verdadeiro, mas é apenas um corolário da regra mais geral. Quanto mais WTFs, mais lento será o entendimento.

Você sabe que escreve um bom código quando ...

1. O cliente está feliz
2. Colegas de trabalho emprestam seu código como ponto de partida
3. Foi-lhe dito ao novato / a novinho para fazer modificações em um sistema que você construiu 6 meses atrás e ele / ela nunca fez uma pergunta a você uma vez
4. Seu chefe pede que você desenvolva novos widgets para a equipe usar
5. Você olha para o código que escreve hoje e diz para si mesmo "Eu gostaria de ter escrito código assim há dois anos"

Como você mede se o código é bom ...

• Qual é o tempo de resposta?
• Quantas viagens de ida e volta ao servidor ele faz?
• Você usaria pessoalmente o aplicativo ou acha que é desajeitado?
• Você construiria da mesma maneira da próxima vez?

Um bom código funciona quando deveria. Um bom código pode ser facilmente modificado quando necessário. Um bom código pode ser reutilizado para obter lucro.

Um código que é

1. livre de erros

2. reutilizável

3. independente

4. menos complexo

5. bem documentado

6. fácil de mudar

é chamado de bom código.

Um bom programa funciona perfeitamente e não possui bugs. Mas que qualidades internas produzem essa perfeição? Não é nenhum mistério, só precisamos de alguns lembretes ocasionais. Se você codifica em C / C ++, C #, Java, Basic, Perl, COBOL ou ASM, toda boa programação exibe as mesmas qualidades consagradas pelo tempo: simplicidade, legibilidade, modularidade, camadas, design, eficiência, elegância e clareza. e clareza

Fonte: MSDN

Isso parece familiar?

A Philips me deu a oportunidade de assistir ao design de um novo produto. À medida que se desenvolvia, fiquei cada vez mais desconfortável e comecei a confidenciar minhas preocupações ao meu supervisor. Eu repetidamente disse a ele que os desenhos não eram "limpos" e que deveriam ser "bonitos" da maneira que os desenhos de Dijkstra eram bonitos. Ele não achou esse comentário útil. Ele me lembrou que éramos engenheiros, não artistas. Em sua mente, eu estava simplesmente expressando meu gosto e ele queria saber qual critério eu estava usando para fazer meu julgamento. Eu não consegui contar a ele! Como não consegui explicar quais princípios estavam sendo violados, meus comentários foram simplesmente ignorados e o trabalho continuou. Sentindo que deve haver uma maneira de explicar e motivar meu "gosto", Comecei a tentar encontrar um princípio que distinguisse bons projetos dos maus. Engenheiros são muito pragmáticos; eles podem admirar a beleza, mas buscam utilidade. Tentei encontrar uma explicação de por que "beleza" era útil.

Por favor, veja o resto aqui .

além dos critérios de qualidade do código natural (mínimo de copiar / colar, sem esparguete etc.), um bom código industrial deve sempre parecer um pouco ingênuo, um pouco detalhado demais, como

int key = i;
const bool do_not_create = false;
Record r = cache.get(key, do_not_create);
++i;

em oposição a

Record r = cache.get(i++, false);

Talvez uma resposta ilustrando o contrário ajudaria (além de ser uma desculpa para obter o XKCD aqui).

Bom código é

• simples de entender,
• de fácil manutenção,
• não tenta resolver todos os problemas, apenas o que está à mão
• vive por um longo tempo sem fazer os desenvolvedores procurarem alternativas

Exemplos incluem

• Apache Commons
• Quadro de primavera
• Estrutura de hibernação

Vou simplesmente ir com "mantenedor"

Todo o código deve ser mantido: não é necessário que essa tarefa seja mais difícil do que o necessário

Se algum leitor não entender esse requisito simples ou precisar que ele seja explicitado, esse leitor não deverá escrever código ...

O bom código será diferente para cada pessoa e o idioma com o qual eles estão trabalhando também afeta o que pode ser considerado um bom código. Geralmente, quando abordo um projeto, procuro o seguinte:

• Como o projeto é organizado? Os arquivos de origem são organizados de maneira limpa e posso encontrar código sem muito esforço?
• Como o código está organizado? Está claramente documentado o que o código do arquivo faz, como o uso de um cabeçalho de arquivo ou o uso de cada classe que reside em seu próprio arquivo? Existem funções no arquivo que não estão mais sendo usadas no aplicativo?
• Como são organizadas as funções? Existe um padrão claro de onde as variáveis ​​são declaradas ou é um padrão bastante aleatório? O código possui um fluxo lógico e evita estruturas de controle desnecessárias? Tudo está claramente documentado, com o código sendo auto-documentado, onde necessário e os comentários expressando claramente o porquê e / ou como o que o código está fazendo?

Além de tudo isso, o design do aplicativo faz sentido como um todo? O código que reside no aplicativo pode ser o melhor do mundo, mas ainda pode ser difícil trabalhar se o design geral do aplicativo não fizer sentido.

Permitam-me que discorde gentilmente da legibilidade. Não, não completamente: um bom código deve ser legível e isso pode ser facilmente alcançado com comentários suficientes.

Mas considero dois tipos de WTF: aqueles em que você se pergunta se o programador foi além da programação 101 e aqueles em que você absolutamente não entende a genialidade do código. Alguns códigos podem parecer muito estranhos no começo, mas na verdade são uma solução muito inventiva para um problema difícil. O segundo não deve contar no medidor WTF e pode ser evitado por comentários.

Código muito legível pode ser muito, muito lento. Uma solução menos legível pode proporcionar muitas melhorias na velocidade. R é um ótimo exemplo de uma linguagem em que isso geralmente é verdade. Gosta-se de evitar loops o máximo possível. Em geral, considero o código mais rápido o melhor, mesmo que seja menos legível. Ou seja, se a melhoria for substancial fora do curso e forem inseridos comentários suficientes para explicar o que o código faz.

Ainda mais, o gerenciamento de memória pode ser crucial em muitas aplicações científicas. Código que é muito legível, tende a ser meio desleixado no uso da memória: há apenas mais objetos criados. Em alguns casos, o uso inteligente da memória torna o código novamente menos legível. Mas se você manipular gigabytes de seqüências de DNA, por exemplo, a memória é um fator crucial. Novamente, considero o código menos intensivo em memória o melhor código, independentemente da legibilidade.

Então, sim, a legibilidade é importante para um bom código. Conheço o adágio de Uwe Liggis: pensar dói e computadores são baratos. Mas no meu campo (genômica estatística), os tempos computacionais de uma semana e o uso de memória acima de 40 Gb não são considerados anormais. Portanto, uma melhoria de duas vezes a velocidade e metade da memória vale muito mais do que esse pouco mais de legibilidade.

No que diz respeito a mim ... eu sei que estou escrevendo um bom código quando um colega de trabalho que trabalha em outro projeto aparece e é capaz de entender e entender o que estou fazendo sem que eu revise cada bloco de código e mostrando o que está fazendo.
Em vez de ele dizer: "Espere um minuto, o que ?!" Ele está dizendo: "Oh, ok, eu vejo o que você fez lá".

Um bom código também não possui muitas soluções alternativas ou 'hacks' furtivos. Linhas quando, enquanto você está escrevendo, também está dizendo a si mesmo: "Eu sei que essa não é uma boa maneira de fazer isso, mas só vou ter que fazer dessa maneira por enquanto. Vou lembrar para melhorá-lo mais tarde ... "

Existem muitos recursos de código 'bom', mas o mais importante, IMHO, é a legibilidade e a manutenção.

Seu código irá conter bugs, irá provavelmente ser ampliado e re-utilizados, e deve estar em algum ponto consignado-re - mesmo que seja você re visitar-lo, as chances são que você não terá uma idéia do que o inferno você fez em primeiro lugar, fazer um favor a si mesmo e não colocar barreiras no caminho.

Claro, use esse algoritmo complexo, porém super eficiente, mas gaste um pouco de tempo extra para documentá-lo, mas, caso contrário, torne seu código claro e consistente.