Como é o código de um bom programador? [fechadas]

Eu sou um programador amador (comecei com VBA para tornar o Excel mais rápido) e tenho trabalhado com VB.NET / C # .NET e estou tentando aprender ADO.NET.

Uma faceta da programação que sempre me frustrou é como é "bom"? Eu não sou um profissional, então tenho pouco para comparar. O que torna um programador melhor? É isso:

• Eles têm um melhor entendimento de todos os objetos / classes / métodos em uma determinada linguagem?
• Seus programas são mais eficientes?
• O design de seus programas é muito melhor em termos de melhor documentação, boa escolha de nomes para funções etc.?

Dito de outra forma, se eu fosse olhar o código de um programador profissional, qual é a primeira coisa que eu notaria sobre o código dele em relação ao meu? Por exemplo, li livros como 'Professional ASP.NET' da Wrox Press. Os exemplos de código nesse livro são de 'classe mundial'? Esse é o pináculo? Algum programador top-gun olharia para aquele código e pensaria que era um bom código?

A lista abaixo não é abrangente, mas essas são as coisas em que pensei ao considerar sua pergunta.

• Um bom código é bem organizado. Dados e operações em classes se encaixam. Não existem dependências estranhas entre as classes. Não se parece com "espaguete".

• Bons comentários de código explicam por que as coisas são feitas e não o que é feito. O próprio código explica o que é feito. A necessidade de comentários deve ser mínima.

• Um bom código usa convenções de nomenclatura significativas para todos, exceto para os objetos mais transitórios. o nome de algo é informativo sobre quando e como usar o objeto.

• Um bom código é bem testado. Os testes servem como uma especificação executável do código e exemplos de seu uso.

• Um bom código não é "inteligente". Ele faz as coisas de maneiras simples e óbvias.

• Um bom código é desenvolvido em unidades de computação pequenas e fáceis de ler. Essas unidades são reutilizadas em todo o código.

Ainda não li, mas o livro que planejo ler sobre esse assunto é Código Limpo, de Robert C. Martin.

A primeira coisa que você notará é que seu código segue um estilo de codificação consistente . Eles sempre escrevem seus blocos de estrutura da mesma forma, recuam religiosamente e comentam quando apropriado.

A segunda coisa que você notará é que seu código é segmentado em pequenos métodos / funções que abrangem no máximo algumas dezenas de linhas. Eles também usam nomes de métodos autodescritivos e geralmente seu código é muito legível.

A terceira coisa que você notará, depois de mexer um pouco no código, é que a lógica é fácil de seguir, fácil de modificar - e, portanto, de fácil manutenção.

Depois disso, você precisará de algum conhecimento e experiência em técnicas de design de software para compreender as escolhas específicas que eles fizeram para construir sua arquitetura de código.

Em relação aos livros, não vi muitos livros em que o código pudesse ser considerado "de classe mundial". Nos livros, eles tentam principalmente apresentar exemplos simples, que podem ser relevantes para resolver problemas muito simples, mas não refletem situações mais complexas.

Citando Fowler, resumindo a legibilidade:

Qualquer idiota pode escrever um código que um computador possa entender.
Bons programadores escrevem códigos que humanos podem entender.

'nough disse.

Pessoalmente, terei de citar "The Zen of Python" de Tim Peters. Diz aos programadores Python como deve ser o seu código, mas descobri que se aplica basicamente a todo o código.

Belo é melhor do que feio.
Explícito é melhor do que implícito.
Simples é melhor que complexo.
Complexo é melhor do que complicado.
Plano é melhor do que aninhado.
O esparso é melhor do que o denso.
A legibilidade conta.
Casos especiais não são especiais o suficiente para quebrar as regras.
Embora a praticidade supere a pureza.
Os erros nunca devem passar silenciosamente.
A menos que seja explicitamente silenciado.
Diante da ambigüidade, recuse a tentação de adivinhar.
Deve haver uma - e de preferência apenas uma - maneira óbvia de fazer isso.
Embora esse caminho possa não ser óbvio no início, a menos que você seja holandês.
Agora é melhor do que nunca.
Embora nunca seja frequentemente melhor do quedireito agora.
Se a implementação for difícil de explicar, é uma má ideia.
Se a implementação for fácil de explicar, pode ser uma boa ideia.
Os namespaces são uma ótima ideia - vamos fazer mais disso!

Código é poesia.

Comece desse ponto de lógica e você poderá derivar muitas das qualidades desejáveis ​​do código. Mais importante ainda, observe que o código é lido muito mais do que escrito, portanto, escreva o código para o leitor. Reescrever, renomear, editar e refatorar para o leitor.

Um corolário de seguimento:

O leitor será você no momento n a partir da data de criação do código. A recompensa de escrever código para o leitor é uma função monotonicamente crescente de n. Um leitor olhando seu código pela primeira vez é indicado por n == infinito.

Em outras palavras, quanto maior for o intervalo de tempo entre o momento em que você escreveu o código e o momento em que o revisou, mais você apreciará seus esforços para escrever para o leitor. Além disso, qualquer pessoa a quem você entregue seu código obterá grande benefício do código escrito com o leitor como a consideração mais importante.

Um segundo corolário:

O código escrito sem consideração pelo leitor pode ser desnecessariamente difícil de entender ou usar. Quando a consideração para o leitor cai abaixo de um certo limite, o leitor obtém menos valor do código do que o valor obtido ao reescrever o código. Quando isso ocorre, o código anterior é jogado fora e, tragicamente, muito trabalho é repetido durante a reescrita.

Um terceiro corolário:

Sabe-se que o segundo corolário se repete várias vezes em um ciclo vicioso de código mal documentado, seguido de reescritas forçadas.

Eu programo há 28 anos e acho essa pergunta difícil de responder. Para mim, um bom código é um pacote completo. O código é escrito de forma limpa, com variáveis ​​significativas e nomes de métodos. Ele tem comentários bem colocados que comentam a intenção do código e não apenas regurgitam o código que você já pode ler. O código faz o que deve de maneira eficiente, sem desperdiçar recursos. Ele também deve ser escrito tendo em vista a sustentabilidade.

O ponto principal, porém, é que isso significa coisas diferentes para pessoas diferentes. O que posso rotular como bom código, alguém pode odiar. Um bom código terá alguns traços comuns que acho que identifiquei acima.

A melhor coisa que você pode fazer é se expor ao código. Observe o código de outras pessoas. Projetos de código aberto são uma boa fonte para isso. Você encontrará códigos bons e códigos ruins. Quanto mais você olha para isso, melhor reconhecerá o que considera um código bom e um código ruim.

Em última análise, você será seu próprio juiz. Quando você encontra estilos e técnicas que gosta de adotá-los, com o tempo você criará seu próprio estilo e isso mudará com o tempo. Não há ninguém aqui que possa acenar uma varinha e dizer o que é bom e que qualquer outra coisa é ruim.

Leia o livro Code Complete. Isso explica muitas idéias sobre como estruturar o código e os motivos para fazer isso. Lê-lo deve causar um curto-circuito em adquirir a experiência necessária para distinguir o bem do mal.

http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670/ref=pd_bbs_sr_1?ie=UTF8&s=books&qid=1229267173&sr=8-1

Tendo programado por quase 10 anos agora e tendo trabalhado com outras pessoas, posso dizer sem preconceito que não há diferença entre um bom programador e um código de programador médio

Todos os programadores em um nível competente:

• Comente corretamente
• Estruture com eficiência
• Documento de forma limpa

Certa vez, ouvi um colega de trabalho dizer " Sempre fui muito lógico e racional. Acho que é por isso que gosto de desenvolver "

Isso, na minha opinião, é a mente de um programador médio. Aquele que vê o mundo em termos de regras e lógica e, em última análise, obedece a essas regras ao projetar e escrever um programa.

O programador especialista entende as regras, mas também seu contexto. Em última análise, isso os leva a ter novas ideias e implementações, a marca de um programador especialista. A programação é, em última análise, uma forma de arte.

Colocado de forma sucinta, o código de um bom programador pode ser lido e compreendido.

Em minha opinião, o código de um bom programador é independente de linguagem ; um código bem escrito pode ser lido e compreendido em um curto espaço de tempo com o mínimo de pensamento, independentemente da linguagem de programação usada. Quer o código esteja em Java, Python, C ++ ou Haskell, um código bem escrito é compreensível por pessoas que nem mesmo programam nessa linguagem específica.

Algumas características do código que são fáceis de ler são: métodos bem nomeados, ausência de "truques" e "otimização" complicada, classes bem projetadas, para citar alguns. Como outros mencionaram, o estilo de codificação é consistente, sucinto e direto .

Por exemplo, outro dia, eu estava dando uma olhada no código do TinyMCE para responder a uma das perguntas no Stack Overflow. É escrito em JavaScript, uma linguagem que quase não usei. Ainda assim, por causa do estilo de codificação e dos comentários incluídos, junto com a estruturação do próprio código, era bastante compreensível e eu fui capaz de navegar pelo código em alguns minutos.

Um livro que me abriu os olhos no que diz respeito à leitura de um bom código de programador é Beautiful Code . Tem muitos artigos escritos por autores de vários projetos de programação em várias linguagens de programação. No entanto, quando li, pude entender o que o autor estava escrevendo em seu código, apesar do fato de nunca ter programado nessa linguagem em particular.

Talvez o que devamos ter em mente é que a programação também tem a ver com comunicação, não apenas com o computador, mas com as pessoas , então o código de um bom programador é quase como um livro bem escrito, que pode comunicar ao leitor as ideias que deseja transmitir .

• Fácil de ler
• fácil de escrever
• de fácil manutenção

todo o resto é filigrana

Um bom código deve ser facilmente compreendido.
Deve ser bem comentado.
As partes difíceis devem ser ainda melhor comentadas.

Um bom código é legível. Você não teria problemas para entender o que o código está fazendo na primeira leitura do código escrito por um bom programador profissional.

Em vez de repetir as ótimas sugestões de todos, vou sugerir que você leia o livro Code Complete, de Steve McConnell

Essencialmente, é um livro repleto de práticas recomendadas de programação para funcionalidade e estilo.

[Resposta puramente subjetiva]
Para mim, um bom código é uma forma de arte, assim como uma pintura. Eu poderia ir mais longe e dizer que é na verdade um desenho que inclui caracteres, cores, "forma" ou "estrutura" de código, e com tudo isso sendo legível / performante. A combinação de legibilidade, estrutura (ou seja, colunas, recuo, até mesmo nomes de variáveis ​​do mesmo comprimento!), Cor (nomes de classes, nomes de variáveis, comentários, etc.) fazem o que gosto de ver como uma imagem "bonita" que pode me deixa muito orgulhoso ou detestado do meu próprio código.

(Como disse antes, resposta muito subjetiva. Desculpe pelo meu inglês.)

Apoio a recomendação do "Código Limpo" de Bob Martin.

"Beautiful Code" foi muito aclamado alguns anos atrás.

Qualquer um dos livros de McConnell vale a pena ler.

Talvez "The Pragmatic Programmer" também seja útil.

%

Só queria adicionar meus 2 centavos ... comentários em seu código - e seu próprio código, geralmente - devem dizer o que seu código faz, agora como faz. Depois de ter o conceito de código 'cliente', que é o código que chama outro código (o exemplo mais simples é o código que chama um método), você deve sempre se preocupar em tornar seu código compreensível da perspectiva do "cliente". Conforme seu código cresce, você verá que isso é ... bom.

Muitas das outras coisas sobre um bom código são sobre os saltos mentais que você fará (definitivamente, se você prestar atenção) ... 99% deles têm a ver com fazer um pouco mais de trabalho agora para poupar uma tonelada de trabalho mais tarde, e reutilização. E também com fazer as coisas certas: quase sempre quero correr para o outro lado, em vez de usar expressões regulares, mas cada vez que entro nelas, vejo por que todos as usam em todas as linguagens em que trabalho (são obscuras, mas trabalho e provavelmente não poderia ser melhor).

Quanto a ler livros, eu diria que definitivamente não na minha experiência. Observe APIs, estruturas e convenções de código e o código de outras pessoas e use seus próprios instintos e tente entender por que as coisas são do jeito que são e quais são as implicações das coisas. O que o código nos livros quase nunca faz é planejar o não planejado, que é o objetivo da verificação de erros. Isso só compensa quando alguém lhe envia um e-mail e diz: "Recebi o erro 321" em vez de "ei, o aplicativo está quebrado, yo."

Um bom código é escrito com o futuro em mente, tanto da perspectiva do programador quanto da perspectiva do usuário.

Isso é respondido muito bem no livro de Fowler, "Refatoração". É a ausência de todos os "cheiros" que ele descreve ao longo do livro.

Eu não vi 'Professional ASP.NET', mas ficaria surpreso se for melhor do que OK. Veja esta questão para alguns livros com código realmente bom. (Isso varia, é claro, mas a resposta aceita é difícil de superar.)

Este parece ser (deveria ser) um FAQ. Existe um artigo ACMRecentemente, sobre códigos bonitos. Parece haver muita ênfase na facilidade de leitura / compreensão. Eu qualificaria isso com "fácil de ler / entender por especialistas de domínio". Os programadores realmente bons tendem a usar os melhores algoritmos (em vez dos algoritmos ingênuos e fáceis de entender O (n ^ 2)) para qualquer problema, o que pode ser difícil de seguir, se você não estiver familiarizado com o algoritmo, mesmo que o bom o programador fornece uma referência ao algoritmo.

Ninguém é perfeito, incluindo bons programadores, mas seu código tende a se esforçar para:

1. Correção e eficiência com algoritmos comprovados (em vez de hacks ingênuos e adhoc)
2. Clareza (comentário para intenção com referência a algoritmos não triviais)
3. Completude para cobrir o básico (convenção de codificação, controle de versão, documentação, testes de unidade etc.)
4. Sucinto (SECO)
5. Robustez (resiliente a entrada arbitrária e interrupção de solicitações de mudança)

Segundo a recomendação do "código limpo" do tio bob. mas você pode dar uma olhada em http://www.amazon.com/Implementation-Patterns-Addison-Wesley-Signature-Kent/dp/0321413091, pois acho que isso lida um pouco melhor com sua questão específica. um bom código deve pular da página e dizer o que faz / como funciona.

Jeff Atwood escreveu um bom artigo sobre como os codificadores são a primeira referência dos digitadores: http://www.codinghorror.com/blog/archives/001188.html

Ao ser um digitador, você sempre precisa ser elegante em seu trabalho, ter estrutura e "gramática" adequada é muito importante. Agora, converter isso para digitar "programação" teria o mesmo resultado.

Estrutura

Comentários

Regiões

Sou um engenheiro de software, o que significa que, durante minha educação, descobri muitas linguagens diferentes, mas minha programação sempre "parece" a mesma, assim como minha escrita em fekberg.wordpress.com, tenho uma forma "especial" de digitar.

Agora, programando diferentes aplicativos e em diferentes linguagens, como Java, C #, Assembler, C ++, C, cheguei ao "padrão" de escrita que gosto.

Eu vejo tudo como "caixas" ou regiões e cada região tem seus comentários explicativos. Uma região pode ser "classe Pessoa" e dentro desta região eu tenho alguns métodos para propriedades, que posso chamar de "Métodos de acesso" ou algo assim, e cada propriedade e região tem seus próprios comentários explicativos.

Isso é muito importante, sempre vejo meu código que eu faço, como "ser parte de uma API", quando criar uma estrutura de API e elegância é MUITO importante.

Pense sobre isso. Leia também meu artigo sobre o Communication issues when adapting outsourcingqual explica de maneira aproximada como códigos ruins podem entrar em conflito, Enterpret como quiser: http://fekberg.wordpress.com/2008/12/14/communication-issues-when-adapting-outsourcing/

Um bom código é fácil de entender, manter e adicionar. Idealmente, também é o mais eficiente possível, sem sacrificar outros indicadores.

Um bom código para mim é algo simples de entender, mas sofisticado. As coisas que te fazem pensar, "nossa, claro, por que não pensei nisso dessa forma?". Um código realmente bom não é difícil de entender; ele simplesmente resolve o problema em questão de maneira direta (ou recursiva, se for ainda mais simples).

Um bom código é onde você sabe o que o método faz a partir do nome. Código ruim é onde você tem que descobrir o que o código faz, para dar sentido ao nome.

Um bom código é onde, se você lê-lo, pode entender o que ele está fazendo em não muito mais tempo do que leva para lê-lo. Código ruim é onde você acaba olhando para ele por muito tempo tentando descobrir o que ele faz.

Um bom código tem coisas nomeadas de forma a tornar desnecessários comentários triviais.

Um bom código tende a ser curto.

Um bom código pode ser reutilizado para fazer o que faz em qualquer outro lugar, uma vez que não depende de coisas que realmente não estão relacionadas ao seu propósito.

Um bom código geralmente é um conjunto de ferramentas simples para realizar trabalhos simples (reunidos de maneiras bem organizadas para realizar trabalhos mais sofisticados). Códigos ruins tendem a ser enormes ferramentas multifuncionais fáceis de quebrar e difíceis de usar.

O código é um reflexo das habilidades e da mentalidade de um programador. Bons programadores sempre estão de olho no futuro - como o código funcionará quando os requisitos ou circunstâncias não forem exatamente o que são hoje. Quão escalável será? Quão conveniente será quando não sou eu quem mantém este código? O quão reutilizável o código será, de forma que outra pessoa fazendo coisas semelhantes possa reutilizar o código e não escrevê-lo novamente. E quando outra pessoa está tentando entender o código que escrevi.

Quando um programador tem essa mentalidade, todas as outras coisas se encaixam perfeitamente.

Nota: Uma base de código é trabalhada por muitos programadores ao longo do tempo e normalmente não há uma designação específica de base de código para um programador. Portanto, um bom código é um reflexo de todos os padrões da empresa e da qualidade de sua força de trabalho.

(Eu uso "ele" abaixo porque esta é a pessoa que eu aspiro ser, às vezes com sucesso).

Acredito que o cerne da filosofia de um bom programador é que ele está sempre pensando "Estou programando para mim mesmo no futuro, quando terei esquecido completamente esta tarefa, por que estava trabalhando nela, quais foram os riscos e até mesmo como isso o código deveria funcionar. "

Como tal, seu código deve:

1. Funcione (não importa o quão rápido o código chegue à resposta errada. Não há crédito parcial no mundo real).
2. Explique como ele sabe que esse código funciona. Esta é uma combinação de documentação (javadoc é minha ferramenta preferida), tratamento de exceções e código de teste. Em um sentido muito real, eu acredito que, linha por linha, o código de teste é mais valioso do que o código funcional se por nenhuma outra razão além de explicar "este código funciona, é assim que deve ser usado, e é por isso que eu deveria obter pago."
3. Ser mantida. Código morto é um pesadelo. A manutenção do código legado é uma tarefa árdua, mas deve ser feita (e lembre-se, é "legado" no momento em que sai de sua mesa).

Por outro lado, acredito que o bom programador nunca deve fazer estas coisas:

1. Obcecado com a formatação. Existem muitos IDEs, editores e impressoras bonitas que podem formatar o código exatamente de acordo com o padrão ou preferência pessoal que você considerar apropriado. Eu uso o Netbeans, configuro as opções de formato uma vez e clico em alt-shift-F de vez em quando. Decida como você deseja que o código seja, configure seu ambiente e deixe a ferramenta fazer o trabalho pesado.
2. Obcecado por convenções de nomenclatura em detrimento da comunicação humana. Se uma convenção de nomenclatura está conduzindo você no caminho de nomear suas classes como "IElephantProviderSupportAbstractManagerSupport" em vez de "Zookeeper", altere o padrão antes de tornar mais difícil para a próxima pessoa.
3. Esqueça que ele trabalha em equipe com seres humanos reais.
4. Esqueça que a principal fonte de erros de codificação está em seu teclado agora. Se houver um engano ou erro, ele deve primeiro olhar para si mesmo.
5. Esqueça que o que vai, volta. Qualquer trabalho que ele fizer agora para tornar seu código mais acessível para leitores futuros quase certamente o beneficiará diretamente (porque quem será a primeira pessoa a olhar seu código? Ele é).

1. Funciona
2. Possui testes de unidade que comprovam que funciona

O resto é cereja ...

• O melhor código tem uma certa elegância que você reconhece assim que o vê.
• Parece trabalhado, com cuidado e atenção aos detalhes. Obviamente, é produzido por alguém com habilidade e tem uma arte - você poderia dizer que parece esculpido e polido, ao invés de áspero e pronto.
• É consistente e de fácil leitura.
• É dividido em funções pequenas e altamente coesas, cada uma das quais faz uma coisa e a faz bem.
• É minimamente acoplado, o que significa que as dependências são poucas e estritamente controladas, geralmente por ...
• Funções e classes dependem de abstrações em vez de implementações.

Ironicamente, a melhor o programador a menos indispensável que ele / ela se torna porque o código produzido é melhor sustentável por qualquer pessoa (como indicado por consenso geral por Eran Galperin).

Minha experiência diz que o oposto também é verdadeiro. O pior que o programador o mais difícil manter sua / seu código é, por isso, mais indispensável que ele / ela se torna, uma vez que nenhuma outra alma pode entender os enigmas produzidos.

Eu tenho um bom exemplo:

Leia o código fonte do GWT (google web takenit), você verá que todo tolo o entende (alguns livros em inglês são mais difíceis de ler do que este código).