Uma das lições mais importantes que aprendi como desenvolvedor há 15 anos foi esse pensamento simples:
Um bom código é expressivo, não impressionante.
Lembro-me de quando ouvi isso e perguntei: "Qual é a diferença?", E recebi uma resposta.
"Expressivo" - compreensível, inequívoco e específico. E, nesse caso, escrever código expressivo exigirá trabalhar com uma tarefa específica. O investimento de tempo e energia em sua criação serve a um propósito específico, e o resultado corresponde à expectativa.
Impressionante é um código que é lembrado. Escrever código que é lembrado por suas estruturas e algoritmos complexos, embora arranhe seu ego, será uma dor real para alguém que o apoiará no futuro. E se o último for um maníaco que conhece seu endereço, Deus o salve da raiva dele.
É por isso que um bom desenvolvedor é sábio, não brilhante. Um desenvolvedor sábio não tem apenas inteligência, mas também a capacidade de pensar constantemente nas consequências de suas ações. Ele sabe qual código específico ele escreve, por que o faz e, o mais importante, como esse código se comportará no futuro. Ou, se mais simples, o desenvolvedor inteligente está tentando curar a doença, não os sintomas.
Desenvolvedores “engenhosos”, com a mesma inteligência, pelo contrário, pensam apenas no presente. Eles podem resolver os problemas atuais de maneira rápida e eficaz. Essa é a montanha de seus truques e truques constantemente acumulados e uma vez que trava o código, enterrando a reputação de todos os envolvidos. É por isso que Steve McConnell observou certa vez:
Programar não é um trabalho na CIA; você não precisa ser inteligente.
E desenvolvedores sábios não fazem nada esclarecido. Eles escrevem um código chato e simples que é fácil de entender. Nem mais nem menos.
Aqui estão mais alguns princípios de desenvolvedores sábios.
Eles preferem simplicidade
Martin Fowler disse uma vez:
Qualquer tolo pode escrever um código amigável ao computador. Um bom desenvolvedor escreve um código que as pessoas podem entender.
Às vezes, os desenvolvedores desejam se afirmar. Mostre aos outros seu talento. E eles começam a procurar soluções abstrusas para todos os problemas que encontram, embora uma solução simples esteja à mão. E este é um dos piores erros que um desenvolvedor pode cometer.
Um desenvolvedor sábio escreve código direto. É fácil manter, otimizar e refatorar, se necessário. O código não faz algo complicado, todos que o encontram imediatamente entendem aproximadamente o que está acontecendo "sob o capô". Algoritmos avançados e incomuns provam ser excelentes durante o sprint noturno para café e energia, mas falham muito mais tarde na produção.
Quando o ego começar a tentá-lo lentamente durante a programação, pergunte-se: "Se eu voltar a trabalhar com esse código após 2 meses, posso lembrar o que exatamente está acontecendo aqui?" Se a resposta for sim, então vá em frente. Lembre-se, no entanto, dos seus colegas que um dia terão que trabalhar com esse código.
O código é como uma piada. Se precisar ser explicado, é ruim.
Eles sabem quando (não) você precisa otimizar seu código.
Edsger Dijkstra observou certa vez:
Um bom desenvolvedor se concentra no que e não na ajuda ao escrever o código.
No entanto, existem várias maneiras diferentes de otimizar seu código. Cada um deles está associado a uma alteração na quantidade de memória consumida, no tempo do processador e em um algoritmo específico. E desenvolvedores sábios escolhem esse caminho de forma pragmática.
Mas antes de começar a melhorar algo, eles seguem a regra de ouro do "não faça mal".
Para que finalidade vou mudar alguma coisa? Talvez o programa já resolva perfeitamente a tarefa? Considerando como e em que ambiente o programa será lançado, há algum sentido em torná-lo mais rápido? Todas essas perguntas devem ser respondidas por você antes de iniciar a otimização.
Qualquer otimização faz sentido apenas no contexto de trabalho e retorno, se o programa é importante e é realmente lento, e existem razões razoáveis para acreditar que ele pode ser otimizado, mantendo a confiabilidade, a correção e a clareza. Ninguém precisa de um programa que produza resultados errôneos, não importa quão rápido seja. Um código bem otimizado é melhor do que não otimizado, mas com a abordagem errada, o oposto exato é verdadeiro.
Lembre-se: qualquer alteração no desempenho durante a otimização deve ser medida. A intuição nesse assunto é um péssimo ajudante.
Eles preferem usar em vez de criar código.
Vic Gundotra acertou o alvo, dizendo uma vez:
Você começa escrevendo o código. Começo por encontrar uma solução.
E desenvolvedores sábios seguem o exemplo. Eles começam procurando por código pronto. Embora pareça para alguns que agora eles façam tudo do zero "como fazer", a maioria acaba com a invenção banal de uma bicicleta.
Fique à vontade para pesquisar no Google. A busca de soluções, seja online ou em sua própria base de código, já é útil, mesmo do ponto de vista de estudar as abordagens que funcionavam anteriormente em problemas semelhantes, bem como seus prós e contras. É por isso que os desenvolvedores inteligentes passam muito tempo lendo o código de outra pessoa antes de escrever o seu. Criar código do zero sempre vale a pena tempo, dinheiro e energia. Não desperdice recursos até que se torne realmente necessário.
Portanto, ao resolver outro problema, tente primeiro verificar se alguém o resolveu antes de você. Você não evita seu trabalho, evita trabalhos desnecessários.
Eles tentam ser melhores.
Aristóteles disse uma vez:
Se você estiver trabalhando em algo que já sabe fazer, não ficará melhor.
Desenvolvedores inteligentes estão tentando melhorar a si mesmos, ou melhor, seu código a cada oportunidade. Eles são modestos o suficiente para perceber que ainda não criaram seu melhor código.
Eles não ficam sentados na zona de conforto repetidamente, usando a mesma abordagem. Eles estão fazendo o possível para garantir que seus próprios hábitos não se tornem dogmas para eles. Eles estão constantemente procurando maneiras e oportunidades para melhorar, especialmente se puderem aprender algo novo no processo.
Desenvolvedores inteligentes não são fascinados por tecnologia da moda e recursos interessantes. Eles são pragmáticos o suficiente para entender que uma bala de prata não existe e que qualquer abordagem tem seus prós e contras.
Eles não têm medo de pedir ajuda.
Sócrates pronunciava:
Se estivéssemos constantemente ajudando um ao outro, ninguém precisaria de sorte.
Como desenvolvedores, gostamos de pensar em nós mesmos como pessoas inteligentes. Além disso, entre nós realmente existem gênios. Mas também estamos inclinados a acreditar que devemos saber tudo no mundo. E realmente, quem tem o prazer de dizer na frente dos colegas: "Eu não sei"? Quem quer admitir que a nova tecnologia para ele é um conjunto de hieróglifos?
Em vez disso, você sussurra para si mesmo: “Eu vou descobrir por conta própria. Já fiz tantas vezes antes, agora posso. "
Desenvolvedores inteligentes não fazem isso. Eles sabem quando pensar por si mesmos e quando pedir ajuda. Eles já sabem que arrastar um pedido de ajuda apenas mata o tempo antes dos prazos, o que prejudicará toda a equipe. Portanto, eles não têm medo de parecer incompetentes e pedir ajuda quando necessário.
Um pedido oportuno de ajuda não prejudicará a fé dos colegas em suas capacidades. Isso fortalecerá a confiança em você, como profissional, pronto para fazer todo o necessário para cumprir prazos e obter resultados de alta qualidade.
Como Cubra Sait observou uma vez:
Mudanças positivas começam com perguntas.