O que há de tão ruim na codificação criativa? [fechadas]

Eu estava assistindo Bob Ross pintando algumas "árvores felizes" hoje à noite, e descobri o que está me estressando sobre meu código recentemente.

A comunidade de pessoas aqui e no Stack Overflow parece rejeitar qualquer cheiro de imperfeição. Meu objetivo é escrever um código respeitável (e, portanto, sustentável e funcional), melhorando minhas habilidades. No entanto, eu codifico de forma criativa.

Deixe-me explicar o que quero dizer com "codificação criativa":

• Meus primeiros passos em um projeto são frequentemente sentar e basear algum código. Para coisas maiores, eu planejo um pouco aqui e ali, mas principalmente eu apenas mergulho.
• Não faço diagrama de nenhuma das minhas aulas, a menos que esteja trabalhando com outras pessoas que estão criando outras peças no projeto. Mesmo assim, certamente não é a primeira coisa que faço. Normalmente não trabalho em grandes projetos e não acho o visual muito útil.
• A primeira rodada de código que eu escrevo será reescrita muitas e muitas vezes quando eu testar, simplificar, refazer e transformar o hack original em algo reutilizável, lógico e eficiente.

Durante esse processo, estou sempre limpando. Eu removo o código não utilizado e comento qualquer coisa que não seja óbvia. Eu testei constantemente.

Meu processo parece ir contra o que é aceitável na comunidade de desenvolvedores profissionais, e eu gostaria de entender o porquê.

Eu sei que a maior parte das reclamações sobre códigos ruins é que alguém ficou preso na bagunça de um ex-funcionário, e isso custou muito tempo e dinheiro para consertar. Isso eu entendo. O que não entendo é como meu processo está errado, já que o resultado final é semelhante ao que você obteria ao planejar tudo desde o início. (Ou pelo menos, foi o que encontrei.)

Ultimamente, minha ansiedade em relação ao problema tem sido tão grave que parei de codificar até saber tudo sobre todos os métodos para resolver o problema específico em que estou trabalhando. Em outras palavras, eu parei de codificar por completo.

Agradeço sinceramente sua opinião, independentemente de suas opiniões sobre o assunto.

Edit: Obrigado a todos por suas respostas. Eu aprendi algo com cada um deles. Todos vocês foram muito úteis.

Não há nada errado com o código-teste-refatoração-repetição, basta dizer às pessoas que você está fazendo prototipagem.

Por outro lado, para projetos maiores, você descobrirá que um pouco de reflexão sobre o design inicial poupará muito tempo no ciclo do tipo "porcaria agora!"

PS: As técnicas de diagramação ajudam você a aprender habilidades de pensamento visual, que são valiosas mesmo que ninguém, exceto você, veja seus diagramas.

Eu sempre prefiro código claro, legível e simples a qualquer código UMLed, visualmente apresentado, com padrão de design, em que classe / interface inclui nomes de padrões como "ItemVisitor" (?!). Padrões de design, técnicas de OO e tudo mais são para formalizar regras. Essas regras vêm do senso comum.

É impossível trabalhar sem essa formalização (a menos que você trabalhe sozinho em seu próprio projeto) e a formalização excessiva aumenta os custos do projeto. Nunca desconsidere as necessidades de outras pessoas para entender seu código. O melhor código é o mais simples.

Nunca hesite em reescrever seu código. Vou receber X votos negativos (X> = 10) para isso, mas vou deixar em negrito: a reutilização do código não é a coisa mais importante .

Antes de iniciar a codificação , considere os casos de uso que esse código implementará. Porque o software é para ser usado, e não para ser desenvolvido. Usabilidade, utilidade são os dois alvos mais importantes e não importa quem usará esse software - outros desenvolvedores de partes dependentes do projeto ou o usuário final.

Eu sou da mesma maneira. Ouça quando outras pessoas lhe falarem sobre as coisas que funcionaram para elas, mas ignore qualquer pessoa que lhe diga o que você "deveria" estar fazendo como se houvesse algum imperativo moral nisso. Se você encontrar algo que funcione para você, vá em frente. Quero dizer, o resultado final é o que é importante, não é? Quem realmente se importa com o caminho que você seguiu para chegar lá?

Lembre-se: as pessoas são diferentes . É uma coisa boa. Não dê ouvidos às pessoas que tentam fazer você gostar delas, e resista ao desejo de fazer outras pessoas gostar de você e você se sairá bem.

Parece que você é:

1. Tentando coisas para encontrar a melhor abordagem (experimentação, design incremental)
2. Reescrevendo o código para torná-lo mais limpo (refatoração)
3. Constantemente escrevendo testes (desenvolvimento orientado a testes)

O que você está fazendo é incrível! Parece que você está fazendo tudo perfeitamente certo, especialmente se você descobriu por si mesmo e não aprendeu com um livro de programação (ágil). Obviamente, há mais do que isso, mas você tem os valores acertados. Lembre-se de refatorar e melhorar o design enquanto adiciona código e não deve haver necessidade de um BDUF .

Você já pensou em focar em um pequeno recurso de cada vez e liberá-lo após a conclusão de cada recurso? Isso pode ajudá-lo a se livrar de qualquer problema de análise com o qual esteja enfrentando e demonstra um progresso real para o seu empregador.

Além disso, não sei de que "comunidade de desenvolvimento profissional" você está falando, mas, se fosse, diria a eles para voltarem às suas torres de marfim para que você possa continuar seu trabalho!

Brad, você não está sozinho. Conheço bons programadores que trabalham exatamente da mesma maneira que você descreve. :)

Se você limpa seu código e sabe como torná-lo eficiente e legível, certamente também desenvolveu um senso de como escrever códigos limpos e eficientes com antecedência.

Além disso, nada pode ser totalmente planejado com antecedência, e o caminho mais curto para descobrir sutilezas é geralmente executar o código e entender os detalhes que foram ignorados.

Eu acho que você está indo perfeitamente bem, e que o estilo de programação que você descreve é ​​perfeitamente válido.

Eu acho que vale a pena completar as respostas acima com uma citação de Alan J. Perlis, do prefácio do conhecido livro do MIT "Estrutura e Interpretação de Programas de Computador", comumente chamado "SICP":

Todo programa de computador é um modelo, traçado na mente, de um processo real ou mental. Esses processos, decorrentes da experiência e do pensamento humanos, são enormes em número, intricados em detalhes e a qualquer momento apenas parcialmente compreendidos. Eles são modelados para nossa satisfação permanente, raramente por nossos programas de computador. Assim, mesmo que nossos programas sejam coleções discretas artesanais de símbolos, mosaicos de funções interligadas, eles evoluem continuamente: nós os mudamos à medida que nossa percepção do modelo se aprofunda, amplia, generaliza até que o modelo finalmente atinja um lugar metaestável em ainda outro modelo com o qual nós lutamos ".

Há boas e más espertas.

Boa Inteligência - alta proporção entre linhas de código inteligentes e linhas de uma alternativa não inteligente. 20 linhas de código que evitam que você escreva 20000 são extremamente boas. O Good Clever trata de salvar seu trabalho.

Bad Clever - baixa proporção entre linhas de código escritas e vs. linhas de código salvas. Uma linha de código inteligente que evita que você escreva cinco linhas de código é Bad Clever. Mau esperto é sobre "masturbação sintática".

Apenas para observar: Bad Clever quase nunca é chamado de "Bad Clever"; ele costuma viajar sob os pseudônimos "bonito", "elegante", "conciso" ou "sucinto".

Definitivamente, posso me reconhecer na maneira como você descreve seu fluxo de trabalho. Eis o seguinte: quando comecei a trabalhar em um ambiente de grupo, quase todas essas coisas tiveram que mudar.

O trabalho em que trabalho há cerca de 8 meses é realmente minha primeira experiência em trabalhar em uma equipe de desenvolvedores em um único projeto. Até agora, literalmente, toda a minha carreira foi como programador de lobo solitário que não precisava lidar com tudo o que vem com o trabalho em equipe. Mesmo quando eu trabalhava em grupo, era sempre um trabalho bastante isolado - eu tinha o meu projeto que era o MINE, ou a minha seção era o MINE, etc. ambiente de trabalho em equipe verdadeiramente colaborativo.

Aqui está a principal coisa que percebi: se não é óbvio o que você está fazendo, provavelmente está causando a próxima dor de cabeça de um colega. A maior parte da agitação "orientada para o processo" que você vê aqui tem a ver com o fato de muitos de nós ter sido o colega com dor de cabeça. E a maioria das teorias de gerenciamento de processos de software tem a ver com minimizar essa dor de cabeça.

Então, coisas como planejar um plano previamente combinado, etc ... Trata-se de ter uma equipe a bordo e sincronizada. Se você é o time, você já está sincronizado consigo mesmo, e isso não é realmente necessário.

Não há nada de errado com sua abordagem como uma forma de arte criativa. Se você está desenvolvendo para benefício pessoal, e o que está fazendo funciona para você, e que considera agradável, provavelmente é tão importante quanto o resultado final que o próprio produto.

Em um ambiente de trabalho profissional, se as escalas de tempo do seu projeto forem curtas, talvez em torno de 2 a 3 semanas ou menos, sua abordagem será chamada de prototipagem rápida e é bastante apropriada para as tarefas futuras.

No entanto, em projetos mais longos, mesmo quando você trabalha por conta própria, essa abordagem é provavelmente um luxo caro para o seu empregador. Passar alguns dias do orçamento do projeto em design de arquitetura inicial e depois testá-la contra o que aconteceria se o gerenciamento decidisse alterar as especificações até ... normalmente é um tempo bem gasto e desenvolverá suas habilidades para se tornar um programador / arquiteto mais valioso posteriormente na sua carreira.

Duas perspectivas:

1. Ninguém tem que manter uma pintura.

2. Quem já assistiu Bob Ross pintar uma pintura sabe que as pinturas têm estrutura. Se você pretender tirar uma lição de Bob Ross, é que planejar com antecedência e trabalhar de maneira organizada faz com que o processo corra bem e pareça simples.

Eu codifico da mesma maneira. Vou começar a escrever e, à medida que vejo padrões emergentes, refatoro. Você pode pintar-se em um canto dessa maneira, precisa saber quando se sentar e pensar em um problema, mas às vezes você apenas dá uma facada nele para realmente entender o problema.

Mas estou curioso sobre isso:

A comunidade de pessoas aqui e no Stack Overflow parece rejeitar qualquer cheiro de imperfeição. [..] Meu processo parece ir contra o que é aceitável na comunidade de desenvolvedores profissionais, e eu gostaria de entender o porquê.

Como alguém no Stack Overflow conheceria seu processo? E o que você quer dizer com "rejeitar"? Naturalmente, o código postado em uma comunidade de programação será examinado criticamente. Mas se alguém identificar áreas em que seu código possa ser aprimorado, isso pode ser apenas uma coisa boa, certo?

Felizmente, ao postar uma pergunta no Stackframe, você limpa seu código e tenta reduzi-lo da forma mais simples possível, por respeito aos seus leitores (às vezes você resolve o seu próprio problema apenas tentando apresentá-lo a outras pessoas), no qual caso algum feedback seja bom. Se você postar um código que você sabe que é ruim e você sabe por que ele é ruim antes de publicá-lo, não o leve para o lado pessoal se as pessoas perceberem que é ruim.

Eu também uso sua abordagem. Funciona melhor para mim, pois reduz o risco de superengenharia.

O que faço com frequência é resolver um problema com provavelmente o menor código possível, o que geralmente leva a dependências evidentemente desnecessárias ou outros problemas de design. Então refatoro o código de trabalho em um código bonito.
Por exemplo, reduzo as dependências entre diferentes módulos para interfaces concisas e coloco em questão a questão de quais dados devem ser mantidos onde, até que todos os módulos dependam apenas de abstrações muito minimalistas dos outros módulos. Você poderia dizer que adio a decisão final, que módulo deve ter qual responsabilidade. Adio a abstração.
Pensar demais em separar um problema em responsabilidades distintas, em abstrações distintas não é bom. Isso forçará você a dobrar sua implementação para se adequar às abstrações que você fez. O código funciona, se produz os resultados desejados e se é sustentável. Um design funciona, se você puder implementá-lo através de um bom código. Se o código não funcionar, você o altera. Portanto, se um design não funcionar, você precisará alterá-lo também. Você só pode ver se um design funciona depois de implementá-lo.

Portanto, ter um esboço simples em mente é o suficiente como design, antes de começar a trazê-lo à vida. Redesenhar, abstrair e refatorar, conforme necessário .

Eu acho que se você é bom em programação, pelo menos às vezes tem que ser divertido, e isso significa ser criativo.

Certamente, ao programar em grupos, existem pelo menos padrões mínimos que devem ser seguidos, não por razões "morais", mas por razões práticas, quando aplicáveis.

Fora isso, é interessante e divertido sondar os limites para ver o que pode ser encontrado lá. Uma vez, ao trabalhar em um Mini na linguagem assembly, descobri que era possível fazer co-rotinas que poderiam mudar de uma para a outra com 1 instrução. Então eu descobri como fazer uma auto-rotina comum que poderia dar dois passos adiante, um passo atrás etc. Isso foi útil? Eu duvido. Essa não é a questão.

Certa vez, ouvi uma palestra de Edsger Dijkstra, falando sobre criatividade em programação. Ele mencionou como um aluno encontrou uma maneira de fazer uma rotação n-bit de uma palavra n-m-bit. Foi feito com 3 bitswaps. Primeiro você troca os n bits, depois os m bits, depois os n + m bits inteiros. Útil? Não. Inteligente? Sim.

É bom ficar à vontade para tentar coisas que ninguém em sã consciência faria.

Pode ser um caso de "tamanho único não serve para todos". Você fez seu estilo funcionar para os projetos em que participou, então quem argumenta com isso? No entanto, os críticos que você está lendo aqui e no SO podem estar trabalhando em projetos maiores ou em projetos que exigem coordenação complexa entre os membros da equipe.

Seu estilo de desenvolvimento pode se tornar um problema se você estiver envolvido em projetos maiores que envolvam cooperação entre vários desenvolvedores. É difícil agendá-lo, é difícil acompanhar o seu progresso, e não há como seus colegas programadores planejarem a parte do trabalho deles que depende de saber o que a parte do trabalho está fazendo.

Você pode estar interessado em ler o Dreaming in Code para ver o que pode acontecer quando um projeto grande adota um estilo de desenvolvimento semelhante ao seu.

Muita garantia de que seu método não está errado, mas deixe-me acrescentar alguma experiência pessoal. Comecei do seu jeito, mas nesse meio tempo aprendi o benefício de planejar antecipadamente pelo menos parte da estrutura geral, e isso por várias razões:

• O maior acréscimo é que é mais fácil ver qual código pode ser reutilizado se for trabalhado um pouco. Costumo escrever um pedaço de código que, ao escrever, repentinamente parece útil para outra parte do esquema geral que tenho pendurado ao lado da minha tela (desenhado no papel em um estilo apenas legível para mim).

• Ter um esquema permite refatorar não apenas o código, mas também o esquema. Às vezes, estou ocupado escrevendo uma aula que de repente parece útil para outra parte do esquema. Como resultado, o esquema se torna mais simples quando o projeto é executado

• Toda vez que atualizo esse esquema, também com a entrada necessária e a saída de funções / métodos e os slots disponíveis nas classes. Isso é mais rápido para reutilizar bits: não preciso mergulhar no código toda vez para verificar o que exatamente entra e sai. Mesmo que esteja nos comentários, ainda tenho que procurar para obter os comentários

Então, na verdade, eu uso seu método também. Acabei de começar, experimentar, refatorar, tentar novamente, mudar outro bit e assim por diante, mas meu ciclo também inclui o esquema. E quando isso é feito, adiciono as informações para a próxima que funciona nesse código.

Veja bem, isso é para projetos em que trabalho sozinho. Se você trabalha com mais pessoas no mesmo código, planejar com antecedência não é apenas lógica, é essencial. Mas acho que você já sabe disso.

E como outros disseram: este é o meu caminho, sua milhagem pode variar.