O projeto está quase pronto, mas o código processual de espaguete. Reescrevo ou continuo tentando enviá-lo? [fechadas]

Sou desenvolvedor web iniciante (um ano de experiência).

Algumas semanas depois de me formar, me ofereceram um emprego para criar um aplicativo da Web para uma empresa cujo dono não era muito técnico. Ele me recrutou para evitar o roubo de sua idéia, o alto custo de desenvolvimento cobrado por uma empresa de serviços e ter alguém jovem em quem ele possa confiar para manter o projeto a longo prazo (cheguei a essas conclusões sozinho depois de ser contratado )

Arrogante como eu era naquela época, com um diploma em ciência da computação, aceitei a oferta pensando que posso construir qualquer coisa.

Eu estava dando os tiros. Após algumas pesquisas, decidi pelo PHP e comecei com o PHP simples, sem objetos, apenas código processual feio. Dois meses depois, tudo estava ficando bagunçado e era difícil progredir. A aplicação web é enorme. Então, decidi verificar uma estrutura MVC que tornaria minha vida mais fácil. Foi aí que me deparei com o garoto legal da comunidade PHP: Laravel. Adorei, foi fácil aprender e comecei a codificar imediatamente. Meu código parecia mais limpo, mais organizado. Parecia muito bom.

Mas, novamente, o aplicativo da web era enorme. A empresa estava me pressionando para entregar a primeira versão, que eles queriam implantar, obviamente, e começar a procurar clientes.

Por ser divertido trabalhar com o Laravel, isso me fez lembrar por que escolhi esse setor em primeiro lugar - algo que esqueci enquanto estava preso no sistema de educação de merda.

Então comecei a trabalhar em pequenos projetos à noite, lendo sobre metodologias e melhores práticas. Revisei o POO, passei para o design e análise orientados a objetos e li o livro Clean Code, do tio Bob .

Isso me ajudou a perceber que eu realmente não sabia de nada. Eu não sabia como criar software da maneira certa. Mas, a essa altura, era tarde demais e agora estou quase terminando. Meu código não é nada limpo, apenas código espaguete, uma verdadeira dor para corrigir um bug, toda a lógica está nos controladores e há pouco design orientado a objetos.

Estou com esse pensamento persistente de que preciso reescrever todo o projeto. No entanto, eu não posso fazer isso ... Eles continuam perguntando quando tudo será feito.

Não consigo imaginar esse código implantado em um servidor. Além disso, ainda não sei nada sobre a eficiência do código e o desempenho do aplicativo Web.

Por um lado, a empresa está esperando o produto e não pode mais esperar. Por outro lado, não consigo me ver indo mais longe com o código real. Eu poderia terminar, finalizar e implantar, mas só Deus sabe o que pode acontecer quando as pessoas começarem a usá-lo.

Eu reescrevo, ou apenas continuo tentando enviar, ou há outra opção que eu perdi?

Você tropeçou no calcanhar de Aquiles da maioria das formações em ciências da computação: elas ensinam as ferramentas e técnicas, mas não o ofício. Construir software é um ofício, que você só adquire através de anos de prática e experiência em ter seu software usado (os usuários são críticos muito mais severos do que os professores). A criação de software também costuma ser um negócio, onde os objetivos de negócios podem substituir as ambições técnicas.

Primeiro de tudo, navio. Se você mostrar o software ao proprietário da empresa e ele achar que está pronto para ser enviado, envie-o. Se não for nesse ponto, mas perto, termine-o. O único software que importa é o que é realmente usado. O único negócio de software que ganha dinheiro é aquele que possui um produto.

Em segundo lugar, você aprendeu muitas coisas valiosas; portanto, aprecie a experiência pelo que ela ensinou :

1. Usar código sem um plano ou arquitetura é uma receita para o desastre
2. Há muito mais na programação do que escrever código
3. Proprietários de negócios não técnicos geralmente não entendem o impacto de decisões técnicas (como quem contratar), e cabe aos desenvolvedores explicar as coisas para eles.
4. A maioria dos problemas já está resolvida muito melhor do que você os solucionaria, nas estruturas existentes. Vale a pena conhecer as estruturas existentes e quando usá-las.
5. As pessoas recém-saídas da escola designadas para um grande projeto com pouca orientação tendem a produzir uma tigela de código de espaguete. Isto é normal.

Aqui estão mais alguns conselhos para você sobre como proceder:

1. Comunicar, comunicar, comunicar. Você deve ser muito franco e franco com o estado do projeto e suas idéias sobre como proceder, mesmo que não tenha certeza e veja vários caminhos. Isso deixa o proprietário da empresa a escolha do que fazer. Se você mantiver o conhecimento para si mesmo, você os privará de escolhas.
2. Resista à tentação da reescrita completa. Enquanto você está reescrevendo, a empresa não tem produto. Além disso, uma reescrita raramente é tão boa quanto você imaginou. Em vez disso, escolha uma arquitetura e migre a base de código para ela gradualmente. Mesmo uma base de código horrível pode ser recuperada dessa maneira. Leia livros sobre refatoração para ajudá-lo.
3. Aprenda sobre testes automatizados / testes de unidade . Você precisa criar confiança no código, e a maneira de fazer isso é cobri-lo com testes automatizados. Isso anda de mãos dadas com a refatoração. Contanto que você não tenha os testes, faça um teste manual e abrangente (tente quebrar seu código, porque seus usuários o farão). Registre todos os bugs que encontrar para poder priorizá-los e corrigi-los (você não terá tempo para consertar todos os bugs, nenhum software é enviado sem bugs no mundo real).
4. Aprenda sobre como implantar um aplicativo Web e mantê-lo em execução. O livro Operações na Web: mantendo os dados no prazo é um bom começo.

Isso soa como qualquer outro sistema que foi lançado para mim para corrigir.

Relaxe, isso acontece com muitas pessoas. Um júnior jogado no fundo do poço sem experiência, sem ajuda, sem apoio e sem orientação não é exatamente uma receita para o sucesso. Contratar e esperar que um programador júnior construa um novo sistema a partir do zero, que funcione bem, tenha um bom desempenho e seja sustentável, não é realista. Inferno, você tem sorte se tudo isso acontecer com um programador sênior.

Na minha opinião você tem que ficar limpo. Isso não vai ser divertido. Diga a eles que você fez o seu melhor, funciona (principalmente), mas você está preocupado que ele não funcione bem e que haverá muitos bugs ( sempre há bugs). Ele precisa ser revisado por um programador sênior e eles devem ser capazes de corrigir rapidamente os problemas visíveis de desempenho / segurança. Ou eles podem implantá-lo e cruzar os dedos. Ou vai dar certo ou vai virar fumaça. Talvez você possa resolver problemas à medida que eles surgirem. Se você tem uma grande base de usuários, talvez não.

Ou você pode fazer o que a maioria das pessoas faz nessa situação: pegar o dinheiro, desaparecer e deixá-los resolver o problema. Vou deixar você decidir qual é a escolha ética.

Editar (como essa pergunta tem muitos votos, é melhor adicionar mais conteúdo)

Parte das alegrias de ser programador é que pessoas não técnicas (provavelmente seu gerente, definitivamente o restante dos negócios) não têm idéia do que você faz. Isso é bom e ruim. Parte do mal é que você precisa explicar constantemente como os projetos de desenvolvimento de software funcionam. Planejamento, requisitos, revisões de código, testes, implantação e correção de erros. É seu trabalho explicar a importância dos testes e reservar um tempo para os testes. Você tem que defender sua posição aqui. As pessoas não entenderão a importância ( "não podemos simplesmente começar a usá-la?"), mas assim que começarem a testar (não no ambiente ativo!), eles entenderão rapidamente os benefícios. Uma das razões pelas quais eles o contrataram é porque eles não sabem nada sobre desenvolvimento de software; portanto, é sua responsabilidade educá-los. Você precisa enfatizar a importância dos testes e da correção de erros aqui - lembre-se, eles não são programadores, não sabem a diferença entre uma divisão por zero e uma tag html quebrada.

Muitas vezes, muitos dos problemas que surgem não são realmente erros. Serão problemas de usabilidade, requisitos perdidos, requisitos que foram alterados, expectativas do usuário (por que não posso usar isso no meu celular?) E, em seguida, os bugs reais reais. Você precisa resolvê-los antes de ir ao ar - geralmente muitos bugs podem ser solucionados ou corrigidos alguns dias depois. Se as pessoas esperam um sistema perfeito, elas sofrerão bastante. Se eles estão esperando bugs, sua vida será muito mais fácil nas próximas semanas.

Ah, e não confunda o teste do usuário com o teste de unidade nem com o sistema.

• Teste de unidade - minha função de código retorna o valor certo
• Teste do sistema - gera um erro quando clico no X
• Teste de aceitação do usuário (UAT) - o programa está em conformidade com os requisitos? Faz o que eles pediram para você fazer? Ele pode ir ao vivo?

Se você não anotou os requisitos do que eles pediram, o UAT será muito, muito mais difícil. É aqui que muitas pessoas caem. Ter o que eles queriam que o sistema fizesse no papel tornaria sua vida muito mais fácil. Eles dirão "Por que não faz X?" e você pode dizer "Você me disse para fazer Y". Se o programa estiver errado, corrija-o. Se os requisitos estiverem incorretos, corrija o documento, peça um ou mais dias (não, insista), faça a alteração, atualize a documentação e teste novamente.

Depois de passar por esse processo algumas vezes, você pode começar a procurar o Agile .. mas esse é outro mundo :)

TL; o teste de DR é bom

Sempre que você começar do zero, você quase certamente cometerá a mesma quantidade de erros ou mais devido ao Segundo Syndromme do Sistema . Seus novos erros serão diferentes, mas a quantidade de tempo necessária para a depuração será semelhante e, portanto, se desesperará sobre como não é um bom ajuste. Também atrasará a implantação na produção ou na implantação de novos recursos se a primeira versão for implantada, o que será um problema sério para a empresa. Joel Spolsky chama de "pior erro estratégico único" que qualquer empresa ou desenvolvedor pode cometer.

A abordagem recomendada é limpar a bagunça inicial pouco a pouco durante a manutenção. E nem tente refatorá-lo apenas por isso. Além disso, os gerentes costumam ver isso como desperdício de dinheiro (o que geralmente é) e traz riscos desnecessários de introdução de novos bugs. Depois de depurar dolorosamente o código, ele pode não ser bonito, mas funcionará. Portanto, espere até que você precise tocá-lo por outros motivos (seja uma correção de bug, um novo recurso ou apenas uma alteração solicitada pelo marketing). Em seguida, limpe as peças mais difíceis de ajustar. Isso geralmente é chamado de regra dos escoteiros .

E nesse ponto você não precisa discutir com o gerente. Basta incluir a refatoração mínima desejada na estimativa para a solicitação. Você aprenderá com a experiência quando tiver condições de ceder um pouco, porque a empresa está realmente em um conserto e quando você não deseja criar problemas no futuro e simplesmente não admite a possibilidade de hacká-lo rapidamente.

Por fim, mais um pouco da leitura recomendada: a Grande Bola de Lama .

Eu esqueço onde li pela primeira vez, mas eu só queria ecoar com mais força o que outras pessoas disseram:

O envio é um recurso.

Não há nada pior do que aquele que continua "limpando" o código existente (possivelmente hacky, feio, sujo) que funciona perfeitamente bem , introduzindo novos bugs etc. O que importa no mundo real é fazer seu trabalho. Você fez isso. Navio. Não se perca na reformulação de um projeto que funcione perfeitamente bem, mesmo que seja feio. Ao corrigi-lo, faça-o de forma incremental e faça de você um bom conjunto de testes para ter o menor número possível de regressões.

Todo projeto deixa você mais esperto do que era antes. Depois de cada projeto, você acumulará mais experiência, o que seria muito útil quando você a possuía desde o início. Eu sei que é difícil não revisitar tudo e aplicar o que você aprendeu. Mas lembre-se:

Perfeito é o inimigo do bem.

Para o cliente, é sempre melhor ter um bom software agora do que um software perfeito que nunca será lançado.

Este foi apenas o seu primeiro projeto. No futuro, haverá muitos outros projetos nos quais você poderá aplicar tudo o que aprendeu desde o início.

Eu li o código limpo de Bob do tio.

Estou com esse pensamento persistente de que preciso reescrever todo o projeto.

Este livro tem uma seção chamada, muito apropriadamente, "O Grande Redesenho no Céu".

Não tente reescrever tudo, porque, no improvável caso de você ter tempo para fazê-lo, os mesmos problemas serão enfrentados. Quando você terminar o reprojeto, aprenderá coisas novas e perceberá que as primeiras partes dele são muito pouco profissionais; portanto, você deve reescrevê-lo novamente.

O reprojeto e a reescrita são bons, mas apenas se forem feitos de forma incremental em um sistema em funcionamento. Como outro usuário apontou, siga a Regra dos Escoteiros, refatorando seu código aos poucos enquanto você trabalha nele.

Você está indo bem.

Você diz que seu código funciona e está quase pronto para ser enviado, certo? E você percebe que seu código pode ser bastante aprimorado. Boa.

Seu dilema me lembra muito minha primeira experiência com freelancer (sendo contratado no meu segundo ano na uni para criar um sistema POS multilíngue). Passei por questionamentos sem fim, pois nunca estava satisfeito com o código, queria escalabilidade, queria reinventar rodas melhores ... Mas apenas adiei o projeto (cerca de 12 meses aproximadamente) e ... o quê? Uma vez implantado, ele ainda precisa de muitas provas, testes, correções, etc ...

Você tem experiência em trabalhar com bases de código profissionais? Muitas bases de código estão cheias de códigos peculiares e difíceis de manter. Uma alternativa para descobrir a complexidade do software tentando criar um programa grande seria manter / estender o código igualmente confuso escrito por outras pessoas.

Os únicos casos em que vi reescritas completas são muito úteis quando a equipe adotou simultaneamente uma nova cadeia de ferramentas / estrutura.

Se a lógica subjacente (o que o programa faz, não como é apresentada como funções, classes e assim por diante ...) for boa, funcionará da mesma maneira que você pensa que é um código de espaguete. não deve ser implantado.

Você precisa deixar seu cliente ter algo que ele possa usar. Então, quando eles solicitarem que você o melhore / adicione funcionalidade, você decide se é necessário um refator e não há problema em informar ao cliente que "é necessário algum trabalho técnico para integrar o referido novo recurso". Pelo qual eles entenderão que isso lhes custará mais dinheiro e terão que esperar mais. E eles vão entender (ou você pode se retirar).

Um momento melhor para reescrever tudo seria quando outro cliente solicitar que você crie algo semelhante.

Em suma, a menos que você possa demonstrar que tudo vai explodir na cara de todo mundo se for implantado, atrasar a implantação seria pouco profissional e não beneficiará você ou seu cliente. Aprender a fazer pequenos refatores enquanto corrige bugs ou adiciona novos recursos, será uma experiência valiosa para você.

A maior parte do que eu diria em resposta à sua pergunta foi dita por outros. Leia "Coisas que você nunca deve fazer, parte I", de Joel Spolsky (junto com alguns de seus outros posts sobre "astronautas da arquitetura"). Lembre-se de que "o perfeito é o inimigo do bem". Aprenda a refatorar incrementalmente. O transporte é importante, etc.

O que eu acrescentaria é o seguinte: você recebeu uma tarefa que foi considerada factível por um único recém-formado trabalhando com um pequeno orçamento / período de inicialização. Você não precisa de nada muito mais sofisticado do que uma programação processual estruturada e boa. (E, para sua informação, "programação processual" não é uma palavra ruim. Na maioria dos casos, é uma necessidade em algum nível e é totalmente adequada para muitos projetos inteiros.)

Apenas certifique-se que você realmente fazer programação estruturada, processual. A repetição no seu código não é necessariamente um sinal de que você precisa de estruturas polimórficas importantes. Pode ser simplesmente um sinal de que você precisa pegar o código repetido e colocá-lo em uma sub-rotina. O fluxo de controle "espaguete" pode ser simplesmente uma oportunidade de se livrar de um global.

Se há aspectos do projeto que legitimamente exigem polimorfismo, herança de implementação etc., eu sugeriria que talvez o tamanho do projeto tenha sido subestimado.

Se você está realmente interessado no dilema que possui, leia também "Lean Startup". Muitos dos conselhos que você está recebendo aqui ressoarão mais com você se você ler esse livro. Basicamente, a taxa de queima de recursos é seu pior inimigo e nada é mais valioso para você e sua organização do que o feedback do usuário final / cliente. Portanto, coloque seu produto em um estado viável (o Produto Mínimo Viável - ou MVP) e envie-o para fora da porta (independentemente da aparência do código). Permita que seus clientes ditem seus futuros conjuntos de alterações e versões, e não o contrário. Se você se concentrar nessa abordagem, você e seu chefe ficarão mais felizes a longo prazo.

Por razões que outros explicaram minuciosamente, é hora de terminar o projeto e enviá-lo, por mais doloroso que seja.

Gostaria apenas de enfatizar que testar o aplicativo também faz parte de "finalizá-lo". Se partes significativas da funcionalidade não foram exaustivamente exercitadas e os resultados corretos confirmados, você está justificado com a preocupação de que as pessoas tenham problemas com este aplicativo quando ele for implantado.

Testes de unidade e testes automatizados de nível superior são ótimos e são coisas que você deve ter o máximo que puder antes de tentar refatorar (ou reescrever) esse aplicativo. Mas agora você precisa testá- lo principalmente, mesmo que precise executar todos os testes "manualmente" e confirmar o funcionamento correto "a olho nu". Se você puder descobrir como automatizar esses testes posteriormente, isso ajudará na hora de começar a trabalhar na próxima versão do produto.

Algumas pessoas têm o dom de se sentar na frente de um novo projeto de software como um usuário de teste alfa e fazer as coisas darem errado. Ou seja, eles são bons em quebrar coisas. Se você tiver a sorte de ter uma pessoa tão talentosa trabalhando com você, experimente primeiro o aplicativo para ter a chance de corrigir erros óbvios mais cedo. Se você tiver que fazer essa tarefa sozinho, então:

• Seja metódico.
• Experimente todos os recursos.
• Finja que você é um usuário inexperiente com seu aplicativo. Cometa erros estúpidos e veja como o software os trata.
• Anote o que está fazendo para tentar novamente depois de pensar que resolveu os problemas.

Sua pergunta diz: "Começou errado, devo começar de novo", enquanto o texto adicional realmente diz "Projeto concluído, mas fiz errado, devo começar de novo". Apenas para o título da pergunta: se a quantidade de trabalho de programação que você fez for pequena em comparação com o trabalho total necessário, iniciar tudo de novo fará sentido. Isso acontece muito quando o problema é complexo e mal compreendido, e é gasto algum tempo para descobrir qual é realmente o problema. Não adianta continuar com um começo ruim, se jogá-lo fora e começar tudo de novo, desta vez com um bom entendimento do problema, significa que você realmente terminará mais rápido.

Isto é o que eu faria pessoalmente:

1. Desista, dê uma desculpa e desista (você pode até devolver parte do seu salário para não ficar mal)
2. Limpe seu código o máximo possível
3. Faça documentação sobre todas as partes boas do seu trabalho, como seu bom design, boas idéias, etc ...

Por que sugiro tudo isso para você?

Porque pense no futuro. Haverá um tempo no futuro em que certas pessoas obterão esse código. Eles farão todos os tipos de suposições e julgamentos sobre você e sua capacidade. Eles não se importam quando você escreveu, eles não se importam com a circunstância. Eles só querem ver nele o que querem ver para confirmar o que querem confirmar.

Você será marcado como qualquer nome ruim, termo que eles podem criar para impactar negativamente você. E mesmo que você no futuro possa ser totalmente diferente em termos de habilidade técnica, habilidades, conhecimentos, estilo e a situação seja tão diferente, esse código será usado contra você de todas as maneiras possíveis. É como um tribunal em que eles podem dizer todas as coisas ruins sobre você e seu código e design, e você nem sabe disso, para que possa se explicar e se defender. (e você pode aprender muitas vezes que eles estão profundamente errados, repetidamente). Portanto, não faça isso. Desistir.

Confie em mim, há pessoas que fizeram muitas suposições sobre você porque você fez algo para qualquer finalidade, a qualquer momento. Para eles, se você gostou disso na situação A, fará na situação B. Eles acham muito simples.

Mais duas sugestões, aposto que pelo menos uma delas você não fez.

1) Coloque um rastreador de erros e ensine seu chefe a usá-lo. Isso pode fazer parte da conversa sobre como você errou, aprendeu melhor e vai corrigi-lo de maneira planejada

2) Comece a usar o controle de versão, embora esperemos que você já esteja fazendo isso.

Existem muitos sistemas hospedados por aí que fornecem os itens acima gratuitamente em pequenas contas. Gosto particularmente do FogBugz, que também possui um ótimo sistema de estimativa e conclusão de tarefas, que dará ao seu chefe ainda mais certeza de que você está lidando com as coisas de maneira bem gerenciada.

editar

Uau, alguém realmente não gostou disso - um voto negativo E um sinalizador de exclusão? Por quê?

Desenvolvo software há mais de trinta anos, incluindo muitos trabalhos de consultoria e herdando o código de outras pessoas. Um grande número de sistemas de problemas que eu vi foram onde as pessoas cavaram uma cova e não fizeram anotações detalhadas sobre como chegaram lá nem tinham controle de versão.

Para responder à sua pergunta: como muitos outros disseram, não. Envie-o e limpe-o pouco a pouco no processo de correção de bugs.

Além disso, enquanto books / StackExchange / webforums são bons recursos de aprendizado, é provável que você descubra que nada pode corresponder ao aprendizado que você receberá ao trabalhar (ou apenas discutir o trabalho) com outros programadores. Encontrar e participar de um grupo local para uma tecnologia que você está usando ou gostaria de aprender é um investimento maravilhoso do seu tempo. Além do conhecimento técnico a ser adquirido, é uma maneira fácil de conectar em rede, que é inestimável, pois você espera por shows futuros.

Seu chefe estava ciente do seu nível de experiência quando o contratou. Apenas expresse suas preocupações e deixe que ele saiba que você está nervoso com isso. Também, informe-o quanto você aprendeu e quanto melhor você pode fazer no próximo projeto.

Você é um desenvolvedor web iniciante, sem um bom desenvolvedor presente para aconselhá-lo, seu chefe contratou você sabendo disso muito bem. Eu acho que você está indo tão bem quanto qualquer um poderia esperar que você faça. Na verdade, o fato de você ter a percepção de que o trabalho poderia ter sido melhor e de ter realmente aprendido coisas que permitiriam fazê-lo melhor significa que você está se saindo melhor do que a maioria. Lembre-se, por sua própria sanidade, que a versão de você que iniciou o trabalho não poderia ter feito melhor. Alguém mais experiente (e, portanto, mais bem pago), ou você com um projeto digno de experiência, poderia ter feito melhor.

O que fazer agora : fique feliz por ser um desenvolvedor melhor do que um ano atrás. No próximo projeto, você fará melhor (e, no final, terá mais experiência novamente e não ficará satisfeito com o que fez; isso é normal). Alterar ou reescrever o último projeto trará à empresa muito pouco benefício pelo custo. O que você pode fazer é substituir um código incorreto por um código válido quando você precisar fazer alterações de qualquer maneira; isso faz sentido, porque a modificação do código mal de manutenção pode ser mais difícil do que substituí-lo por um bom código. E se você pedir a um desenvolvedor inexperiente para ajudá-lo, diga a eles que esse código não é um exemplo que eles devem copiar.