Executando verificação de segurança...
2

"Clean Code", Desempenho Horrível

Vídeo orignial: https://www.youtube.com/watch?v=tD5NrevFtbU

Nesse vídeo o autor, Casey Muratori, mostra como Código Limpo pode fazer o seu programa executar até ~20x mais devagar.

Esse vídeo faz parte do curso Performance-Aware Programming, onde ele apresenta 5 multiplicadores de desempenho para software:

  1. eliminação de desperdício
  2. paralelismo a nível de instrução
  3. SIMD
  4. cache
  5. threads

Tudo isso entendendo o que de fato a CPU está fazendo e que decisões podemos tomar pra dar menos trabalho pra ela. Afinal, tudo o que escrevemos, de uma forma ou de outra, passa pela CPU.

O que eu achei interessante é que o curso mostra também como aplicar alguns desses multiplicadores em linguagens de alto nível como Python.

De qualquer maneira, é mais um conjunto de técnicas pra nos ajudar a escrever software melhores pros usuários. Pra quem curte programar jogos é muito útil.

Também existe a versão em artigo do vídeo (agradecimentos ao tetri por ter me lembrado).


Parece que eu to fazendo propagando do curso, mas eu só achei que é um recurso interessante porque é muito diferente do estilo orientação a objetos então tive que compartilhar.


Alguns outros vídeos interessantes do Casey:

Handmade Hero | "Why start from scratch vs Using an engine? Why reinvent the wheel?", o porquê fazer algumas coisas do zero

Where Does Bad Code Come From?, mais reflexões sobre Clean Code (playlist sobre a qualidade dos softwares modernos)

Handmade Hero, uma série de vídeos ensinando a fazer um jogo um do zero em C usando a API do Windows (playlist mais organizada)

Carregando publicação patrocinada...
2

Ao ler seu texto me lembrei na hora do manifesto Handmade, e que hoje temos computadores melhores e programas piores. Sobre o clean code, acho necessário ter códigos legiveis, mas MUITAS vezes o pessoal exagera, achei essa imagem que exemplifica muito bem oq quero dizer:


oop-clean-code

2

Não se preocupe, não parece que está divulgando o curso, na verdade nem sei que curso está falando.

O vídeo é muito bom, só não espere ele ser popular.

Eu construí minha carreira em torno da performance. Mas sempre defendo código legíveis antes de mais nada. Nem sempre ter performance faz o código fica ilegível, e o vídeo passa um pouco isso. Há uma crença que só pode fazer código rápido se ele ficar incompreensível, quando tem casos que é o oposto, o legível é o mais rápido.

Ele mostra muito bem que em alguns casos pode deixar de lado algumas regras que não vão prejudicar a legibilidade tanto assim e ter ganhos absurdos.

O próprio Clean Code tem uma passagem que diz para não seguir regras, nem as do livro, para entender o que está fazendo, fazer escolhas com consciência. Ela é frequentemente ignorada e as outras são seguidas em qualquer contexto.

Tenho uma palestra que fala sobre uma frase do Donald Knuth que tiraram do contexto como começarem justificar que performance não importa, Quase todo mundo já foi submetida a ela, mas o contexto todo era para mostrar que a performance deveria ser muito trabalhava, só que em 3% do código e não todo ele, como acabou sendo divulgado. Ele deve ter a mesma sensação de quem inventou a capacidade nuclear para inventarem uma bomba.

O resultado são aplicações lentas e ineficientes. Enquanto eu não for acionista de quem faz isso está tudo bem. Se isso transparecer para o usuário, e em muitos casos transparece, enquanto eu não for usuário desse aplicativo, está tudo bem.

Obviamente que todo engenheiro com boa qualificação saberá fazer escolhas adequadas para a necessidade em cada contexto. E precisa ser assim.

Vou dar um exemplo que gosto muito e conheço de perto. O Stack Overflow pode rodar com apenas 1 servidor, mesmo sendo um dos 50 sites mais acessados do mundo (varia dependendo da época). Outros sites absurdamente menores precisam de centenas ou milhares. E tem um SEO pior por responder lentamente. É aí onde precisa questionar se a decisão está certa.

Em muitos casos o código é lento e não é legível, até porque só está seguindo regras, não está pensando sobre ele.

O próprio SO já errou. Essa coisa de cache, de arquitetura sofisticada e outras parafernálias que podem ajudar ficar mais rápido, são complexidades e que podem também piorar a eficiência e desempenho. Ele cacheavam, tudo, hoje bem poucos coisas, porque viram na prática que cache não é tão útil assim, em alguns lugares. Não pode adotá-lo como regra, precisa estudar, experimentar, e usar onde faz efeito real.

Não vou dizer que é ruim, mas eu não gosto muito de forçar performance em linguagens de script, a não ser em desperdícios óbvios, simples e nem deveriam existir. Se precisa de performance, um dos ganhos mais fáceis é usar uma tecnologia que já entregue isso.

Até porque não há comprovação que essas linguagens mais "lentas" são claramente mais produtivas. Elas podem até diminuir o tempo de entrega inicial, mas também piora o custo de manutenção futuro, a não ser que se aplique técnicas que baixa a produtividade inicial, então no empate, ainda ficará com algo mais lento, e só tão robusto se tiver esforço adicional.

Desenvolver softwares de qualidade, não é fácil, é trabalhoso e requer muita experiência qualitativa. Todos esses conteúdos ajudam ir entendendo cada vez mais, e não pode ser usado sozinho, é tudo parte de uma reflexão maior. Precisa ter um contraponto.

Obrigado por compartilhar algo tão interessante. É preciso manter a mente aberta para tudo, só assim podemos nos desenvolver bem.

Farei algo que muitos pedem para aprender programar corretamente, gratuitamente. Para saber quando, me segue nas suas plataformas preferidas. Quase não as uso, não terá infindas notificações (links aqui).

2

Clean Code, e quaisquer outras "boas práticas", não são leis sagradas, e nem regras universais. São no máximo recomendações, sugestões. Você analisa, vê os prós e contras e usa quando fizer sentido (como tudo em computação, aliás).

O caso do vídeo é um exemplo de quando não usar. Se vc precisa otimizar ao máximo, e pra isso precisa quebrar algumas regras, vá em frente. Não vejo problema nenhum em ir contra o "senso comum", se for algo bem justificado. Desde que, claro, sejam justificativas técnicas, e não dogmáticas ou ideológicas (ou então por moda, "todo mundo faz", e a famigerada desculpa-mãe de todas, "é boa prática").

Mas tem casos em que justifica sim. Um código que não precisa de otimização extrema, que nunca roda com muitos dados, e no qual a diferença entre 1 milissegundo e 50 milissegundos não tem impacto nenhum, seria um em que eu poderia seguir o Clean Code. Eu não tenho dados oficiais, apenas experiência pessoal (e portanto é mais anedótico do que factual) de que seguir alguns princípios, especialmente em equipes que mantém bases de código grandes, pode ajudar na manutenção. Não quer dizer que se seguir tudo à risca, nunca terá problemas. Mas ele pode ajudar sim.

Mas como eu já disse, cada caso é um caso. Em código throw away (aquele "scriptzinho" que só vai rodar uma vez) eu não me preocuparia com nenhuma "boa prática", e dependendo do caso nem com performance. Em projetos de longo prazo, melhor manter um mínimo de organização, e isso pode ou não usar um ou mais princípios desta ou daquela metodologia. E se precisar quebrar alguma regra, desde que bem justificado, não vejo problema algum. Contexto é tudo.

O problema de qualquer coisa em computação não é usar, e sim usar errado (quando não é adequado ao problema/contexto, ou quando o uso excessivo acaba tendo o efeito contrário do proposto).

1

Hoje em dia as máquinas são mais baratas que as pessoas programando, ou seja, é condizente reduzir performarmance de máquina para aumentar produtividade de desenvolvimento;

1
1
1

acho que só esqueci mesmo kkkk o artigo é o roteiro do vídeo então não perde nada

Mas obrigado por lembrar. Vou colocar no post

1

yudiazvd,

Concordo com você sobre o uso extremo de clean code.

Porém a minha ideia é que a gente deveria ter um pensamento de levar a performance como prioridade e, à partir daí, limpar o máximo que puder.

Levar em consideração somente performance pode tardar futuros desenvolvimentos.

1

É comum quando o software é criado com foco em desempenho a legibilidade do código é comprometida. Como o "clean code" é focado principalmente em legibilidade certamente isso gera um custo em algum momento.

Mas acredito que na maioria das aplicações comerciais modernas, esses gargalos de performance pode ser contornados com arquitetura, usando cache, filas de processamento assíncrono, etc.