código deve ser curto / conciso? [fechadas]

https://stackoverflow.com/questions/952194

math
proof

11-09-2019
|

Pergunta

Ao escrever uma prova matemática, uma meta é continuar comprimindo a prova. A prova fica mais elegante, mas não necessariamente mais legível. Compressão se traduz em uma melhor compreensão, como você eliminar caracteres desnecessários e verbosidade.

Eu ouvi muitas vezes os desenvolvedores dizem que você deve fazer o seu pé impressão de código tão pequeno quanto possível. Isso pode muito rapidamente produzir código ilegível. Em matemática, não é uma questão como essa desde que o exercício é puramente acadêmico. No entanto, no código de produção, onde o tempo é dinheiro, tendo as pessoas tentam descobrir o que algum código muito concisa está fazendo não parece fazer muito sentido. Para um pouco mais detalhado código, você começa a legibilidade e poupança.

Em que ponto você parar de comprimir código de software?

Solução

I tentar chegar a um nível de detalhamento que minhas declarações programa lê como uma sentença de qualquer programador poderia entender. Isto significa fortemente refatoração meu código tal que é todos os pequenos pedaços de uma história, de modo que cada ação seria descrito em um método separado (um ainda mais nível poderia ser a de outra classe).

Significado eu não iria reduzir o meu número de caracteres só porque ele pode ser expresso em menos. Isso é o que competições code-golfe estão a fazer.

Outras dicas

A minha regra é dizer o que você quer dizer . Uma maneira comum que eu vejo as pessoas vão errado é "redução de força." Basicamente, eles substituem o conceito que eles estão pensando com algo que parece ignorar as etapas. Infelizmente, eles estão deixando conceitos fora de seu código, tornando-o mais difícil de ler.

Por exemplo, alterar

for (int i = 0; i < n; i++)
    foo[i] = ...

para

int * p = foo, q = foo+n;
while ( *p++ = ... < q );

é um exemplo de uma redução da força que parece salvar as etapas, mas deixa de fora o fato de que foo é um array, tornando-o mais difícil de ler.

Outro comum é usar bool em vez de uma enumeração.

enum {
    MouseDown,
    MouseUp
};

Tendo esta seja

bool IsMouseDown;

deixa de fora o fato de que esta é uma máquina de estado, tornando o código mais difícil de manter.

Assim, a minha regra de ouro seria, na sua implementação, não cavar para baixo para um nível mais baixo do que os conceitos que você está tentando expressar.

Você pode tornar o código mais pequenos, vendo redundância e eliminá-lo, ou por ser inteligente. Fazer o primeiro e não o último.

Aqui está um bom artigo de Steve McConnell - Melhores Práticas http://www.stevemcconnell.com/ IEEE Software / bp06.htm

Eu acho que a curto / conciso são dois resultados de código bem escrito. Há muitos aspectos ao código fazer bons e muitos resultados de código bem escrito, percebe os dois são diferentes. Você não planejar para uma pequena cópia do pé, você planeja para uma função que é conciso e faz uma única coisa extremamente bem - Isso deve levar a uma pequena cópia do pé (mas não). Aqui está uma pequena lista do que gostaria de focar ao escrever código:

funções focadas individuais - uma função deve fazer apenas uma coisa, uma simples entrega, multi funções de destaque são buggy e não é facilmente reutilizável
fracamente acoplada - não chegar a partir de dentro de uma função para dados global e não dependem fortemente de outras funções
nomenclatura precisa - de uso significativo variável nomes precisos, nomes crípticos são apenas isso
manter o código simples e não complexa - não sobre a linguagem específica uso técnico wow de, bom para impressionar os outros, difícil de entender e manter facilmente - Se você adicionar algo comentário 'especial' que assim, pelo menos as pessoas possam apreciá-lo antes amaldiçoando-lo
uniformemente comentário - a muitos comentários serão ignorados e ultrapassada a poucos têm nenhum significado
formatação - orgulho take na forma como os olhares de código, código corretamente recuado ajuda
trabalho com a mente de uma pessoa a manutenção do código - pensar o que seria como para manter o código que você está escrita
tenha medo ou preguiça de refatorar - Nada é perfeito pela primeira vez, limpar sua própria bagunça

Uma maneira de encontrar um equilíbrio é procurar legibilidade e não concisa-ness. Os programadores são constantemente analisando código visualmente para ver o que está sendo feito, e assim o código deve, tanto quanto possível fluxo bem.

Se o programador está digitalizando o código e atinge uma seção que é difícil de entender, ou preciso algum esforço para visualmente análise e entender, é uma coisa ruim. Usando comuns construções bem compreendidos é importante, ficar longe da vaga e pouco usado a menos que necessário.

Os seres humanos não são compiladores. Compiladores podem comer as coisas e manter em movimento. código obscura não está mentalmente consumida por seres humanos como o código rapidamente claramente compreendido.

Às vezes é muito difícil de produzir código legível em um algoritmo complicado, mas na maioria das vezes, a legibilidade humana é o que devemos procurar, e não esperteza. Eu não acho que o comprimento de código é realmente uma medida de clareza também, porque às vezes um mais detalhado método é mais legível do que um método conciso, e por vezes um método conciso é mais legível do que um longo.

Além disso, comentários só devem complementar, e não deve descrever o seu código, o código deve descrever-se. Se você tem a comentar uma linha, porque não é óbvio o que é feito, o que é mau. Leva mais tempo para a maioria dos programadores experientes para ler uma explicação Inglês que ele faz para ler o código em si. Acho que o livro Código martelos completos esta casa.

Quanto nomes de objetos ir, o pensamento sobre este passou por uma evolução com a introdução de novas linguagens de programação.

Se você pegar as línguas "chaveta", começando com C, concisão foi considerada a alma da sagacidade. Então, você teria uma variável para conter um valor de empréstimo com o nome "lv", por exemplo. A ideia era que você estava escrevendo um monte de código, de modo a manter as teclas a um mínimo.

Em seguida, veio o Microsoft-sancionado "notação húngara", onde as primeiras letras de um nome de variável foram feitos para indicar o seu tipo subjacente. Pode-se usar "FLV", ou algo assim, para indicar que o valor do empréstimo foi representada por uma variável float.

Com Java, e, em seguida, C #, o paradigma tornou-se um dos clareza. Um bom nome para uma variável de valor do empréstimo seria "loanValue". Eu acredito que parte da razão para isso é o recurso de conclusão de comando na maioria dos editores modernos. Desde a sua não é necessário digitar um nome inteiro mais, assim como você pode usar como muitos personagens, como é necessário para ser descritivo.

Esta é uma tendência boa. Código precisa ser inteligível. Os comentários são muitas vezes adicionados como uma reflexão tardia, se em tudo. Eles também não são atualizados como o código é atualizado, então eles se tornam desatualizados. Descritivo, bem escolhido , nomes de variáveis ??são o primeiro melhor e mais fácil, para que os outros saibam que você estava de codificação aproximadamente.

Eu tinha um professor de ciência da computação que disse: "Como engenheiros, estamos constantemente criando tipos de coisas que nunca existiram antes. Os nomes que nós damos-lhes vai ficar, por isso, devemos ter o cuidado de nomear as coisas significativamente . "

É preciso haver um equilíbrio entre o código-fonte doce curto e desempenho. Se é bom fonte e corre o mais rápido, em seguida, bom, mas por uma questão de boa fonte que é executado como um cão, então ruim.

Esforce-se para refatorar até o próprio código lê bem. Você vai descobrir seus próprios erros no processo, o código será mais fácil de grok para o "próximo cara", e você não será sobrecarregado por manter (e mais tarde se esquecer de mudança) nos comentários o que você já está expressos em código.

Quando isso falha ... com certeza, me deixe um comentário.

E não me diga "o que" no comentário (que é o que o código é para), diga-me "porquê".

Ao contrário de longo / caminhadas? Claro!

Mas se chega ao ponto em que é tão curto e tão concisa que é difícil de entender, então, que você tenha ido longe demais.

Sim. Sempre.

DRY : Do not Repeat Yourself. Isso lhe dará um código que é conciso e seguro. Escrever o mesmo código várias vezes é uma boa maneira de torná-lo difícil de manter.

Agora, isso não significa que você deve fazer uma função de quaisquer blocos de código procurando remotamente parecidos.

Um erro muito comum (horror?), Por exemplo, é factorizing código fazendo quase a mesma coisa, e para lidar com as diferenças entre as ocorrências adicionando uma bandeira para a função API. Isto pode parecer inócuos no início, mas gera código fluir difícil de entender e erro propenso, e ainda mais difícil refatorar.

Se você seguir as regras de refatoração comuns (olhando sobre o código cheiros) seu código se tornará mais e mais concisa como um efeito colateral como muitos cheiros de código está prestes a detecção de redundância.

Por outro lado, se você tentar tornar o código mais curto possível não seguir todas as orientações meaningfull, em algum momento você vai ter que parar porque você simplesmente não vai ver mais como reduzir código.

Imagine se o primeiro passo é remover todos os espaços em branco inúteis ... depois que o código passo na maioria das linguagens de programação se tornará tão difícil de ler, você não terá muita chance de encontrar qualquer outro realce possível.

O exemplo acima é bastante caricatural, mas não tão longe do que você obtém quando se tenta otimizar para tamanho sem seguir qualquer orientação sensata.

Não há nenhuma linha exata que pode ser tirada de distinguir entre código que é simplista e código que é florido. Use o bom senso. Têm outros olham para o seu código e ver como facilmente se pode compreendê-lo. Mas lembre-se, exatidão é o objetivo número 1.

A necessidade de pequenas pegadas de código é um retrocesso desde os dias de linguagem assembly e as línguas primeiro ligeiramente alto nível ... há pequenas pegadas de código onde uma necessidade real e urgente. Esses dias, porém, não é tanto de uma necessidade.

Dito isso, eu odeio detalhado código. Onde eu trabalho, nós escrevemos código que lê tanto quanto possível como uma linguagem natural, sem qualquer gramática extra ou palavras. E nós não abrevie nada menos que seu uma abreviatura muito comum.

Company.get_by_name("ABC") 
makeHeaderTable()

é tão concisa como vamos nós.

Em geral, eu fazer as coisas óbvias e fáceis de trabalhar. Se concisão / falta me serve em que extremidade, todo o melhor. Muitas vezes, respostas curtas são as mais claras, então falta é um subproduto do óbvio.

Há um par de pontos para minha mente que determinam quando parar de otimização:

Worth de gastar otimizações tempo realizando. Se você tem pessoas passando semanas e não encontrar nada, existem melhores usos desses recursos?
Qual é a ordem de prioridade de otimização. Existem alguns fatores diferentes que se poderia se preocupam quando se trata de código: O tempo de execução, espaço de execução (tanto correr e apenas o código compilado), escalabilidade, estabilidade, quantos recursos são implementados, etc. Parte disso é o comércio off de tempo e espaço, mas também pode estar onde faz algum movimento de código, por exemplo, pode middleware executar comandos SQL ad hoc ou aqueles deve ser encaminhado através de procedimentos armazenados para melhorar o desempenho?

Eu acho que o ponto principal é que há um moderação que a maioria das boas soluções terá.

As otimizações de código tem pouco a ver com o estilo de codificação. O fato de que o arquivo contém espaços x ou novas linhas menos do que no início não o torna melhor ou mais rápido, pelo menos na fase de execução - você formatar o código com caracteres brancos que são unsually ignorados pelo compilador. Ele ainda faz com que o código pior, porque se torna ilegível para os outros programadores e você mesmo.

É muito mais importante para o código para ser curto e limpo em sua estrutura lógica, tais como condições de teste, controle de fluxo, suposições, tratamento de erros ou a interface de programação geral. É claro, também gostaria de incluir comentários aqui inteligentes e úteis + a documentação.

Não há necessariamente uma correlação entre o código conciso e desempenho. Isso é um mito. Em idiomas maduros como C / C ++ os compiladores são capazes de optimizar o código de forma muito eficaz. Não é motivo necessidade em tais línguas assumir que o código mais conciso é o código de melhor desempenho. Mais recentes, línguas menos com desempenho otimizado como Ruby não têm a otimização do compilador apresenta de compiladores C / C ++, mas ainda há pouca razão para acreditar que o código conciso é um desempenho melhor. A realidade é que nunca sabemos como código bem irá realizar em produção até que ele entra em produção e é perfilado. Simples, inócuos, as funções podem ser enormes gargalos de desempenho se for chamado a partir de locais suficientes dentro do código. Em sistemas altamente simultâneas as maiores gargalos são geralmente causada por algoritmos pobres simultaneidade ou bloqueio excessivo. Estas questões são raramente resolvidos por escrever código "concisa".

A linha de fundo é esta: Código que executa mal pode sempre ser reformulado uma vez profiling determina que é o gargalo. Código só pode ser efetivamente reformulado se é fácil de entender. Código que é escrito para ser "concisa" ou "inteligente" é muitas vezes mais difícil refatorar e manter.

Escreva o seu código para facilitar a leitura humana, em seguida, refatorar para o desempenho quando necessário.

Os meus dois centavos ...

Código deve ser curto, concreto, e concentrada. Você sempre pode explicar as suas ideias com muitas palavras em comentários .

Você pode tornar seu código mais curto ou compacto que quiser, contanto que você comentá-lo. Desta forma, o código pode ser otimizado, mas ainda fazer a identificação. I tendem a ficar no lugar do meio com variáveis ??e métodos descritivos e comentários sparce se ainda não está claro.

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow