Latest / escovando bits podcast / #71 - Morte ao código complexo: simplicidade como ato de rebeldia

Transcript

#71 - Morte ao código complexo: simplicidade como ato de rebeldia · escovando bits podcast

• 0:03
  SPEAKER_01: Assine a Codecom Pro, apoie a Codecom e ganhe vários benefícios.
• 0:17
  SPEAKER_01: Olá, você está escutando Escovando Beats, o podcast da Codecom.
• 0:29
  Eu sou o Gabriel e cara,
• 0:31
  eu nem sei se eu sei escrever códigos complexos,
• 0:34
  na real.
• 0:35
  SPEAKER_02: Eu sou o Galeno e ser simples é diferente de ser simples.
• 0:38
  SPEAKER_02: Fala pessoal,
• 0:39
  aqui é o Alex e é difícil escrever complexo porque se é
• 0:43
  complexo eu não vou
• 0:44
  SPEAKER_02: entender,
• 0:44
  SPEAKER_02: então é melhor deixar pra lá.
• 0:50
  SPEAKER_01: Se todo código que tu vê, tu não entende, então todo código é complexo.
• 0:55
  É,
• 0:55
  pode ser que demore um pouco mais e eu descubra que agora eu
• 0:58
  consegui ler.
• 0:59
  SPEAKER_02: Mas se eu não bati o olho e já não consegui ler,
• 1:01
  SPEAKER_02: claro que tem familiaridade,
• 1:02
  SPEAKER_02: um monte de coisa envolvida,
• 1:03
  SPEAKER_02: mas se é algo que eu teoricamente já sei,
• 1:06
  SPEAKER_02: e aí eu bato o olho e não consigo entender nada,
• 1:08
  SPEAKER_02: tem que ter um bom motivo para aquilo existir.
• 1:10
  SPEAKER_02: Boa.
• 1:11
  SPEAKER_01: A gente vai só para o nosso Reclames do Plim Plim e volta já.
• 1:17
  SPEAKER_01: Pergunta sobre arquitetura e engenharia.
• 1:23
  SPEAKER_02: Só que de software.
• 1:29
  SPEAKER_01: Neste quadro,
• 1:30
  trazemos um especialista do ASUS para tirar dúvidas dos devs
• 1:33
  quando o assunto é
• 1:34
  SPEAKER_01: arquitetura e engenharia de software.
• 1:36
  SPEAKER_01: Hoje estamos aqui com a Larissa Martins,
• 1:38
  SPEAKER_01: Tech Lead,
• 1:39
  SPEAKER_01: para nos ajudar a sanar as dúvidas que recebemos.
• 1:42
  SPEAKER_01: Por que é tão difícil entender a parte de negócios como dev?
• 1:45
  SPEAKER_01: Tem algum jeito de melhorar isso?
• 1:47
  Eu acho que o principal problema com essa parte de negócio é
• 1:52
  que fazer software
• 1:54
  SPEAKER_00: hoje é muito mais do que escrever código.
• 1:57
  SPEAKER_00: O código é só um meio pelo qual você faz o software ali.
• 2:01
  SPEAKER_00: A ideia principal disso tudo é resolver um problema.
• 2:04
  E quando a gente resolve um problema,
• 2:05
  a gente precisa juntar a nossa técnica
• 2:08
  SPEAKER_00: a técnica correta ali, com o conhecimento do domínio do produto.
• 2:12
  SPEAKER_00: E se a gente não dominar o problema que a gente precisa resolver,
• 2:15
  eu posso ser o melhor técnico possível e o problema não vai ser
• 2:19
  resolvido,
• 2:20
  SPEAKER_00: né?
• 2:20
  SPEAKER_00: Minha solução não vai funcionar.
• 2:22
  SPEAKER_00: E é normal que engenheiros,
• 2:23
  SPEAKER_00: principalmente no começo da carreira,
• 2:25
  SPEAKER_00: a gente tenha aquela ansiedade de codar logo,
• 2:27
  SPEAKER_00: de ver as coisas saindo,
• 2:29
  SPEAKER_00: de ter entregas logo.
• 2:31
  Mas entender o negócio é algo que é primordial para que a gente
• 2:34
  consiga entregar
• 2:35
  SPEAKER_00: alguma coisa efetiva.
• 2:37
  Hoje a gente já tem algumas práticas que ajudam os engenheiros
• 2:40
  a se aprofundar nisso.
• 2:41
  SPEAKER_00: Eu,
• 2:42
  SPEAKER_00: por exemplo,
• 2:42
  SPEAKER_00: tenho uma mania de quando eu vou fazer uma feature nova,
• 2:46
  SPEAKER_00: algo grande,
• 2:48
  SPEAKER_00: eu gosto de desenhar,
• 2:49
  SPEAKER_00: colocar no papel mesmo ali,
• 2:51
  SPEAKER_00: fazer aquele desenho dos sistemas,
• 2:52
  SPEAKER_00: entender onde é que eu tô,
• 2:54
  SPEAKER_00: onde é que meu domínio vai estar ali.
• 2:55
  SPEAKER_00: Às vezes até aqueles casos de uso, se acontecer tal coisa.
• 3:01
  Eu acho que isso ajuda a gente a entender onde tá cada pecinha
• 3:05
  e se de fato a gente
• 3:06
  SPEAKER_00: vai conseguir resolver o problema do cliente ou não.
• 3:10
  Uma coisa que eu costumo fazer também quando eu avalio os PRs
• 3:13
  aqui no Asas,
• 3:14
  SPEAKER_00: ou quando eu vou abrir um PR,
• 3:16
  SPEAKER_00: é ter uma cultura de não descrever o que eu fiz,
• 3:18
  SPEAKER_00: mas qual que é o problema que eu tô resolvendo com aquele código.
• 3:21
  SPEAKER_00: Eu acredito que isso é uma forma de documentar, né?
• 3:24
  Então facilita ali quando alguma pessoa vai ver o código ali a
• 3:28
  um longo prazo e não
• 3:29
  SPEAKER_00: tá entendendo direito porque aquilo ali foi feito,
• 3:31
  SPEAKER_00: consegue entender o que motivou aquela decisão.
• 3:34
  SPEAKER_00: E eu acho que é uma boa métrica pra gente entender se o desenvolvedor,
• 3:37
  SPEAKER_00: ele só escreveu o código ou se ele de fato resolveu o problema.
• 3:41
  SPEAKER_00: Porque se ele escreve o problema, é uma...
• 3:45
  Uma forma de ver que ele entendeu o que ele tá resolvendo ali a
• 3:49
  proposta.
• 3:49
  SPEAKER_00: Então,
• 3:50
  SPEAKER_00: eu acho que é uma forma legal de refletir,
• 3:53
  SPEAKER_00: assim,
• 3:53
  quando você vai abrir o PR e você tentar escrever qual que era
• 3:56
  o problema,
• 3:56
  SPEAKER_00: né?
• 3:57
  SPEAKER_00: O que você tá resolvendo.
• 3:58
  SPEAKER_00: E hoje a gente tem práticas estruturadas,
• 4:00
  SPEAKER_00: assim,
• 4:00
  SPEAKER_00: falando de arquitetura de software,
• 4:02
  SPEAKER_00: que ajuda também a trazer...
• 4:04
  SPEAKER_00: é mais essa linguagem de domínio para dentro da engenharia de software.
• 4:08
  A gente tem muitas empresas que utilizam a abordagem de Domain
• 4:11
  Drive Design,
• 4:12
  que ele traz uma modelagem já pensada mais em aproximar a
• 4:16
  linguagem técnica mesmo
• 4:17
  SPEAKER_00: da linguagem de negócio.
• 4:18
  SPEAKER_00: E eu acho que isso ajuda muito.
• 4:20
  SPEAKER_00: No fim das contas,
• 4:21
  SPEAKER_00: quando a gente consegue enxergar esse problema com clareza,
• 4:26
  SPEAKER_00: o código deixa de ser só execução e ele passa a ser uma solução real.
• 4:30
  SPEAKER_00: Então, acho que é bem válido.
• 4:43
  O Perguntas de Engenharia e Arquitetura,
• 4:45
  Socket Software,
• 4:46
  é patrocinado pelo ASUS.
• 4:47
  Acesse o link na descrição do episódio para saber mais sobre as
• 4:50
  vagas disponíveis
• 4:51
  SPEAKER_01: para a área de engenharia de software.
• 5:00
  SPEAKER_01: Estamos de volta.
• 5:01
  SPEAKER_01: O tema de hoje,
• 5:02
  SPEAKER_01: caso você não esteja olhando pro seu celular,
• 5:05
  SPEAKER_01: ou olhando pro seu Apple Watch,
• 5:08
  SPEAKER_01: ou olhando pra telinha do carro,
• 5:10
  SPEAKER_01: sei lá.
• 5:10
  SPEAKER_01: Como que é o tema que a gente colocou?
• 5:12
  SPEAKER_01: Pô, nem lembro.
• 5:14
  SPEAKER_01: Morte é o código complexo.
• 5:15
  SPEAKER_01: Simplicidade como ato de rebeldia.
• 5:17
  SPEAKER_02: Olha aí, ó. Aí, o tema aqui não é simples, né?
• 5:20
  SPEAKER_02: Um tema bem complexo.
• 5:22
  SPEAKER_01: Um tema bem complexo.
• 5:23
  Mas eu queria entender primeiro que vocês me expliquem o que é
• 5:27
  complexidade de código.
• 5:28
  Cara,
• 5:28
  acho que complexidade é qualquer coisa que seja muito difícil
• 5:33
  de entender.
• 5:34
  SPEAKER_02: Isso vale pra código, isso vale pra qualquer coisa na vida.
• 5:38
  Uma obra de arte pode ser uma obra de arte complexa se ela tem
• 5:41
  muitas camadas ou
• 5:41
  SPEAKER_02: que você tem que se perder muito tempo olhando pra entender ela.
• 5:45
  Tem muitas facetas,
• 5:46
  tem muitos detalhes,
• 5:47
  muitos poréns,
• 5:48
  muitas curvas,
• 5:50
  muitas nuances,
• 5:51
  muitas...
• 5:52
  SPEAKER_02: coisas,
• 5:52
  SPEAKER_02: assim,
• 5:52
  SPEAKER_02: acho que a complexidade no código meio que vai para esse caminho também,
• 5:56
  SPEAKER_02: sabe,
• 5:56
  SPEAKER_02: tipo,
• 5:57
  SPEAKER_02: tem muitas coisinhas,
• 5:58
  SPEAKER_02: muita coisa chamando outra coisa,
• 6:00
  SPEAKER_02: tem muita variável,
• 6:01
  SPEAKER_02: muito processo,
• 6:02
  SPEAKER_02: muito,
• 6:03
  SPEAKER_02: às vezes,
• 6:03
  SPEAKER_02: muita microtimização,
• 6:05
  SPEAKER_02: muito detalhezinho,
• 6:06
  SPEAKER_02: assim,
• 6:06
  SPEAKER_02: que gera uma complexidade que deixa o negócio difícil,
• 6:11
  SPEAKER_02: assim,
• 6:11
  SPEAKER_02: deixa algo que poderia ser fácil,
• 6:14
  SPEAKER_02: ele vira algo difícil.
• 6:17
  SPEAKER_02: Eu acho que é nessa linha mesmo.
• 6:19
  SPEAKER_02: Tipo,
• 6:19
  SPEAKER_02: quando eu penso em código complexo,
• 6:22
  SPEAKER_02: tem uma relação de quem está lendo e qual é o código,
• 6:25
  SPEAKER_02: né?
• 6:25
  SPEAKER_02: Porque,
• 6:25
  SPEAKER_02: por exemplo,
• 6:26
  SPEAKER_02: muito provavelmente,
• 6:27
  SPEAKER_02: vou usar esses nomes meio estranhos que a gente usa hoje em dia,
• 6:29
  SPEAKER_02: tipo sênior,
• 6:30
  SPEAKER_02: etc.
• 6:30
  SPEAKER_02: Vamos imaginar que um sênior ou qualquer coisa que vem depois disso,
• 6:33
  SPEAKER_02: mais especializado,
• 6:34
  SPEAKER_02: escreve um código.
• 6:35
  SPEAKER_02: Se a leitura é de um júnior,
• 6:37
  SPEAKER_02: de um estagiário,
• 6:38
  SPEAKER_02: talvez tudo pareça complexo,
• 6:40
  SPEAKER_02: até por uma questão de familiaridade.
• 6:42
  Mas eu acho que quando inverte,
• 6:43
  aí eu acho que é mais fácil dizer se é complexo.
• 6:45
  SPEAKER_02: Por exemplo,
• 6:46
  SPEAKER_02: tem um seno ali no código do Júlio e ele fala não estou entendendo nada,
• 6:49
  SPEAKER_02: pode ser um gap geracional,
• 6:50
  SPEAKER_02: né?
• 6:51
  SPEAKER_02: É código da geração alfa,
• 6:52
  mas no geral é porque talvez tenham mais camadas de
• 6:56
  interpretação ou faça muito
• 6:58
  SPEAKER_02: mais,
• 6:58
  tenha muito mais ginástica ali envolvida do que precisa para
• 7:00
  chegar na solução.
• 7:02
  SPEAKER_01: Mas vocês dizem,
• 7:02
  SPEAKER_01: assim,
• 7:03
  SPEAKER_01: que tipo,
• 7:03
  SPEAKER_01: sei lá,
• 7:04
  um cara que vai programar e ele separa muito código ou escreve
• 7:08
  muitas funções
• 7:09
  SPEAKER_01: separadas,
• 7:10
  SPEAKER_01: isso é deixar o código complexo também?
• 7:13
  SPEAKER_02: Ou não?
• 7:15
  SPEAKER_02: Sendo bem sênior aqui, eu vou dizer que depende, né?
• 7:17
  SPEAKER_02: Tipo, se tu tem motivo pra fazer isso, sim, né?
• 7:20
  SPEAKER_02: Mas se você não tem, aí não faz sentido, né?
• 7:23
  SPEAKER_02: Tipo,
• 7:23
  SPEAKER_02: você tem que pensar,
• 7:24
  SPEAKER_02: por exemplo,
• 7:25
  SPEAKER_02: em Java que você cria,
• 7:26
  SPEAKER_02: cada arquivo basicamente é uma classe,
• 7:28
  SPEAKER_02: né?
• 7:28
  SPEAKER_02: Se tu for começar a separar cada pedaço do código e for seguir muito,
• 7:31
  SPEAKER_02: acho que é o princípio do Solid,
• 7:32
  SPEAKER_02: que você tem que ter umas separações de responsabilidade,
• 7:36
  SPEAKER_02: acho que o S do Solid,
• 7:37
  SPEAKER_02: você tem que ter cada função faz uma coisinha só.
• 7:41
  SPEAKER_02: Se tu for pensar nisso,
• 7:43
  SPEAKER_02: uma classe para cada coisinha,
• 7:44
  SPEAKER_02: por exemplo,
• 7:44
  SPEAKER_02: você vai ter que ficar dando um control click ali
• 7:49
  SPEAKER_02: O tempo todo.
• 7:50
  SPEAKER_02: Então,
• 7:50
  SPEAKER_02: por mais que as funções estejam pequenas e simples,
• 7:54
  SPEAKER_02: esse pedacinho de código talvez seja simples,
• 7:56
  SPEAKER_02: você entender uma rotina inteira se torna um processo complexo.
• 7:59
  SPEAKER_02: Pode ser uma solução,
• 8:01
  SPEAKER_02: na verdade,
• 8:01
  SPEAKER_02: em alguns casos,
• 8:02
  para você ter um reaproveitamento de código e daí deixar outras
• 8:04
  coisas mais
• 8:05
  SPEAKER_02: simples,
• 8:05
  SPEAKER_02: mas também pode ser algo complexo porque você separou demais.
• 8:08
  SPEAKER_02: Você acaba tendo que juntar peças de um puzzle ou assim.
• 8:11
  SPEAKER_01: Sim,
• 8:12
  SPEAKER_01: e outra coisa que eu ia falar,
• 8:14
  SPEAKER_01: e a complexidade,
• 8:16
  SPEAKER_01: ela é perigosa,
• 8:18
  SPEAKER_01: tipo,
• 8:18
  a gente tem que evitar a complexidade só porque ela vai ser
• 8:21
  complexa para as outras
• 8:23
  SPEAKER_01: pessoas entenderem o código ou ela também pode ter outros sintomas,
• 8:27
  SPEAKER_01: tipo,
• 8:27
  SPEAKER_01: sei lá,
• 8:27
  SPEAKER_01: ter mais bugs ou ter performance PR?
• 8:31
  SPEAKER_02: Eu acho que os dois são verdade.
• 8:32
  Porque quando a gente pensa em complexidade,
• 8:35
  sempre tem aquela divisão,
• 8:35
  né?
• 8:35
  SPEAKER_02: Se a complexidade era necessária ou ela é acidental.
• 8:38
  SPEAKER_02: Aí eu acho que vai ao encontro do que você está dizendo,
• 8:40
  SPEAKER_02: que é,
• 8:41
  SPEAKER_02: bem,
• 8:41
  se realmente a solução é complexa a ponto de precisar de
• 8:45
  complexidade que envolve o
• 8:47
  SPEAKER_02: código ser complexo,
• 8:48
  SPEAKER_02: Talvez você não vá fugir da complexidade porque ela é necessária.
• 8:51
  SPEAKER_02: Então, beleza.
• 8:52
  SPEAKER_02: A gente sabe o porquê daquilo.
• 8:53
  SPEAKER_02: Existe uma intenção clara.
• 8:54
  SPEAKER_02: E se fizer diferente daquilo, a gente perde algo.
• 8:56
  SPEAKER_02: Aí esse algo pode ser performance ou outro tipo de ganho.
• 9:00
  SPEAKER_02: Mas quando ela é acidental, não, né?
• 9:02
  SPEAKER_02: Porque ainda que tenha esse fator social, é mais difícil de ler, mas...
• 9:05
  SPEAKER_02: No tempo isso compõe um problema, né?
• 9:07
  Porque se essa parte é complexa e no futuro você tem uma
• 9:10
  segunda parte complexa,
• 9:11
  SPEAKER_02: no futuro você tem uma terceira,
• 9:12
  SPEAKER_02: daqui a pouco elas se falam,
• 9:13
  SPEAKER_02: isso forma uma solução,
• 9:14
  tende a chegar no dia que a pessoa que não está acostumada a
• 9:18
  código legado ou
• 9:19
  alguma coisa mais complexa que a média vai dar a sugestão de
• 9:23
  tem que reescrever.
• 9:24
  SPEAKER_02: Então, ter que reescrever normalmente não é a solução.
• 9:27
  Mas às vezes a gente está num buraco tão sem saída que o custo
• 9:31
  do refactoring com
• 9:32
  SPEAKER_02: qualidade versus reescrever talvez valha a pena.
• 9:35
  SPEAKER_02: E aí quando a gente pensa o que é complexo,
• 9:37
  SPEAKER_02: talvez a contraposição seja discutir o que é simples,
• 9:40
  SPEAKER_02: mas aí vamos vendo.
• 9:42
  Mas eu acho que de fato um código muito complexo traz uma série
• 9:45
  de problemas,
• 9:46
  SPEAKER_02: principalmente débito técnico,
• 9:47
  SPEAKER_02: que você vai gastar tempo de alguém para ler isso depois no futuro,
• 9:51
  SPEAKER_02: então se você escrever algo complexo para algo que era simples,
• 9:54
  SPEAKER_02: a pessoa vai ficar horas ali lendo,
• 9:55
  SPEAKER_02: tentando entender,
• 9:56
  ou ela vai te consultar e fazer você gastar seu tempo de novo
• 9:59
  com aquilo para...
• 10:00
  SPEAKER_02: Ela entendeu o que você escreveu.
• 10:02
  SPEAKER_02: Também já era a própria questão de bugs.
• 10:04
  SPEAKER_02: Quando é difícil de entender,
• 10:05
  SPEAKER_02: você pode não ver alguma nuance,
• 10:07
  SPEAKER_02: alguma coisa,
• 10:08
  SPEAKER_02: algum detalhe que você pode passar despercebido.
• 10:11
  SPEAKER_02: de teste que você não percebeu,
• 10:12
  SPEAKER_02: porque enfim,
• 10:13
  você tinha tanta coisa na cabeça naquele momento que você tinha
• 10:16
  que colocar muita
• 10:17
  SPEAKER_02: coisa na cabeça,
• 10:17
  SPEAKER_02: no caso,
• 10:18
  SPEAKER_02: porque você tinha que entender aquele código,
• 10:19
  SPEAKER_02: que você acaba esquecendo algum cenário,
• 10:21
  SPEAKER_02: acaba deixando passar alguma coisa,
• 10:23
  SPEAKER_02: esquece de testar determinada coisa,
• 10:25
  SPEAKER_02: então acho que um código muito complexo,
• 10:28
  SPEAKER_02: de fato,
• 10:29
  SPEAKER_02: vai trazer mais bugs,
• 10:30
  SPEAKER_02: com certeza.
• 10:30
  SPEAKER_02: E tem muito da EgoTrip também, né?
• 10:32
  Às vezes o código só é complexo porque alguém que acabou de
• 10:35
  aprender algumas
• 10:36
  SPEAKER_02: features da linguagem quer usar pra dizer que usou.
• 10:39
  SPEAKER_02: Então existe essa,
• 10:40
  SPEAKER_02: em momentos,
• 10:41
  uma competição velada de quem é mais hardcore entendedor da
• 10:44
  linguagem específica.
• 10:46
  E aí o código fica complexo como uma sinalização de eu sou mais
• 10:49
  inteligente.
• 10:50
  SPEAKER_02: Só que, na verdade, você tá provando o oposto, né?
• 10:51
  SPEAKER_02: Você tá provando que você não consegue fazer de um jeito simples.
• 10:54
  SPEAKER_02: É,
• 10:54
  SPEAKER_02: isso até é uma história engraçada,
• 10:56
  SPEAKER_02: assim,
• 10:56
  SPEAKER_02: porque eu lembro que tinha um cara que trabalhava comigo,
• 10:58
  SPEAKER_02: assim,
• 10:59
  SPEAKER_02: eu não lembro qual foi o contexto,
• 11:01
  SPEAKER_02: assim,
• 11:01
  SPEAKER_02: mas eu fiz um PR lá,
• 11:03
  SPEAKER_02: eu subi,
• 11:03
  SPEAKER_02: depois ele pegou meu Slack e perguntou assim,
• 11:05
  SPEAKER_02: pô,
• 11:05
  SPEAKER_02: cara,
• 11:05
  SPEAKER_02: por que que tu não usou uma mona daqui?
• 11:08
  SPEAKER_02: E eu, que caralho é uma mona?
• 11:10
  SPEAKER_02: É sempre eles, né, cara?
• 11:12
  É sempre os doidão do funcional que quer ficar empurrando um
• 11:14
  negócio que não precisa no código.
• 11:16
  Sabe,
• 11:16
  tipo,
• 11:16
  o cara descobriu que era uma monada,
• 11:18
  agora eu queria aplicar em tudo,
• 11:20
  assim.
• 11:20
  SPEAKER_02: E aí ele me explicou o que que era,
• 11:21
  SPEAKER_02: e eu,
• 11:22
  SPEAKER_02: cara,
• 11:22
  SPEAKER_02: porque acho que vai ficar muito mais complexo do que tá,
• 11:25
  SPEAKER_02: e agora tu pensa um júnior,
• 11:26
  SPEAKER_02: entendeu,
• 11:26
  SPEAKER_02: o que que é uma monada,
• 11:27
  SPEAKER_02: sabe?
• 11:28
  SPEAKER_02: Beleza,
• 11:28
  SPEAKER_02: ela pode ter um caso de uso,
• 11:30
  SPEAKER_02: assim,
• 11:30
  SPEAKER_02: uma coisa que ela funcione,
• 11:31
  SPEAKER_02: mas pra esse caso ele vai deixar mais complexo,
• 11:33
  SPEAKER_02: ele pode ficar bonito,
• 11:34
  SPEAKER_02: pode ficar algo que tu vai mostrar com a tua mãe depois,
• 11:36
  SPEAKER_02: alguma coisa assim,
• 11:37
  SPEAKER_02: mas ele vai deixar o código mais complexo do que ele precisa,
• 11:40
  SPEAKER_02: porque é um contexto que não é muito usado a você fazer isso,
• 11:43
  SPEAKER_02: né?
• 11:43
  SPEAKER_02: É,
• 11:43
  SPEAKER_02: e inclusive tem essa parte do fator como esse time é composto,
• 11:48
  SPEAKER_02: quem são as pessoas que mantêm o software.
• 11:50
  Porque vão ter casos onde usar uma feature específica ou uma
• 11:54
  técnica específica vai
• 11:56
  SPEAKER_02: de encontro a ter mais corretude,
• 11:58
  SPEAKER_02: de ser mais elegante.
• 11:59
  SPEAKER_02: Mas o ponto é, para quem?
• 12:01
  SPEAKER_02: Porque ele pode ser elegante em abstrato,
• 12:03
  SPEAKER_02: para alguém que você nunca ouviu falar ou que não existe,
• 12:06
  SPEAKER_02: olhar o código e falar nossa,
• 12:08
  SPEAKER_02: você usou a coisa que é muito elegante,
• 12:09
  SPEAKER_02: agora só tem três linhas ao invés de vinte.
• 12:11
  SPEAKER_02: Mas o time que mantém,
• 12:13
  ele tem condições de olhar para aquilo e retirar esse benefício
• 12:18
  ou da elegância ou
• 12:19
  SPEAKER_02: da feature?
• 12:19
  SPEAKER_02: Às vezes não.
• 12:21
  Então ser um pouco mais,
• 12:23
  não declarativo,
• 12:24
  mas se você for um pouco mais específico,
• 12:26
  SPEAKER_02: positivo, né?
• 12:27
  SPEAKER_02: Falar exatamente o que você quer,
• 12:29
  SPEAKER_02: ao invés de tentar não fazer esses equilíbrios de,
• 12:31
  SPEAKER_02: nossa,
• 12:31
  SPEAKER_02: se eu escrever,
• 12:32
  SPEAKER_02: quanto menos código,
• 12:33
  SPEAKER_02: melhor,
• 12:34
  SPEAKER_02: né?
• 12:34
  SPEAKER_02: Tipo, a super one-liner que resolve tudo.
• 12:36
  SPEAKER_02: Eu acho que a gente devia evitar isso pensando em quem vai ler.
• 12:39
  SPEAKER_02: E quem vai ler não é um leitor abstrato, né?
• 12:41
  SPEAKER_02: Do tipo, qual é a média de leitores de código do Brasil?
• 12:44
  SPEAKER_02: Não é assim que a gente pensa.
• 12:46
  SPEAKER_02: Quem são as pessoas que mantêm o código hoje ou num futuro observável?
• 12:49
  SPEAKER_02: E aí que vem um balanço, que eu acho que é uma conversa difícil, que é
• 12:52
  Se a gente colocar todas as partes do código de forma muito
• 12:56
  fácil de entender,
• 12:57
  consequentemente o todo vai ser mais difícil de ler porque é
• 13:01
  uma nuvem muito grande
• 13:02
  SPEAKER_02: de coisas óbvias.
• 13:03
  SPEAKER_02: Mas ao contrário,
• 13:04
  SPEAKER_02: também é verdade nesse trade-off que é.
• 13:06
  SPEAKER_02: Se você usar um código altamente declarativo,
• 13:08
  SPEAKER_02: onde você pega cinco linhas que diz exatamente o que deveria acontecer,
• 13:12
  SPEAKER_02: é muito difícil entender as partes.
• 13:13
  Então existe um equilíbrio entre o que você quer entender mais
• 13:17
  rápido,
• 13:17
  o todo ou as partes.
• 13:19
  Aí depende de qual é a característica do software,
• 13:21
  como que ele é mantido.
• 13:22
  SPEAKER_02: Quando tiver um bug, o que você prefere?
• 13:24
  Só reescrever mais rápido porque é três linhas de novo ou
• 13:27
  entender tudo o que está acontecendo?
• 13:28
  Isso não é um problema óbvio,
• 13:30
  mas é uma escolha que você tem que ter todo dia.
• 13:32
  SPEAKER_01: Sim,
• 13:32
  e eu lembro que uma vez eu ouvi uma frase que falava que a
• 13:36
  simplicidade não é o
• 13:39
  SPEAKER_01: primeiro trabalho,
• 13:39
  SPEAKER_01: é a última revisão.
• 13:41
  SPEAKER_01: Então, basicamente, até a gente fez um posting brincando sobre isso na...
• 13:47
  SPEAKER_01: no Instagram da Codecom, que é vomita, depois refatoria.
• 13:50
  SPEAKER_01: Tipo,
• 13:50
  primeiro tu vai lá e escreve o código do jeito que tá na tua
• 13:53
  cabeça pra fazer ele e
• 13:55
  SPEAKER_01: depois tu vai melhorando sempre com esse pensamento
• 14:00
  Não sei se vocês têm alguma técnica que vocês usam,
• 14:03
  assim,
• 14:04
  pra evitar escrever código complexo.
• 14:05
  É,
• 14:06
  eu acho que essa que você descreveu é perfeita,
• 14:09
  assim,
• 14:09
  tipo,
• 14:09
  eu uso ao direto mesmo.
• 14:10
  SPEAKER_02: Primeiro eu tento escrever,
• 14:11
  SPEAKER_02: ou,
• 14:11
  SPEAKER_02: tipo,
• 14:11
  SPEAKER_02: às vezes eu escrevo na mão mesmo,
• 14:13
  SPEAKER_02: assim,
• 14:13
  SPEAKER_02: eu não escrevo o código,
• 14:14
  SPEAKER_02: né?
• 14:14
  SPEAKER_02: Escrevo mais ou menos o passo a passo que ele tem que fazer,
• 14:16
  SPEAKER_02: assim,
• 14:16
  SPEAKER_02: tipo,
• 14:16
  SPEAKER_02: o que seria o algoritmo.
• 14:17
  SPEAKER_02: E aí eu vou transformando isso em código,
• 14:20
  vou vendo mais ou menos algumas coisas que eu acho que está
• 14:22
  para ir melhorando e
• 14:23
  SPEAKER_02: depois no final tento pensar,
• 14:25
  SPEAKER_02: dou uma olhada geral assim e vejo,
• 14:26
  SPEAKER_02: pô,
• 14:26
  SPEAKER_02: tá bom,
• 14:27
  SPEAKER_02: dá para entender,
• 14:28
  SPEAKER_02: sabe?
• 14:28
  SPEAKER_02: Tipo, eu consigo explicar isso aqui fácil.
• 14:31
  Acho que essa técnica de botar para fora primeiro para resolver
• 14:33
  logo e depois
• 14:34
  SPEAKER_02: refatorar costuma funcionar.
• 14:36
  SPEAKER_02: bem.
• 14:36
  SPEAKER_02: Eu acho que às vezes...
• 14:37
  SPEAKER_02: Porque se tu às vezes tenta fazer o contrário,
• 14:39
  SPEAKER_02: assim,
• 14:40
  SPEAKER_02: você tenta pensar muito em design,
• 14:41
  SPEAKER_02: tem até um termo que eles usam,
• 14:42
  SPEAKER_02: né?
• 14:43
  SPEAKER_02: Paralysis by analysis.
• 14:44
  SPEAKER_02: Quando você fica paralisado pra ficar analisando demais.
• 14:47
  SPEAKER_02: Tanto tempo pensando,
• 14:48
  SPEAKER_02: tentando chegar na solução perfeita,
• 14:50
  SPEAKER_02: assim,
• 14:50
  SPEAKER_02: que no fim você pode até,
• 14:51
  SPEAKER_02: na verdade,
• 14:52
  SPEAKER_02: acabar criando complexidade por ter pensado demais,
• 14:55
  SPEAKER_02: assim.
• 14:55
  SPEAKER_02: Porque você fez um caminho mental que outras pessoas não fizeram.
• 14:58
  SPEAKER_02: Essa ideia de vomitar uma solução e depois você ir meio que pulindo ela,
• 15:02
  SPEAKER_02: assim,
• 15:02
  SPEAKER_02: eu acho que ela tende a funcionar bem.
• 15:03
  SPEAKER_02: Você até
• 15:04
  SPEAKER_02: Porque, às vezes, você precisa entregar rápido, né?
• 15:05
  SPEAKER_02: Então,
• 15:06
  SPEAKER_02: às vezes,
• 15:06
  SPEAKER_02: você entregar alguma coisa funcionando,
• 15:08
  SPEAKER_02: por mais que seja feio,
• 15:09
  SPEAKER_02: acaba sendo melhor,
• 15:12
  SPEAKER_02: né?
• 15:12
  SPEAKER_02: E aí, depois, os outros podem até te ajudar a refatorar, né?
• 15:14
  SPEAKER_02: Se for o caso...
• 15:15
  SPEAKER_02: Eles vão olhar pro teu código e falar,
• 15:16
  SPEAKER_02: pô,
• 15:17
  SPEAKER_02: tenta fazer isso aqui desse jeito e tal.
• 15:19
  Às vezes,
• 15:19
  o próprio trabalho de simplificar o código não precisa ser tão
• 15:22
  solitário,
• 15:22
  assim.
• 15:23
  SPEAKER_02: Você pode ter a ajuda de outras pessoas, né?
• 15:24
  SPEAKER_02: É,
• 15:24
  SPEAKER_02: inclusive tem uma coisa que se chama The Unix Way,
• 15:28
  SPEAKER_02: que exatamente vai na linha disso que eles falam.
• 15:30
  SPEAKER_02: Make it work, make it right, make it fast.
• 15:33
  SPEAKER_02: Ou seja, primeiro você tem que fazer funcionar, né?
• 15:35
  SPEAKER_02: Funciona ou não funciona?
• 15:36
  SPEAKER_02: Beleza.
• 15:37
  Mas funciona certo,
• 15:38
  porque vão ter alguns ad cases e outras coisas que você vai ter
• 15:41
  que lidar.
• 15:42
  SPEAKER_02: Tipo assim, agora ele é correto, tem a corretude que você precisa, sim.
• 15:45
  SPEAKER_02: Agora que finalmente a gente chegou em algum lugar,
• 15:47
  SPEAKER_02: a gente pode pensar em fazer ele ficar mais rápido.
• 15:48
  SPEAKER_02: Ou seja, a gente não otimiza antes de começar o trabalho.
• 15:53
  SPEAKER_02: E aí quando a gente pensa em otimização,
• 15:54
  SPEAKER_02: a gente tem que lembrar que tempo do mundo real também é otimização.
• 15:58
  SPEAKER_02: Então como é que a gente ganha tempo no mundo real?
• 15:59
  SPEAKER_02: Quando a gente cria abstração, né?
• 16:01
  SPEAKER_02: Se a gente cria abstração,
• 16:01
  a gente não tem que lidar de novo com tudo aquilo que já foi
• 16:04
  abstraído por nós ou
• 16:05
  SPEAKER_02: por outras pessoas,
• 16:06
  SPEAKER_02: do tipo uma biblioteca,
• 16:08
  SPEAKER_02: a forma de modelar o sistema.
• 16:09
  Então tudo isso,
• 16:10
  todos esses tipos de abstrações servem para a gente ganhar
• 16:12
  tempo.
• 16:13
  Só se a gente tentar ganhar tempo no primeiro minuto da
• 16:15
  modelagem ou do software...
• 16:17
  SPEAKER_02: provavelmente a gente está otimizando.
• 16:18
  SPEAKER_02: E aí quando a gente pensa em otimização,
• 16:19
  SPEAKER_02: é muito fácil a gente levar isso para o mundo do benchmark,
• 16:22
  SPEAKER_02: quão rápido é o código,
• 16:23
  SPEAKER_02: mas otimização tem outras facetas.
• 16:25
  SPEAKER_02: Por exemplo, essa de abstrair cedo.
• 16:27
  E aí que vem o ponto de lembrar que tem linguagens que deixam
• 16:30
  isso mais difícil e mais fácil.
• 16:32
  SPEAKER_02: Por exemplo,
• 16:33
  SPEAKER_02: infelizmente vou ter que falar dele,
• 16:34
  SPEAKER_02: mas assim,
• 16:35
  SPEAKER_02: quando a gente vai olhar para o Java,
• 16:36
  SPEAKER_02: pelo menos os Java antes das 25 versões que ele tem,
• 16:40
  SPEAKER_02: você precisa dizer qual é a sua interface antes.
• 16:43
  SPEAKER_02: Você não pode declarar ela depois que o código já existe.
• 16:45
  SPEAKER_02: Você não tem essa opção.
• 16:46
  SPEAKER_02: Porque as interfaces em Java são nominais, né?
• 16:48
  SPEAKER_02: Você tem que dizer, implementes tal coisa.
• 16:51
  SPEAKER_02: Porque se não tiver isso escrito, não vai implementar e pronto, acabou.
• 16:54
  SPEAKER_02: Tem outras linguagens onde esse tipo de uso de interface é estrutural.
• 16:58
  SPEAKER_02: Então, tipo, se você tem as mesmas assinaturas, vai rolar.
• 17:01
  SPEAKER_02: Aí em umas linguagens é duct type, em outras se chama de outra coisa.
• 17:04
  SPEAKER_02: Mas o que eu quero dizer com isso tudo?
• 17:06
  SPEAKER_02: Se você tem que saber qual é a tua abstração antes,
• 17:09
  então o jeito de pensar quando você está nessas linguagens meio
• 17:12
  que não é tão bom,
• 17:14
  porque você tem que imaginar como vai ser usado em N casos
• 17:17
  antes mesmo de ter o
• 17:18
  SPEAKER_02: primeiro.
• 17:19
  SPEAKER_02: Então,
• 17:19
  SPEAKER_02: teoricamente,
• 17:20
  SPEAKER_02: não quer dizer que é uma regra,
• 17:21
  SPEAKER_02: quando você programa em Java,
• 17:22
  SPEAKER_02: você está otimizando cedo demais.
• 17:24
  SPEAKER_02: Mas isso é uma característica da linguagem.
• 17:26
  Isso serve para ser Sharp e outras coisas que você tem que
• 17:28
  nominalmente dizer.
• 17:30
  Essa classe ou o nome da coisa que for a linguagem implementa
• 17:34
  explicitamente essa interface.
• 17:35
  SPEAKER_02: E aí isso traz um problema, né?
• 17:37
  SPEAKER_02: Porque de uma hora para outra você tem que saber qual é o segundo,
• 17:40
  SPEAKER_02: terceiro,
• 17:40
  SPEAKER_02: quarto caso que aquilo vai ser usado sem conhecer os casos.
• 17:46
  SPEAKER_02: Eu acho que isso até é um bom exemplo.
• 17:49
  Não é porque a linguagem tem um paradigma que você é obrigado a
• 17:52
  ter esse paradigma
• 17:53
  SPEAKER_02: na sua cabeça também.
• 17:54
  Então o próprio Java é um bom exemplo de quando você faz uma
• 17:58
  programação muito
• 17:59
  orientada à interface e às vezes você nem tem um código que é
• 18:02
  tão reutilizável,
• 18:03
  SPEAKER_02: que você vai precisar dessas interfaces depois,
• 18:05
  SPEAKER_02: você acaba...
• 18:06
  SPEAKER_02: criando uma complexidade desnecessária.
• 18:07
  Então,
• 18:08
  agora,
• 18:08
  para toda classe que você for criar,
• 18:09
  você vai ter que criar uma interface.
• 18:11
  SPEAKER_02: Então, às vezes, você só precisa de uma classe mesmo.
• 18:14
  SPEAKER_02: Você só vai ter um caso que vai utilizar isso.
• 18:16
  Acho que até uma das críticas que fazem em cima do clean code é
• 18:20
  justamente isso.
• 18:20
  SPEAKER_02: Ele acaba gerando muito código,
• 18:22
  SPEAKER_02: muita complexidade,
• 18:23
  SPEAKER_02: às vezes,
• 18:23
  SPEAKER_02: desnecessária para ter um código,
• 18:25
  SPEAKER_02: abre aspas,
• 18:26
  SPEAKER_02: limpo.
• 18:26
  SPEAKER_02: Mas é um...
• 18:27
  SPEAKER_02: É um limpo, às vezes, para um tipo de utilidade específica.
• 18:30
  SPEAKER_02: É uma utilidade no sentido,
• 18:31
  SPEAKER_02: às vezes,
• 18:32
  SPEAKER_02: mais de você não ficar tão preso,
• 18:33
  SPEAKER_02: às vezes,
• 18:34
  SPEAKER_02: a frameworks ou a detalhes de implementação,
• 18:37
  SPEAKER_02: coisas mais específicas,
• 18:39
  SPEAKER_02: integrações.
• 18:40
  SPEAKER_02: Ele fica mais limpo nesse sentido,
• 18:41
  SPEAKER_02: mas às vezes não fica tão limpo para quem for ler,
• 18:43
  SPEAKER_02: por exemplo.
• 18:43
  SPEAKER_02: Então é bem o que o Alex falou, sabe, de...
• 18:45
  Às vezes você otimizar é otimizar tempo de leitura de outros
• 18:49
  devs lendo o seu código.
• 18:51
  Você otimizar eles entenderem o seu código e justamente não
• 18:55
  sofrendo coisas com
• 18:56
  bugs e não seguir necessariamente as boas práticas de
• 18:59
  organização de código,
• 19:00
  SPEAKER_02: fazer um 5S do código,
• 19:01
  SPEAKER_02: sabe?
• 19:02
  SPEAKER_02: Deixar as coisas com gavetinhas corretas, com as labels corretas, etc.
• 19:06
  SPEAKER_02: O problema do Clean Code é que ele existe, né?
• 19:08
  SPEAKER_02: Esse que é a principal crítica.
• 19:09
  SPEAKER_02: O Clean Code é que ele foi escrito, né?
• 19:12
  SPEAKER_01: O Bruno Rocha,
• 19:13
  SPEAKER_01: ele veio aqui,
• 19:13
  SPEAKER_01: participou,
• 19:14
  SPEAKER_01: ele falou que ele já leu o Clean Code várias vezes,
• 19:17
  SPEAKER_01: até outras versões que tem dele.
• 19:19
  SPEAKER_01: E ele, tipo, ele usa pra, tipo, saber o que não fazer, assim, também, né?
• 19:25
  SPEAKER_01: Tipo,
• 19:25
  SPEAKER_01: ele interpreta aquilo e tem a própria...
• 19:28
  SPEAKER_01: Só que tem muita gente que lê o Clean Code e leva aquilo como,
• 19:31
  SPEAKER_01: tipo,
• 19:31
  SPEAKER_01: não,
• 19:31
  SPEAKER_01: essas são as regras universais,
• 19:33
  SPEAKER_01: eu não posso...
• 19:35
  SPEAKER_01: Não posso fazer nada de errado.
• 19:36
  Acho que você tem que ter essa sabedoria de saber quando
• 19:39
  implementar ou não,
• 19:40
  SPEAKER_02: de quando ele de fato vai fazer sentido ou não.
• 19:42
  SPEAKER_02: Porque tem contextos que você vai precisar de um reaproveitamento e,
• 19:45
  SPEAKER_02: cara,
• 19:45
  SPEAKER_02: uma interface vai te resolver muita coisa.
• 19:47
  SPEAKER_02: Um exemplo prático é quando você vai trabalhar,
• 19:49
  SPEAKER_02: por exemplo,
• 19:49
  com manipulação de arquivo e você não sabe se o arquivo vai ser
• 19:52
  salvo em disco,
• 19:52
  SPEAKER_02: no S3 ou num pendrive,
• 19:55
  SPEAKER_02: tá ligado?
• 19:56
  Você tem uma interface que vai basicamente te permitir ter essa
• 20:00
  maleabilidade de escolher...
• 20:01
  SPEAKER_02: onde que você vai plugar,
• 20:02
  SPEAKER_02: assim,
• 20:03
  SPEAKER_02: então você tem quase como se fosse um adaptadorzinho mesmo,
• 20:06
  SPEAKER_02: assim,
• 20:06
  SPEAKER_02: que dependendo do que,
• 20:08
  SPEAKER_02: onde você for implementar,
• 20:09
  SPEAKER_02: né,
• 20:09
  SPEAKER_02: você tem uma base em comum entre essas três classes,
• 20:12
  SPEAKER_02: por exemplo,
• 20:12
  SPEAKER_02: então,
• 20:13
  SPEAKER_02: nesse caso faz sentido você ter uma interface,
• 20:14
  SPEAKER_02: agora para outras coisas,
• 20:15
  SPEAKER_02: às vezes não.
• 20:16
  SPEAKER_01: E quando o Alex estava falando,
• 20:18
  eu também lembrei daquela biblioteca famosa JavaScript chamada
• 20:22
  Underscore,
• 20:23
  SPEAKER_01: se vocês já passaram por isso?
• 20:25
  mas basicamente é um underline e ele é tipo underline o nome da
• 20:30
  função é underline
• 20:31
  e daí ela tem várias na verdade o nome da classe é underline e
• 20:34
  daí ela tem várias
• 20:35
  funções mas tipo é horrível assim eu já passei por isso no
• 20:38
  código e daí tipo tá o
• 20:39
  que que faz isso é tipo um underline ponto slug sei lá e daí
• 20:43
  ele faz o slug da
• 20:44
  SPEAKER_01: parada daí tipo sei lá
• 20:46
  SPEAKER_01: Eu acho muito...
• 20:47
  SPEAKER_01: Ah,
• 20:47
  é tipo um compilado de um monte de função utilitária que você
• 20:51
  pode usar em qualquer
• 20:52
  SPEAKER_02: lugar,
• 20:52
  SPEAKER_02: tipo isso.
• 20:52
  SPEAKER_02: É, geralmente de texto, isso.
• 20:55
  SPEAKER_02: Entendi, entendi.
• 20:56
  SPEAKER_02: É, JavaScript é isso aí, né?
• 20:58
  SPEAKER_02: Esse mundinho aí.
• 20:58
  SPEAKER_02: Não tem como fugir muito, não.
• 21:00
  SPEAKER_02: É a caixa de Pandora da programação, hein?
• 21:02
  Era para ser usado no browser,
• 21:04
  mas aí inventaram de jogar isso em qualquer lugar.
• 21:06
  SPEAKER_02: A main que tem o WebAssembly agora, que aí ninguém precisa mais usar.
• 21:10
  SPEAKER_02: Mas beleza.
• 21:13
  SPEAKER_01: Teve outra coisa que eu vi no artigo recente também,
• 21:16
  SPEAKER_01: que fala sobre que a maior parte dos códigos é sem graça.
• 21:21
  SPEAKER_02: Tomara, eu prefiro que seja assim mesmo.
• 21:23
  SPEAKER_01: Não, mas é verdade, né?
• 21:25
  SPEAKER_01: É verdade.
• 21:25
  SPEAKER_01: Só que tem muita gente que fica nessa pira de,
• 21:28
  SPEAKER_01: tipo,
• 21:28
  SPEAKER_01: querer criar coisas magníficas e fazer códigos incríveis,
• 21:34
  SPEAKER_01: né?
• 21:35
  SPEAKER_01: Eu não sei se vocês sentem isso também, ou já sentiram antigamente.
• 21:39
  Não sei se vocês têm alguma coisa assim de como resistir a essa
• 21:42
  tentação de tentar
• 21:44
  SPEAKER_01: não fazer um código chato,
• 21:45
  SPEAKER_01: tá ligado?
• 21:46
  SPEAKER_02: Acho que é meio que uma rebeldia contra o próprio ego, assim, tá ligado?
• 21:49
  SPEAKER_02: A gente botou esse rótulo de que a gente é engenheiro, né?
• 21:52
  SPEAKER_02: E aí a gente bota na cabeça que a gente tem que fazer engenharia.
• 21:55
  SPEAKER_02: Não é bem isso, né?
• 21:56
  SPEAKER_02: Tipo,
• 21:57
  SPEAKER_02: eu acho que,
• 21:58
  SPEAKER_02: eu não sei,
• 21:58
  SPEAKER_02: pelo menos pra mim,
• 21:59
  SPEAKER_02: assim,
• 21:59
  SPEAKER_02: a simplicidade é um negócio que é até gratificante,
• 22:01
  SPEAKER_02: sabe?
• 22:02
  SPEAKER_02: Que,
• 22:02
  SPEAKER_02: tipo,
• 22:02
  sabe quando você olha pra um problema complexo e você resolve
• 22:05
  ele de um jeito
• 22:05
  SPEAKER_02: simples,
• 22:06
  SPEAKER_02: etc?
• 22:09
  SPEAKER_02: um negócio complexo de um jeito muito simples.
• 22:12
  Que é diferente de quando você pega um problema complexo e
• 22:14
  resolve de um jeito complexo.
• 22:15
  SPEAKER_02: Você fica pensando que você é um maluco, basicamente.
• 22:17
  Porque você olha pra aquilo lá e pensa cara,
• 22:19
  como é que eu cheguei nessa solução,
• 22:20
  sabe?
• 22:21
  SPEAKER_02: Aquela velha piada, né?
• 22:22
  Tipo,
• 22:22
  quando eu comecei isso aqui,
• 22:24
  Deus e eu sabíamos o que estávamos fazendo.
• 22:25
  SPEAKER_02: Agora só Deus sabe.
• 22:26
  Porque às vezes é um processo tão complexo assim que até te
• 22:29
  explicar pra outra pessoa,
• 22:31
  sei lá.
• 22:31
  SPEAKER_02: Não é um...
• 22:32
  SPEAKER_02: Pelo menos pra mim,
• 22:33
  SPEAKER_02: assim,
• 22:34
  SPEAKER_02: eu não consigo olhar pra aquilo dali e pensar,
• 22:35
  SPEAKER_02: cara,
• 22:36
  SPEAKER_02: eu fiz um bom trabalho,
• 22:36
  SPEAKER_02: sabe?
• 22:37
  SPEAKER_02: Porque é um negócio tão... É uma engenhoca, você fez uma engenhoca, sabe?
• 22:40
  SPEAKER_02: Você não se orgulha de uma engenhoca.
• 22:42
  Mas essa parada de código complexo é uma parada...
• 22:45
  Escrever código simples,
• 22:47
  na real.
• 22:47
  SPEAKER_01: É uma parada meio mestre Miyagi,
• 22:49
  SPEAKER_01: assim,
• 22:50
  SPEAKER_01: que quanto mais conhecimento tu tem,
• 22:53
  SPEAKER_01: mais código simples tu consegue escrever?
• 22:55
  SPEAKER_01: Ou,
• 22:55
  SPEAKER_01: tipo,
• 22:56
  é uma parada que tu já consegue fazer desde quando começou a
• 22:59
  aprender a programar,
• 23:00
  SPEAKER_01: assim?
• 23:00
  É,
• 23:00
  eu não sei,
• 23:01
  porque quando a gente tá começando,
• 23:03
  a gente não tem referencial,
• 23:04
  né?
• 23:04
  SPEAKER_02: Então, todo código, ele só existe, né?
• 23:06
  SPEAKER_02: Ele não é nem simples e nem difícil.
• 23:08
  Quando você tá literalmente conversando,
• 23:10
  tudo é complexo,
• 23:10
  porque,
• 23:11
  sei lá,
• 23:12
  né?
• 23:12
  SPEAKER_02: Tem um if dentro do fork, o que será que é isso?
• 23:14
  SPEAKER_02: E aí é complexo porque você não está acostumado.
• 23:17
  SPEAKER_02: Aí vão ter algumas coisas que vão ser familiaridade, né?
• 23:20
  E outras coisas vão ser aprendizado que você vai conseguir
• 23:22
  levar para outros lugares.
• 23:23
  SPEAKER_02: Então, com o passar do tempo, o ecossistema onde você está inserido, né?
• 23:28
  SPEAKER_02: Eu vou dar um exemplo hipotético.
• 23:30
  SPEAKER_02: Não tão hipotético assim, mas muito hipotético.
• 23:32
  SPEAKER_02: Imagina que você passou a vida inteira trabalhando no HSBC,
• 23:35
  em vez de numa startup ou em qualquer feng que as pessoas
• 23:38
  gostam de dizer que é o
• 23:39
  SPEAKER_02: melhor lugar do mundo.
• 23:40
  SPEAKER_02: Provavelmente,
• 23:41
  SPEAKER_02: o código mais simples que você viu,
• 23:43
  SPEAKER_02: ele tem várias complexidades acidentais e vários dogmas.
• 23:46
  SPEAKER_02: Tipo,
• 23:46
  SPEAKER_02: um pouquinho de clean code,
• 23:47
  SPEAKER_02: um pouquinho de coisas tipo da Microsoft,
• 23:49
  SPEAKER_02: event source,
• 23:50
  SPEAKER_02: essas coisas.
• 23:51
  SPEAKER_02: Então,
• 23:51
  SPEAKER_02: se a tua visão de mundo é só existe esses três meio que jeitos de fazer,
• 23:56
  SPEAKER_02: a tua noção de simples pode ser,
• 24:00
  SPEAKER_02: eu já fiz isso aqui tantas vezes que se tornou simples,
• 24:02
  SPEAKER_02: é uma questão de costume,
• 24:03
  SPEAKER_02: ou não tem como ser mais simples que isso,
• 24:04
  SPEAKER_02: porque eu nunca vi.
• 24:06
  Então,
• 24:06
  se for mais simples que isso,
• 24:08
  pode ser lido,
• 24:08
  inclusive,
• 24:08
  como errado.
• 24:09
  SPEAKER_02: Tipo assim, como assim não tem todas essas proteções que eu não vou usar?
• 24:13
  SPEAKER_02: Essa é uma forma de ver.
• 24:15
  SPEAKER_02: E qual é a pergunta?
• 24:16
  Porque eu acho que eu falei de um cenário hipotético,
• 24:18
  mas eu não respondi ela.
• 24:20
  Eu tava perguntando sobre quanto mais experiente você é,
• 24:24
  mais fácil fica escrever código.
• 24:26
  SPEAKER_02: Ah, sim, com certeza.
• 24:27
  SPEAKER_02: Então, e é por isso que eu disse isso.
• 24:29
  Porque você pode ter menos experiência e ter passado por
• 24:33
  lugares onde você
• 24:33
  conseguiu aprender ou com pessoas ou com cenários que
• 24:36
  demonstraram que essa
• 24:37
  SPEAKER_02: simplicidade é possível e qual é os efeitos dela,
• 24:40
  SPEAKER_02: né?
• 24:40
  Tipo,
• 24:41
  se fizer desse jeito,
• 24:41
  eu ganho isso,
• 24:42
  perco aquilo,
• 24:42
  tenho aqueles trade-offs.
• 24:43
  SPEAKER_02: Mas, de qualquer maneira, você entendeu...
• 24:46
  meio que por osmose ou por empiria que existe algo que dá pra
• 24:50
  chamar de elegante.
• 24:51
  SPEAKER_02: Com o tempo, você começa a associar características, né?
• 24:54
  SPEAKER_02: Ah,
• 24:54
  SPEAKER_02: então quando eu não preciso disso,
• 24:56
  SPEAKER_02: ou não tenho que fazer aquilo,
• 24:57
  SPEAKER_02: ou consigo atingir X,
• 24:59
  SPEAKER_02: então provavelmente isso é mais simples.
• 25:00
  SPEAKER_02: E aí fica aquela coisa meio no sentimento.
• 25:02
  SPEAKER_02: Dá pra descrever o que é simplicidade.
• 25:04
  SPEAKER_02: Vou deixar pro final.
• 25:05
  SPEAKER_02: Mas no geral, eu acho que sim.
• 25:07
  SPEAKER_02: Mais experiência te torna mais apto a fazer coisas mais simples.
• 25:11
  Mas o simples,
• 25:12
  tipo,
• 25:13
  Holy Grail do simples é difícil porque isso depende do que você
• 25:16
  já viu.
• 25:16
  Eu acho que você consegue fazer o mais simples porque você tem
• 25:18
  uma mirilha de coisas.
• 25:19
  SPEAKER_02: Tipo assim, eu vi 50 jeitos diferentes.
• 25:21
  SPEAKER_02: Tem o mais complexo e o mais simples.
• 25:23
  SPEAKER_02: Então a experiência deixa você fazer o mais simples?
• 25:25
  SPEAKER_02: Eu acho que sim.
• 25:26
  SPEAKER_02: Só que o seu simples pode ser diferente do meu.
• 25:27
  SPEAKER_02: Eu acho que essa aqui é a coisa que deixa confuso.
• 25:30
  SPEAKER_02: O Holy Grail é só o Uncle Bob, né?
• 25:32
  SPEAKER_02: É, falta ele conseguir.
• 25:33
  SPEAKER_02: Ele tá atrás até hoje.
• 25:35
  SPEAKER_02: É,
• 25:35
  mas eu acho que a simplicidade é uma coisa que leva tempo pra
• 25:39
  você aprender,
• 25:40
  SPEAKER_02: assim,
• 25:40
  SPEAKER_02: e eu acho que é uma questão de maturidade nos dois sentidos,
• 25:43
  SPEAKER_02: assim,
• 25:43
  SPEAKER_02: maturidade profissional e até emocional mesmo,
• 25:46
  SPEAKER_02: porque,
• 25:46
  SPEAKER_02: querendo ou não,
• 25:47
  SPEAKER_02: às vezes a simplicidade envolve até um pouco de empatia com outra pessoa,
• 25:50
  SPEAKER_02: né,
• 25:51
  SPEAKER_02: com quem que vai ler esse código,
• 25:52
  SPEAKER_02: com quem que
• 25:53
  SPEAKER_02: Ou até uma empatia com o seu eu futuro,
• 25:55
  SPEAKER_02: de tipo,
• 25:55
  SPEAKER_02: cara,
• 25:56
  no futuro eu vou ter que voltar nisso aqui e eu preciso
• 25:58
  entender isso aqui rápido.
• 25:59
  SPEAKER_02: Eu acho que são coisas que você vai pegando meio que no tato, sabe?
• 26:03
  Conforme você vai convivendo,
• 26:04
  você vai vendo o que as outras pessoas fazem com você,
• 26:07
  sabe?
• 26:07
  SPEAKER_02: Virou um papo de psicologia, né?
• 26:08
  SPEAKER_02: Psicólogo.
• 26:09
  SPEAKER_02: Tipo, como os outros te tratam através do código.
• 26:11
  SPEAKER_02: Porque código é linguagem, é comunicação, então.
• 26:14
  SPEAKER_02: Como os outros te tratam no código ali.
• 26:17
  SPEAKER_02: E como você trata os outros, sabe?
• 26:19
  SPEAKER_02: Então, você quer que as pessoas te entendam rápido, sabe?
• 26:22
  Que a coisa que você faça,
• 26:23
  que você está fazendo,
• 26:24
  seja facilmente entendível.
• 26:26
  SPEAKER_02: Acho que é um exercício até de empatia.
• 26:28
  SPEAKER_02: Preocupar com quem vai revisar SPR, com quem vai ler isso depois.
• 26:31
  SPEAKER_02: Acho que isso demanda maturidade.
• 26:35
  SPEAKER_01: E onde vocês acham que entra a complexidade e a abstração de código?
• 26:40
  SPEAKER_01: Tipo assim, vocês têm alguma técnica também sobre isso?
• 26:43
  SPEAKER_01: Tipo, quando abstrair?
• 26:45
  SPEAKER_01: Quando eu tô abstraindo demais?
• 26:46
  SPEAKER_01: Quando eu devo abstrair?
• 26:48
  SPEAKER_01: Quando não?
• 26:49
  SPEAKER_01: Cara, não sei se tem um macete.
• 26:51
  SPEAKER_01: Tipo, entra numa parte mais técnica, assim.
• 26:53
  SPEAKER_02: Sei,
• 26:53
  SPEAKER_02: não sei se tem um macete assim,
• 26:54
  mas o que geralmente funcionou pra gente era você não abstrai
• 26:58
  isso que você não
• 26:58
  SPEAKER_02: precisa.
• 26:58
  SPEAKER_02: Então,
• 26:59
  SPEAKER_02: você às vezes tá pensando muito no futuro,
• 27:02
  SPEAKER_02: assim,
• 27:02
  SPEAKER_02: tipo,
• 27:03
  SPEAKER_02: ah,
• 27:03
  SPEAKER_02: pode ser que alguém no futuro vai precisar reutilizar isso,
• 27:05
  SPEAKER_02: ou pode ser que a gente precise colocar essa feature depois no futuro.
• 27:09
  SPEAKER_02: Você tem certeza que você vai precisar disso?
• 27:11
  SPEAKER_02: Não, então não faz isso agora.
• 27:12
  SPEAKER_02: Então, resolve de um jeito simples, depois você refatora, sabe?
• 27:15
  SPEAKER_02: Acho que...
• 27:15
  SPEAKER_02: Isso é mais fácil para quem trabalha com um serviço online,
• 27:19
  SPEAKER_02: que você pode atualizar o código com alguma facilidade,
• 27:21
  SPEAKER_02: você sobe um novo container lá,
• 27:22
  SPEAKER_02: um código novo.
• 27:23
  SPEAKER_02: Então, nessa realidade, você pode modificar o seu código depois também.
• 27:29
  SPEAKER_02: Às vezes,
• 27:29
  SPEAKER_02: se resolver de um jeito mais simples agora,
• 27:31
  você tem menos coisa para explicar para os outros do que se
• 27:36
  você estivesse pensando
• 27:36
  SPEAKER_02: em uma abstração futura que vai vir daqui seis meses,
• 27:39
  SPEAKER_02: um ano,
• 27:39
  SPEAKER_02: pode ser que nem venha.
• 27:40
  Então você foca só no que você tem que fazer agora e abstrai só
• 27:43
  quando de fato
• 27:44
  SPEAKER_02: precisa,
• 27:44
  SPEAKER_02: quando você sabe que vai ter um contexto para utilizar essa abstração.
• 27:47
  Eu acho que é isso,
• 27:48
  eu acho que a abstração tem que emergir do que você precisa
• 27:51
  abstrair.
• 27:52
  SPEAKER_02: Vão ter cenários como esse que você só tem um cenário,
• 27:56
  SPEAKER_02: então você não tem por que ficar pensando em como vão ser os outros.
• 27:58
  SPEAKER_02: Aí vai ter um momento que você vê que tem um segundo jeito de fazer.
• 28:02
  SPEAKER_02: E aí eu tenho uma regra pra mim,
• 28:03
  SPEAKER_02: né,
• 28:03
  SPEAKER_02: que eu acho que ela é universal,
• 28:04
  SPEAKER_02: que é,
• 28:05
  SPEAKER_02: eu só abstraio quando eu conheço o terceiro caso,
• 28:07
  SPEAKER_02: antes eu não faço.
• 28:08
  Antes eu copio e colo,
• 28:09
  se for o caso,
• 28:09
  e troco os nomes e vamos ver o que acontece.
• 28:11
  SPEAKER_02: Porque pode ser que seja só uma grande coincidência no início,
• 28:13
  SPEAKER_02: que as coisas são parecidas,
• 28:14
  SPEAKER_02: mas elas não são tipo versões da mesma coisa,
• 28:17
  SPEAKER_02: elas só são parecidas.
• 28:18
  SPEAKER_02: E aí quando eu chego no terceiro caso,
• 28:20
  SPEAKER_02: aí eu penso,
• 28:21
  SPEAKER_02: peraí,
• 28:21
  SPEAKER_02: isso agora realmente é tudo a mesma coisa ou não?
• 28:24
  SPEAKER_02: Isso é uma forma de ver.
• 28:25
  Mas aí tem um caso que o Daliano trouxe,
• 28:27
  que é,
• 28:28
  vão ter momentos que você não pode fazer isso.
• 28:30
  SPEAKER_02: Por exemplo,
• 28:30
  se você estiver falando como vai ser um sistema embarcado que
• 28:34
  não tem como fazer
• 28:34
  SPEAKER_02: atualização,
• 28:35
  SPEAKER_02: depois que está lá no chip já era,
• 28:37
  SPEAKER_02: meio que você tem que saber de antemão,
• 28:40
  SPEAKER_02: o que dá,
• 28:40
  SPEAKER_02: o que não dá,
• 28:41
  qual é o tipo de abstração que você vai criar para conseguir se
• 28:44
  comunicar ainda da
• 28:44
  SPEAKER_02: mesma forma.
• 28:45
  SPEAKER_02: Só que aí eu acho que quando chega nesse cenário,
• 28:47
  SPEAKER_02: ou cenários parecidos com esse,
• 28:49
  o tempo de planejamento e o estudo em cima das possibilidades é
• 28:53
  bem grande e é
• 28:54
  SPEAKER_02: sério.
• 28:54
  SPEAKER_02: Não é tipo, vai, vai, vai, pega o card do gira, não é isso, né?
• 28:57
  SPEAKER_02: Porque quando a gente tem um cenário de mais velocidade,
• 29:00
  SPEAKER_02: a abstração precisa emergir com o tempo,
• 29:02
  SPEAKER_02: porque senão você já não tem tempo.
• 29:04
  SPEAKER_02: E aí você vai se enganar que você vai fazer uma boa abstração,
• 29:07
  SPEAKER_02: que é a clássica abstração de eu vou trocar o banco de dados,
• 29:10
  SPEAKER_02: aí quando você troca você tem que trocar as interfaces.
• 29:12
  SPEAKER_02: É esse o caso,
• 29:12
  porque foi tão pouco planejado ou com tão pouca experiência
• 29:16
  sobre o segundo e
• 29:17
  SPEAKER_02: terceiro caso,
• 29:18
  SPEAKER_02: que a abstração só existe para você ficar confortável.
• 29:21
  SPEAKER_02: Então você,
• 29:22
  SPEAKER_02: teoricamente,
• 29:22
  SPEAKER_02: está comprando tempo,
• 29:24
  SPEAKER_02: tentando comprar algum tempo com isso,
• 29:25
  SPEAKER_02: meio que ou sabendo que nunca vai ter a segunda versão,
• 29:28
  SPEAKER_02: ou quando chegar na segunda versão,
• 29:30
  SPEAKER_02: meio que tanto faz porque você vai ter que reescrever tudo.
• 29:32
  SPEAKER_02: Então, quando que eu abstraio?
• 29:33
  SPEAKER_02: Em casos concretos é quando aparece o terceiro caso.
• 29:36
  Em casos onde aquilo não deveria ser o escopo do dia a dia das
• 29:40
  pessoas programando
• 29:41
  SPEAKER_02: ou do time,
• 29:42
  SPEAKER_02: disciplinas específicas,
• 29:43
  SPEAKER_02: né?
• 29:43
  Imagina assim,
• 29:44
  eu não preciso que todo mundo do meu time saiba a criptografia.
• 29:47
  Eu não preciso que todo mundo do meu time saiba como exatamente
• 29:50
  se conecta com o
• 29:51
  SPEAKER_02: banco de dados,
• 29:52
  SPEAKER_02: fora chamar a função.
• 29:53
  SPEAKER_02: Então,
• 29:53
  SPEAKER_02: essas coisas estarem abstraídas,
• 29:54
  SPEAKER_02: eu acho que é ok,
• 29:55
  SPEAKER_02: porque,
• 29:56
  SPEAKER_02: apesar de relevantes,
• 29:58
  SPEAKER_02: elas não são o que você precisa fazer no dia a dia,
• 30:00
  SPEAKER_02: porque esse problema já foi resolvido.
• 30:02
  SPEAKER_02: O que é diferente de eu criar uma abstração para o meu domínio,
• 30:06
  SPEAKER_02: que é criar um conjunto de classes,
• 30:07
  SPEAKER_02: um modelo mental,
• 30:08
  SPEAKER_02: essa é a mais perigosa para mim,
• 30:10
  SPEAKER_02: porque...
• 30:10
  SPEAKER_02: Se eu planejei,
• 30:11
  SPEAKER_02: mesmo que ainda em conjunto ou não,
• 30:13
  SPEAKER_02: mas normalmente as pessoas acabam fazendo sozinhas,
• 30:15
  SPEAKER_02: esse tipo de abstração de domínio,
• 30:17
  SPEAKER_02: como a minha aplicação vai funcionar,
• 30:18
  SPEAKER_02: eu estou inventando uma visão de mundo.
• 30:20
  Eu estou criando um modelo mental que a partir de amanhã alguém
• 30:23
  vai ter que tentar
• 30:24
  SPEAKER_02: pensar igual a mim para conseguir continuar desenvolvendo.
• 30:27
  SPEAKER_02: E aí em cenários mais rápidos,
• 30:29
  SPEAKER_02: aí eu vou falar qualquer empresa que tem OKR,
• 30:31
  SPEAKER_02: esse tipo de coisa...
• 30:32
  Você vai ter que fazer mais rápido do que você vai poder parar
• 30:34
  e remodelar e pensar
• 30:36
  SPEAKER_02: qual é a abstração correta daqui para frente.
• 30:38
  SPEAKER_02: O que vai gerar?
• 30:39
  Você vai ter projetos grandes que vão ter níveis de abstração
• 30:42
  mais e menos
• 30:42
  SPEAKER_02: sofisticada dentro da mesma codebase.
• 30:45
  SPEAKER_02: Ou seja,
• 30:45
  SPEAKER_02: se for para ter esse tipo de bagunça,
• 30:48
  SPEAKER_02: eu prefiro que seja uma abstração muito pequena ou que não tenha.
• 30:51
  SPEAKER_02: Porque aí, pelo menos, eu sei o que está acontecendo.
• 30:53
  Porque imagina,
• 30:54
  eu te falo assim,
• 30:55
  isso aqui é um gerenciador de construção de carro.
• 30:58
  SPEAKER_02: Isso aqui é...
• 30:59
  SPEAKER_02: O negócio que cria prego, você fala, caralho, é muito longe um do outro.
• 31:02
  SPEAKER_02: Sim,
• 31:03
  mas no mundo real você vai chegar nesse cenário se a abstração
• 31:06
  tentar ser muito
• 31:08
  SPEAKER_02: sofisticada,
• 31:09
  SPEAKER_02: o que não é uma coisa necessariamente ruim,
• 31:10
  SPEAKER_02: em projetos que são rápidos,
• 31:12
  que eles precisam estar mudando e precisam estar tendo
• 31:15
  correspondência com esses
• 31:16
  SPEAKER_02: desafios de mercado e as palavrinhas em inglês,
• 31:18
  SPEAKER_02: market fit,
• 31:19
  SPEAKER_02: essas coisas.
• 31:19
  SPEAKER_02: Então, não sei se vale a pena.
• 31:21
  SPEAKER_02: Tem linguagens que ajudam e deixam mais difícil fazer esse tipo de coisa.
• 31:24
  SPEAKER_01: Alex,
• 31:25
  SPEAKER_01: lá no começo da conversa,
• 31:27
  SPEAKER_01: tu falou sobre a complexidade inerente,
• 31:31
  SPEAKER_01: complexidade,
• 31:32
  SPEAKER_01: como que é?
• 31:33
  SPEAKER_01: Acidental.
• 31:34
  É,
• 31:34
  mas tipo assim,
• 31:34
  eu fiquei pensando,
• 31:36
  tu falou sobre banco de dados,
• 31:37
  por exemplo.
• 31:38
  Daí imagina que uma pessoa lá pegou uma tarefa de criar um
• 31:41
  produto novo...
• 31:43
  SPEAKER_01: E ela precisa fazer essa configuração inicial ali do banco de dados.
• 31:48
  SPEAKER_01: Como que ela decide se,
• 31:49
  SPEAKER_01: tipo,
• 31:50
  SPEAKER_01: pô,
• 31:50
  eu já vou criar essa configuração de um jeito que é plug and
• 31:53
  play para um dia,
• 31:54
  SPEAKER_01: se alguém quiser trocar o banco de dados,
• 31:57
  SPEAKER_01: fique mais fácil?
• 31:58
  SPEAKER_01: Ou não,
• 31:59
  eu vou fazer aqui do jeito para resolver com o nosso banco de
• 32:02
  dados atual e foda-se
• 32:03
  SPEAKER_01: o futuro?
• 32:04
  SPEAKER_01: Porque é complexo de mudar isso, né?
• 32:06
  SPEAKER_01: Ou sei lá, não sei se tu tem outro exemplo, né?
• 32:08
  Mas tipo,
• 32:09
  pô,
• 32:09
  sei lá,
• 32:09
  uma feature muito foda que talvez pode ser que aconteça.
• 32:14
  SPEAKER_01: Tipo, sei lá, um dev pleno que pegou essa tarefa pra fazer.
• 32:17
  SPEAKER_01: Como que ele pode decidir se ele deixa complexo ou não?
• 32:22
  Se ele tiver uma escolha,
• 32:23
  deixar complexo ou não,
• 32:24
  a resposta é sempre não,
• 32:25
  né?
• 32:26
  Porque se ele sabe que ele vai deixar complexo,
• 32:27
  acho que ele não deveria.
• 32:28
  SPEAKER_01: Não,
• 32:29
  SPEAKER_01: mas eu tô falando dessa ideia ali do inerente ou não,
• 32:31
  SPEAKER_01: tipo,
• 32:32
  SPEAKER_01: será que eu preciso deixar complexo pra facilitar?
• 32:35
  SPEAKER_01: Tipo,
• 32:35
  SPEAKER_01: eu acho que,
• 32:36
  SPEAKER_01: eu sei que vai de desencontro do que o Galeno falou,
• 32:39
  SPEAKER_01: de tipo,
• 32:39
  SPEAKER_01: ah,
• 32:40
  SPEAKER_01: o futuro foda-se,
• 32:41
  SPEAKER_01: mas,
• 32:42
  SPEAKER_01: pô,
• 32:43
  SPEAKER_01: imagina que é uma tarefa que realmente possa impactar,
• 32:45
  SPEAKER_01: igual essa do banco de dados,
• 32:47
  SPEAKER_01: né,
• 32:47
  SPEAKER_01: sei lá.
• 32:47
  SPEAKER_02: Ah, não, não, não.
• 32:48
  SPEAKER_02: Eu entendi, eu entendi.
• 32:49
  Mas é que o meu ponto é justamente se a escolha é eu posso
• 32:51
  deixar complexo ou não,
• 32:52
  SPEAKER_02: a resposta é sempre não.
• 32:53
  SPEAKER_02: Mas aí se o ponto é é complexo, então não tem como responder não.
• 32:56
  SPEAKER_02: Porque é complexo.
• 32:57
  SPEAKER_02: Então vai ter algum nível de complexidade ali.
• 33:00
  Aí a discussão que pode ter é é tão complexo quanto precisa ou
• 33:03
  vai ficar mais complexo ainda?
• 33:04
  SPEAKER_02: Que aí que é a parte do acidental.
• 33:06
  SPEAKER_02: Porque se já é complexo, não tem como ficar simples.
• 33:08
  SPEAKER_02: Não tem como, acabou.
• 33:10
  SPEAKER_02: O meu ponto agora é,
• 33:11
  eu faço o mínimo aceitável por progredir ou eu tento pensar um
• 33:15
  pouco como é que eu
• 33:16
  SPEAKER_02: deixo isso mais fácil ou talvez,
• 33:18
  SPEAKER_02: entre aspas,
• 33:18
  SPEAKER_02: mais complexo,
• 33:19
  mas mais simples de digerir por alguns detalhes para outras
• 33:22
  pessoas que vão vir
• 33:23
  SPEAKER_02: depois,
• 33:24
  SPEAKER_02: ou nas próximas tarefas,
• 33:25
  SPEAKER_02: ou os próximos times que vão lidar com isso.
• 33:27
  Aí a discussão é justamente aonde você está e qual é a cultura
• 33:31
  desse lugar.
• 33:31
  Porque a gente fala de código como se fosse uma coisa muito
• 33:34
  high-tech,
• 33:35
  meu Deus,
• 33:35
  eu sou nerd.
• 33:36
  SPEAKER_02: Mas, na verdade, o código só serve para falar com outra pessoa.
• 33:38
  Porque a máquina não precisa do código que você escreve,
• 33:40
  ela precisa do bináriozão no final.
• 33:43
  SPEAKER_02: Tanto faz o que você escreveu com aquela linguagenzinha bonita.
• 33:46
  SPEAKER_02: Dado isso, como é que eu diria?
• 33:48
  SPEAKER_02: Se você tem,
• 33:49
  SPEAKER_02: no geral,
• 33:50
  SPEAKER_02: a gente está falando de médias,
• 33:51
  SPEAKER_02: porque tudo vai ter exceção para qualquer coisa.
• 33:53
  Se você tem pessoas que conseguiriam evoluir daquele ponto que
• 33:57
  você parou em
• 33:57
  SPEAKER_02: diante,
• 33:58
  SPEAKER_02: com pouca orientação,
• 33:59
  SPEAKER_02: porque esse é o tipo de pessoas que estão à sua volta,
• 34:02
  SPEAKER_02: na verdade eu faria o mínimo aceitável,
• 34:04
  SPEAKER_02: e eu não tô falando fazer errado,
• 34:05
  SPEAKER_02: nem fazer com bug,
• 34:06
  SPEAKER_02: nem fazer com risco de segurança.
• 34:07
  SPEAKER_02: O mínimo aceitável é progredir.
• 34:08
  Aí você deixa anotado quais foram as motivações,
• 34:10
  até onde você foi,
• 34:11
  e alguém vai entender.
• 34:12
  SPEAKER_02: Se tu não escrever nada, vai parecer só que você fez sacanagem.
• 34:14
  SPEAKER_02: Mas o ideal é você deixar declarado.
• 34:16
  SPEAKER_02: Por que eu fiz dessa forma e o que eu queria chegar?
• 34:18
  Se você tem um time que provavelmente você é uma das pessoas
• 34:21
  mais experientes,
• 34:22
  você sabe que as outras pessoas ainda não chegaram nesse lugar
• 34:24
  de saber fazer as
• 34:25
  SPEAKER_02: escolhas.
• 34:27
  Se ela vê algo sem estrutura,
• 34:28
  ela não vai conseguir,
• 34:29
  quando precisar,
• 34:30
  criar uma estrutura.
• 34:31
  SPEAKER_02: Porque assim, todo mundo já começou sem saber nada.
• 34:34
  SPEAKER_02: Então eu tive um dia na minha vida que eu olhei para o projeto.
• 34:37
  SPEAKER_02: Se o projeto fosse três arquivos, ele jamais ia ter uma pasta.
• 34:40
  SPEAKER_02: Porque para que tem que ter uma pasta...
• 34:41
  SPEAKER_02: Se alguém mais inteligente que eu só botou três arquivos.
• 34:44
  SPEAKER_02: Você não tem nem condições de dizer qual é o correto.
• 34:46
  SPEAKER_02: Vou fazer uma vírgula dentro disso aí.
• 34:47
  SPEAKER_02: E é por isso que os dogmas existem.
• 34:50
  Por que alguém lê,
• 34:51
  sei lá,
• 34:52
  o próprio Clean Code ou leu alguma coisa sobre arquitetura no
• 34:55
  geral?
• 34:56
  SPEAKER_02: Tipo, ah, li o livro do Hexagonal, li o livro do Clean Architecture.
• 34:59
  SPEAKER_02: Aí ela fala, agora eu sei fazer e só tem esse jeito no mundo para fazer.
• 35:02
  SPEAKER_02: porque antes ela não tinha nenhum.
• 35:04
  SPEAKER_02: Normalmente é esse o caso.
• 35:05
  SPEAKER_02: Então se ela não tem nenhum,
• 35:06
  SPEAKER_02: é melhor usar aquilo que ela sabe e ela tem algum respaldo de dizer.
• 35:09
  SPEAKER_02: Alguém ou uma legião de alguém diz que se eu fizer isso aqui tá tudo bem.
• 35:13
  SPEAKER_02: Aí ela sai do eu não sei nada pra eu sei alguma coisa.
• 35:16
  SPEAKER_02: Aí ela pode acabar entrando em cenários onde ela vai ver a segunda,
• 35:19
  SPEAKER_02: a terceira e começar a ver que tem diferenças.
• 35:21
  SPEAKER_02: Ou só virar o dogma mesmo, né?
• 35:23
  SPEAKER_02: Se agarra em um e nunca mais pode trocar.
• 35:24
  Mas quanto mais ela vê essas coisas,
• 35:26
  ela vai ficando experiente a ponto de ter a decisão.
• 35:28
  SPEAKER_02: Só que se a gente tem essas pessoas,
• 35:29
  SPEAKER_02: aí a gente está no caso A,
• 35:31
  SPEAKER_02: que é a pessoa que pode olhar para aquilo e falar,
• 35:32
  SPEAKER_02: não,
• 35:33
  SPEAKER_02: chegou o momento onde a gente tem que ter essa mudança.
• 35:35
  SPEAKER_02: O segundo caso é, a pessoa não sabe o que fazer com aquilo depois.
• 35:38
  SPEAKER_02: E aí você vai ter uma decisão.
• 35:40
  SPEAKER_02: Você vai deixar pronto o suficiente para ela usar e igualtar.
• 35:44
  SPEAKER_02: E só quando você voltar com essa reestrutura vai acontecer...
• 35:46
  Ou o que acontece nos cenários mega enterprise e vai de terno e
• 35:50
  gravata para o
• 35:51
  SPEAKER_02: trabalho que é,
• 35:52
  eu vou deixar todas as caixinhas prontas porque quando precisar
• 35:55
  a caixinha já está
• 35:56
  SPEAKER_02: lá,
• 35:56
  SPEAKER_02: é só botar o arquivo.
• 35:57
  SPEAKER_02: Ou a camada já está lá e é só fazer.
• 35:59
  SPEAKER_02: E é por isso que muita gente às vezes reclama de o seguinte,
• 36:02
  SPEAKER_02: eu estou num projeto e eu só quero salvar a informação.
• 36:05
  SPEAKER_02: E aí eu tenho várias indireções e várias camadas.
• 36:08
  SPEAKER_02: Tem mais de um motivo disso acontecer.
• 36:09
  SPEAKER_02: O mais comum é, às vezes tu é ruim e não sabe.
• 36:12
  SPEAKER_02: Porque se chegou nesse ponto,
• 36:14
  é porque talvez você não fosse a pessoa que conseguiria chegar
• 36:17
  nessas camadas e
• 36:18
  SPEAKER_02: precisasse.
• 36:19
  SPEAKER_02: Não sei se é o caso.
• 36:20
  SPEAKER_02: Mas tem o caso dois.
• 36:21
  SPEAKER_02: Trauma de quem tá criando.
• 36:23
  Porque a pessoa tá tão acostumada a lidar com pessoas que não
• 36:26
  conseguem chegar num
• 36:28
  SPEAKER_02: design ou numa estrutura que ela é intencional,
• 36:30
  SPEAKER_02: que ela deixa as caixas prontas desde o dia um,
• 36:32
  SPEAKER_02: porque ela fala,
• 36:33
  SPEAKER_02: eu não sei quem vai mexer nessa porra,
• 36:34
  SPEAKER_02: mas quando mexer,
• 36:35
  SPEAKER_02: já tá tudo formatado,
• 36:36
  SPEAKER_02: é só usar.
• 36:37
  SPEAKER_02: Então, assim, isso está errado?
• 36:39
  SPEAKER_02: Não sei se está errado.
• 36:40
  SPEAKER_02: Errado e errado é muito difícil dizer, né?
• 36:42
  Como pauta moral,
• 36:43
  acho que não dá para contar,
• 36:44
  mas tem motivo para essas coisas acontecerem.
• 36:46
  SPEAKER_02: Não tem tipo assim,
• 36:47
  hoje eu acordei e vou fazer uma arquitetura que todo mundo vai
• 36:50
  ter muito trabalho
• 36:51
  SPEAKER_02: porque tem várias pastas.
• 36:52
  SPEAKER_02: Ninguém faz isso, pô.
• 36:53
  SPEAKER_02: Tirando, sei lá, os psicopatas.
• 36:55
  SPEAKER_02: Mas,
• 36:55
  SPEAKER_02: no geral,
• 36:56
  as pessoas fazem essas múltiplas camadas desde o dia 1 porque
• 37:00
  existe um cenário
• 37:01
  SPEAKER_02: dentro da empresa onde...
• 37:03
  SPEAKER_02: É meio que sabido e às vezes é velado,
• 37:05
  SPEAKER_02: porque assim,
• 37:05
  SPEAKER_02: no foguetinho do Slack não existe falar que as pessoas não sabem,
• 37:08
  SPEAKER_02: né?
• 37:08
  SPEAKER_02: Mas a gente sabe que tem pessoas que não sabem.
• 37:10
  SPEAKER_02: Coisas.
• 37:11
  SPEAKER_02: E eu sou uma delas.
• 37:12
  SPEAKER_02: Tem várias coisas que eu não sei.
• 37:13
  SPEAKER_02: Mas se eu fosse menos experiente, saberia menos ainda.
• 37:15
  SPEAKER_02: Dado isso,
• 37:16
  se eu dou o projeto e eu sei que vão ter tipo um monte de pleno
• 37:19
  pra baixo e eles
• 37:20
  SPEAKER_02: não têm condições de fazer essa arquitetura evoluir,
• 37:23
  SPEAKER_02: porque é fofo,
• 37:24
  SPEAKER_02: né?
• 37:24
  SPEAKER_02: Tu falar arquitetura evolutiva.
• 37:25
  SPEAKER_02: Se ninguém sabe evoluir, não é evolutiva.
• 37:27
  SPEAKER_02: Vai ficar parado na pedra.
• 37:28
  SPEAKER_02: Se ninguém sabe fazer isso funcionar, o que vai acontecer?
• 37:31
  SPEAKER_02: Vai ficar uma posta, vai aparecer um shell script o negócio inteiro.
• 37:34
  SPEAKER_02: Logo,
• 37:34
  é por isso que as caixinhas estão prontas desde o início e é
• 37:36
  por isso que as
• 37:37
  pessoas amam ler os livros do Uncle Bob ou qualquer coisa
• 37:41
  parecida e fazer
• 37:41
  SPEAKER_02: idêntico.
• 37:42
  Porque pelo menos elas sabem que em alguma visão de mundo
• 37:45
  aquilo está correto.
• 37:46
  SPEAKER_02: E aí a discussão é, vou fazer complexo ou vou fazer não complexo?
• 37:49
  Eu acho que às vezes você faz complexo porque as pessoas que
• 37:52
  vão vir depois não vão
• 37:53
  SPEAKER_02: conseguir fazer complexo se for preciso.
• 37:55
  SPEAKER_02: Então no dia que necessitar da complexidade, não vai ter como chegar lá.
• 37:59
  SPEAKER_02: Vai ficar só bagunçado, que é pior do que complexo.
• 38:05
  SPEAKER_01: Isso não tem a ver com a parada que o Galeno falou também de empatia?
• 38:08
  SPEAKER_01: Querendo ou não,
• 38:10
  SPEAKER_01: ao mesmo tempo que tu tá xingando todo mundo,
• 38:12
  SPEAKER_01: falando que as pessoas não têm capacidade,
• 38:14
  SPEAKER_01: são burros,
• 38:14
  SPEAKER_01: não sei o que lá,
• 38:15
  SPEAKER_01: tu tá sendo empático com essas pessoas?
• 38:17
  Não,
• 38:17
  pô,
• 38:17
  eu não xingo,
• 38:18
  não sou aqui,
• 38:18
  só que às vezes as pessoas não sabem.
• 38:20
  SPEAKER_02: Eu não falo, você tem que ser muito idiota.
• 38:22
  SPEAKER_02: Não, eu não faço isso não.
• 38:24
  SPEAKER_01: Não, mas entendeu, né?
• 38:26
  SPEAKER_01: Tipo assim,
• 38:27
  SPEAKER_01: eu estou sendo empático como um dev senior,
• 38:29
  SPEAKER_01: um staff,
• 38:30
  SPEAKER_01: sei lá,
• 38:31
  SPEAKER_01: de fazer uma parada complexa no meu código,
• 38:34
  SPEAKER_01: porque quando as pessoas usarem isso,
• 38:36
  pra elas vai ser mais fácil do que elas terem que entender o
• 38:40
  que eu tô fazendo,
• 38:41
  SPEAKER_01: sabe?
• 38:42
  SPEAKER_01: Então, mas aí que tá.
• 38:43
  SPEAKER_02: Alguém pode fazer isso por mais de um motivo.
• 38:44
  SPEAKER_02: Um motivo pode ser,
• 38:46
  SPEAKER_02: estou preocupado com que as pessoas mantenham esse projeto com qualidade,
• 38:50
  SPEAKER_02: logo vou deixar as estruturas pra elas.
• 38:51
  SPEAKER_02: Sou bondoso.
• 38:52
  SPEAKER_02: Tem o segundo caso, que é, eu só sei fazer desse jeito.
• 38:55
  SPEAKER_02: Quando eu aprendi sobre essas coisas,
• 38:58
  SPEAKER_02: eu aprendi,
• 38:58
  SPEAKER_02: sei lá,
• 38:58
  SPEAKER_02: no blog da AWS,
• 38:59
  SPEAKER_02: que fala que pra ter uma coisa simples tem que usar cinco produtos.
• 39:02
  E aí eu fiz certificação,
• 39:04
  e aí eu tenho que provar que tudo que eu aprendi faz sentido.
• 39:06
  SPEAKER_02: Então eu tenho que usar tudo.
• 39:07
  É tipo,
• 39:08
  olhando pro final da foto,
• 39:10
  eu acho que você não tem como dizer qual foi a intenção.
• 39:12
  Mas existem motivos não tão bons e motivos bem empáticos para
• 39:16
  essa coisa acontecer.
• 39:17
  SPEAKER_02: Mas você que está recebendo isso,
• 39:19
  SPEAKER_02: você pode olhar e falar assim,
• 39:20
  SPEAKER_02: porra,
• 39:21
  SPEAKER_02: que merda,
• 39:21
  SPEAKER_02: que projeto enorme,
• 39:22
  SPEAKER_02: eu só queria salvar o banco.
• 39:23
  SPEAKER_02: Às vezes o cara teve uma boa intenção,
• 39:26
  SPEAKER_02: porque na cabeça dele era óbvio,
• 39:27
  SPEAKER_02: mas no fim ele acabou tornando um negócio complexo,
• 39:29
  SPEAKER_02: ele não levou em conta o que os outros sabiam.
• 39:31
  Esse exemplo da AWS é muito bom,
• 39:33
  o cara querer meter um SNS com SQS conectado num Dynamo com
• 39:37
  SPEAKER_02: um milhão de tecnologias e o cara só sabe PHP e mais que ele.
• 39:40
  SPEAKER_02: Às vezes você tem que pensar no outro assim, deixar sempre para o outro.
• 39:43
  SPEAKER_02: Ou se tiver que ser essa arquitetura mesmo,
• 39:45
  SPEAKER_02: aí você documenta,
• 39:47
  SPEAKER_02: sei lá,
• 39:47
  SPEAKER_02: dá um jeito depois para esse cara conseguir entender o que você fez.
• 39:50
  SPEAKER_02: Inclusive o DHH,
• 39:52
  SPEAKER_02: que agora ele está começando a entrar para uma onda meio errada,
• 39:54
  SPEAKER_02: mas vamos falar só do que ele faz,
• 39:56
  SPEAKER_02: não do que ele é.
• 39:57
  SPEAKER_02: Ele tem um blog post que se chama Mercadores de Complexidade.
• 40:01
  SPEAKER_02: Ele explora um pouco,
• 40:02
  SPEAKER_02: tipo assim,
• 40:03
  SPEAKER_02: às vezes vai ser lido ou vai ser vendido para você uma ideia de que essa
• 40:08
  SPEAKER_02: complexidade é a solução.
• 40:10
  SPEAKER_02: É o jeito correto de fazer,
• 40:11
  porque olha aqui quantas coisas estão chegando e fazendo a sua
• 40:15
  solução ficar
• 40:15
  SPEAKER_02: perfeitamente.
• 40:16
  SPEAKER_02: É só tu ver, qualquer blueprint da AWS usa cinco, seis coisas.
• 40:20
  SPEAKER_02: Na verdade, você provavelmente não precisa de nada.
• 40:21
  SPEAKER_02: E quando eu digo nada, é. Dá para ser uma coisa só que resolve.
• 40:24
  SPEAKER_02: Cara, é assustador.
• 40:25
  Quando eu vejo aquele,
• 40:26
  ah,
• 40:26
  veja a arquitetura que a Netflix usa,
• 40:29
  tá ligado?
• 40:29
  SPEAKER_02: Aí você vê que,
• 40:30
  SPEAKER_02: tipo,
• 40:31
  SPEAKER_02: 15 coisas diferentes,
• 40:32
  SPEAKER_02: assim,
• 40:32
  SPEAKER_02: coisas que não tem nem como pesquisar no Google.
• 40:35
  SPEAKER_01: Tem que ser amigo de um cara da Amazon pra ter acesso.
• 40:39
  SPEAKER_02: Exatamente.
• 40:40
  SPEAKER_02: Quando a gente pensa nessa parte de mercadores de complexidade,
• 40:43
  ele está falando muito sobre a ideia de que se vendeu com a
• 40:45
  cloud é simples,
• 40:46
  mas na verdade é muito mais simples você ter um servidor e
• 40:48
  manter ele se você for
• 40:49
  SPEAKER_02: pensar na complexidade que você vai chegar no final,
• 40:51
  SPEAKER_02: tanto que eles saíram da cloud,
• 40:52
  SPEAKER_02: é um caso deles.
• 40:53
  SPEAKER_02: Mas se a gente levar isso para o código que a gente está falando,
• 40:55
  SPEAKER_02: a gente tem vários mercadores de complexidade.
• 40:58
  SPEAKER_02: Porque tem um monte de gente falando que o jeito de fazer o código é X.
• 41:02
  SPEAKER_02: Porque se você falar assim,
• 41:03
  SPEAKER_02: cara,
• 41:03
  SPEAKER_02: é só usar essa linha,
• 41:04
  SPEAKER_02: é só gravar no banco e beleza,
• 41:05
  SPEAKER_02: tá funcionando.
• 41:06
  SPEAKER_02: Não brilha, não é massa pra caralho.
• 41:08
  SPEAKER_02: Não tem todo o equilibrismo de falar que aquilo ali funciona.
• 41:13
  SPEAKER_02: E a gente teve um caso na CodeCon Select, né?
• 41:15
  Lá no Pioneer que eu tava,
• 41:16
  alguém falou assim,
• 41:17
  porra,
• 41:17
  a gente usou event sourcing no projeto.
• 41:20
  SPEAKER_02: E era um projeto muito simples.
• 41:21
  SPEAKER_02: A gente não consegue mais manter o projeto.
• 41:23
  SPEAKER_02: Tipo, uma mudança simples demora alguns dias pra ser feita.
• 41:27
  SPEAKER_02: Entenda,
• 41:27
  SPEAKER_02: se você procurar sobre event sourcing,
• 41:29
  SPEAKER_02: tirando os haters,
• 41:30
  SPEAKER_02: tipo oficialmente haters,
• 41:31
  SPEAKER_02: mas se tu for pegar a média de como as pessoas estão falando sobre,
• 41:34
  SPEAKER_02: parece que é a solução para todos os problemas.
• 41:36
  SPEAKER_02: E quando eu quero dizer todos os problemas,
• 41:37
  qualquer pessoa que está um pouquinho mais alinhada com o
• 41:40
  design vai falar,
• 41:41
  SPEAKER_02: eu sei que não é.
• 41:42
  SPEAKER_02: Mas não é para você a conversa, é para quem pode cair nesse conto.
• 41:44
  SPEAKER_02: Se você for olhar os blog posts e as pessoas se promovendo,
• 41:47
  SPEAKER_02: parece que se você fizer desse jeito,
• 41:48
  SPEAKER_02: nunca mais você vai ter problema porque resolve tudo.
• 41:50
  SPEAKER_02: Vai ter features que você nunca teve antes.
• 41:52
  SPEAKER_02: Você pode fazer query voltando no tempo.
• 41:54
  SPEAKER_02: Você pode fazer várias coisas.
• 41:56
  SPEAKER_02: Boa, eu não preciso de nada disso.
• 41:57
  SPEAKER_02: E agora?
• 41:57
  SPEAKER_02: Ah, mas se você precisar, já está lá.
• 41:59
  SPEAKER_02: E aí, talvez, venha o lance da boa intenção.
• 42:01
  Ah,
• 42:02
  você é empático para fazer com o event sourcing porque vai
• 42:04
  chegar nesse dia.
• 42:05
  SPEAKER_02: Boa.
• 42:05
  SPEAKER_02: Aí acontece o quê?
• 42:07
  SPEAKER_02: não precisava e o cara vai numa conferência pra falar fudeu,
• 42:10
  eu tô usando aquele negócio que resolver todos os problemas e
• 42:13
  agora só é difícil de
• 42:14
  SPEAKER_02: manter então assim,
• 42:15
  SPEAKER_02: tem gente pra cacete vendendo o curso falando,
• 42:19
  SPEAKER_02: é com event sourcing que faz porque se eu te falar
• 42:21
  SPEAKER_02: É só fazer.
• 42:22
  SPEAKER_02: Demora duas horas e tu já aprendeu?
• 42:24
  SPEAKER_02: Eu não vou poder te cobrar muito caro, né?
• 42:26
  SPEAKER_02: Eu preciso de alguma coisa que demora 20 horas pra eu te ensinar.
• 42:28
  SPEAKER_02: Que aí tu pensa, cara, eu estudei pra caralho, passei a semana fazendo.
• 42:32
  SPEAKER_02: Nossa, tem vários detalhes, né?
• 42:33
  SPEAKER_02: Agora, é isso.
• 42:34
  SPEAKER_02: São mercadores de complexidade.
• 42:36
  SPEAKER_02: Fazer
• 42:37
  SPEAKER_02: simples não é muito atrativo, né?
• 42:39
  SPEAKER_02: Tipo, ninguém gosta de, nossa, realmente, você só resolveu.
• 42:43
  SPEAKER_02: Não é nem vendável, né?
• 42:44
  SPEAKER_02: Do ponto de vista de marketing,
• 42:46
  SPEAKER_02: de falar que fez alguma coisa,
• 42:47
  SPEAKER_02: você não vai pra uma conferência e falar assim,
• 42:49
  SPEAKER_02: então,
• 42:50
  SPEAKER_02: eu escrevi esse arquivo aqui,
• 42:51
  SPEAKER_02: ele tem 16 linhas e é isso aí,
• 42:52
  SPEAKER_02: acabou o problema.
• 42:54
  SPEAKER_02: Não é a QCon que vai querer isso.
• 42:55
  SPEAKER_02: Vão ser conferências mais ativas sobre fazer bons designs.
• 42:59
  Na QCon é como eu usei tudo que a AWS oferece e da GCP porque
• 43:03
  era multi-cloud.
• 43:03
  SPEAKER_02: Aí todo mundo, uau, que solução massa.
• 43:06
  SPEAKER_02: Às vezes nem precisa, pô.
• 43:08
  SPEAKER_01: E eu fiquei pensando também no papel do Code Review.
• 43:11
  SPEAKER_01: Tipo,
• 43:11
  SPEAKER_01: principalmente assim,
• 43:12
  SPEAKER_01: pô,
• 43:13
  SPEAKER_01: eu quero começar a evitar códigos complexos na minha empresa,
• 43:17
  SPEAKER_01: eu estou cuidando do meu,
• 43:19
  SPEAKER_01: mas tem pessoas aqui que não estão.
• 43:22
  SPEAKER_01: Então, como que as pessoas podem usar mais o Code Review, assim, para...
• 43:26
  SPEAKER_01: E melhorando esse codebase bugado aí que eles estão...
• 43:30
  SPEAKER_02: Eu tenho uma ideia,
• 43:31
  SPEAKER_02: mas eu não sei se ela é a melhor ideia.
• 43:33
  SPEAKER_02: Code review sem guideline nenhum, tipo o que a empresa espera.
• 43:36
  E quando eu digo empresa,
• 43:37
  pode ser um time,
• 43:38
  um grupo de times,
• 43:39
  algo maior ou a empresa inteira.
• 43:41
  Se tu não tem guideline nenhum,
• 43:42
  todo code review é um coder versus 30 reviewers.
• 43:46
  SPEAKER_02: Porque vira um debate de quem está certo baseado em subjetividade.
• 43:50
  SPEAKER_02: Baseado em, eu trabalhei na empresa X e lá era certo fazer isso.
• 43:53
  SPEAKER_02: Eu li o livro Y e é assim que deveria ser feito.
• 43:56
  SPEAKER_02: A discussão,
• 43:57
  SPEAKER_02: ela não é formatada em vamos para frente sim ou não,
• 44:00
  SPEAKER_02: ou qual é o critério para isso aqui passar,
• 44:01
  SPEAKER_02: mesmo que tenha problemas talvez de estética,
• 44:04
  SPEAKER_02: não de corretude.
• 44:05
  SPEAKER_02: Então assim,
• 44:06
  SPEAKER_02: code review sem nenhum guideline,
• 44:08
  SPEAKER_02: tipo assim,
• 44:08
  SPEAKER_02: esse é o mínimo que a gente olha,
• 44:09
  SPEAKER_02: esse é o mínimo que a gente espera de formato e etc.
• 44:12
  SPEAKER_02: É discussão, é tipo rim, é quem tem mais persuasão.
• 44:15
  SPEAKER_01: É basicamente isso.
• 44:17
  SPEAKER_01: Poxa,
• 44:17
  SPEAKER_01: eu trabalhei numa empresa que era essa parada assim,
• 44:21
  SPEAKER_01: de tipo,
• 44:21
  SPEAKER_01: tu mesmo merge aí ao teu PR,
• 44:23
  SPEAKER_01: que eu achava mó estranho.
• 44:24
  Mas eu lembro que era tipo assim,
• 44:26
  tu só precisava de um code review aprovado e tu mergeava.
• 44:30
  SPEAKER_01: Daí tipo,
• 44:31
  SPEAKER_01: tinha vários PRs abertos lá,
• 44:33
  SPEAKER_01: que ia lá uns dev sênior de dois anos,
• 44:36
  SPEAKER_01: comentava só um LGTM,
• 44:38
  SPEAKER_01: looks good to me,
• 44:40
  SPEAKER_01: aprovava,
• 44:41
  SPEAKER_01: e o código assim,
• 44:43
  SPEAKER_01: a Deus dará,
• 44:43
  SPEAKER_01: né?
• 44:44
  SPEAKER_01: É loucura, né?
• 44:45
  SPEAKER_01: Tem muita empresa que deve ser assim, né, cara?
• 44:47
  SPEAKER_02: Deve ser, meio anarquista.
• 44:49
  SPEAKER_02: Não sei se precisa de guidelines também, assim, seria bom, né?
• 44:51
  Acho que no Asus lá tinha muito guideline,
• 44:55
  assim,
• 44:55
  de tipo,
• 44:55
  ah,
• 44:56
  manter simples,
• 44:57
  sabe?
• 44:57
  SPEAKER_02: Da teoria do bom escoteiro,
• 44:59
  SPEAKER_02: de sempre tentar deixar o lugar mais organizado do que quando você pegou.
• 45:02
  SPEAKER_02: Isso é legal,
• 45:02
  SPEAKER_02: assim,
• 45:03
  SPEAKER_02: pra fomentar uma cultura e tudo mais,
• 45:04
  SPEAKER_02: mas às vezes eu acho que o guideline é a tua opinião,
• 45:06
  SPEAKER_02: cara.
• 45:08
  SPEAKER_02: Se tu
• 45:08
  SPEAKER_02: sente que tu não tá conseguindo entender o que você tá lendo, sabe?
• 45:12
  SPEAKER_02: Aquele vídeo do Clóvis de Barros Filhos,
• 45:14
  SPEAKER_02: como esse cara escreveu algo que eu não consigo entender,
• 45:17
  SPEAKER_02: sabe?
• 45:18
  Às vezes o problema tá de fato na escrita do cara e às vezes é
• 45:21
  só a tua opinião de
• 45:22
  SPEAKER_02: cara,
• 45:22
  SPEAKER_02: eu não tô conseguindo entender isso aqui.
• 45:23
  SPEAKER_02: É o suficiente pra
• 45:25
  SPEAKER_02: a pessoa ter que olhar aquilo dali com um pouco mais de cuidado,
• 45:28
  SPEAKER_02: assim,
• 45:28
  SPEAKER_02: ainda mais se tu tem algum nível maior de senioridade,
• 45:30
  SPEAKER_02: assim,
• 45:31
  SPEAKER_02: se tu já é pleno,
• 45:31
  SPEAKER_02: já é sênior,
• 45:32
  SPEAKER_02: você tem um pouco mais de bagagem pra ver que aquilo dali,
• 45:36
  SPEAKER_02: na verdade,
• 45:36
  SPEAKER_02: tá uma maçaroca,
• 45:37
  SPEAKER_02: né,
• 45:37
  SPEAKER_02: tem um código espaguete,
• 45:38
  SPEAKER_02: assim,
• 45:39
  SPEAKER_02: que tá tudo enrolado,
• 45:40
  SPEAKER_02: você não sabe onde começa,
• 45:41
  SPEAKER_02: onde termina cada filme.
• 45:43
  SPEAKER_02: E aí você usa sua própria experiência como base pra isso,
• 45:46
  SPEAKER_02: tipo,
• 45:46
  SPEAKER_02: ah,
• 45:47
  SPEAKER_02: tentar chegar na solução mais simples junto com a pessoa que escreveu PR.
• 45:50
  SPEAKER_02: É, eu acho que o caminho da colaboração é importante.
• 45:56
  SPEAKER_01: Pra não virar essa parada que o Alex comentou, eu acho que é isso aí.
• 46:00
  SPEAKER_01: É tipo, tu ter essa empatia também no Code Review, né?
• 46:03
  SPEAKER_01: De questionar, né?
• 46:04
  SPEAKER_01: Ao invés de falar, não, faça desse jeito.
• 46:06
  SPEAKER_01: Vai lá e fala, pô, por que que tu resolveu fazer desse jeito, né?
• 46:09
  SPEAKER_01: Eu não entendi direito o que que esse código tá fazendo.
• 46:12
  Às vezes a pessoa fez daquele jeito porque foi o único meio que
• 46:15
  ela encontrou para
• 46:16
  SPEAKER_02: fazer com o Danilo.
• 46:17
  SPEAKER_02: E às vezes você chegar com outra ideia ou se dispor a ajudar ela,
• 46:20
  SPEAKER_02: você consegue dar uma ideia para ela e ajudar ela no próprio processo de
• 46:24
  SPEAKER_02: aprendizado.
• 46:25
  Eu acho que a forma como eu mais aprendi a escrever um código
• 46:28
  mais organizado foi
• 46:28
  SPEAKER_02: justamente com base no que os outros me diziam que estava ruim.
• 46:31
  Eu tinha um professor de design que falou que o melhor cliente
• 46:35
  que ele teve,
• 46:35
  SPEAKER_02: entre aspas,
• 46:36
  foi o cliente que mais se aclamava porque era um cliente que
• 46:38
  reclamava com
• 46:39
  SPEAKER_02: argumento.
• 46:39
  SPEAKER_02: E meio que isso foi ensinando ele a criar,
• 46:42
  SPEAKER_02: artes um pouco melhores,
• 46:44
  SPEAKER_02: assim,
• 46:44
  SPEAKER_02: tipo,
• 46:44
  SPEAKER_02: ele prestava sensações sobre a mente,
• 46:46
  SPEAKER_02: detalhes que antes ele não prestava.
• 46:48
  Então foi nesse ciclo de feedback que ele foi se tornando um
• 46:51
  profissional melhor.
• 46:52
  SPEAKER_02: É,
• 46:52
  SPEAKER_02: no geral,
• 46:52
  SPEAKER_02: eu acho que tem empresas e empresas,
• 46:54
  SPEAKER_02: né,
• 46:54
  SPEAKER_02: vão ter lugares onde,
• 46:56
  SPEAKER_02: na média,
• 46:56
  SPEAKER_02: todo mundo tem uma mesma visão de mundo,
• 46:58
  SPEAKER_02: pelo menos de tecnologia,
• 47:00
  SPEAKER_02: e vão ter coisas que são dadas,
• 47:02
  SPEAKER_02: né,
• 47:02
  SPEAKER_02: tipo,
• 47:02
  SPEAKER_02: todo mundo meio que concorda com elas.
• 47:04
  SPEAKER_02: Mas vão ter vários outros lugares que não.
• 47:06
  SPEAKER_02: E aí por que eu acho que tem que ter algum nível de guia?
• 47:09
  SPEAKER_02: E quando eu digo guia, não precisa ser 80 páginas.
• 47:11
  SPEAKER_02: Às vezes pode ser 3 parágrafos, às vezes pode ser 80 páginas.
• 47:14
  SPEAKER_02: Por quê?
• 47:14
  SPEAKER_02: Porque se a gente pensar assim, tem alguém mais experiente revisando.
• 47:17
  SPEAKER_02: Imagina que sou literalmente eu.
• 47:19
  SPEAKER_02: E aí foi
• 47:21
  SPEAKER_02: Imagina se eu comento assim, isso não segue solid.
• 47:23
  SPEAKER_02: Aí,
• 47:23
  SPEAKER_02: tipo,
• 47:23
  hierarquicamente eu vou falar um negócio que uma massa de
• 47:27
  pessoas concorda,
• 47:28
  SPEAKER_02: não precisa,
• 47:29
  SPEAKER_02: e aí se tornou aquilo que deve ser feito.
• 47:31
  Por isso que eu acho que tem que ter um baseline mínimo de
• 47:34
  quais são as regras que
• 47:35
  a gente não quer quebrar e quais são as regras que a gente quer
• 47:37
  continuar seguindo.
• 47:38
  SPEAKER_02: Todo o resto eu acho que continua sendo subjetivo.
• 47:40
  SPEAKER_02: Mas se não tiver o mínimo,
• 47:41
  a gente pode sofrer de pessoas com mais posição hierárquica ou
• 47:45
  pessoas com mais
• 47:46
  SPEAKER_02: influência...
• 47:48
  SPEAKER_02: social ali com as pessoas vão meio que ditar o que elas preferem e não
• 47:52
  necessariamente o que é melhor porque a visão de um é simples
• 47:55
  assim o Galeno foi lá
• 47:56
  SPEAKER_02: e fez um negócio simples aí eu falo ah não,
• 47:58
  você tinha que ter usado essas três coisas se ele fosse muito
• 48:01
  inexperiente ele
• 48:01
  SPEAKER_02: podia pensar caralho,
• 48:02
  SPEAKER_02: realmente eu não tô usando as paradas que tem que ser usado
• 48:05
  SPEAKER_02: E aí ele vai lá e faz o curso de aprender a fazer difícil,
• 48:08
  SPEAKER_02: achando que tá aprendendo a fazer melhor.
• 48:10
  SPEAKER_02: E aí, a partir de amanhã, ele passa a fazer isso.
• 48:11
  Aí quando ele tem mais três anos de experiência,
• 48:13
  ele faz isso com quem tem um.
• 48:14
  SPEAKER_02: E aí tem essa cascata de...
• 48:16
  SPEAKER_02: Ninguém tá realmente discutindo como deveria ser feito,
• 48:18
  SPEAKER_02: qual é a intenção que o projeto deveria.
• 48:20
  SPEAKER_02: É meio que vira folclore.
• 48:21
  SPEAKER_02: Quem tá ali na época, fala qual é a direção, né?
• 48:24
  SPEAKER_02: E não qual é a direção que o projeto deveria tomar.
• 48:27
  SPEAKER_02: Eu sempre lembro daquele caso do... Acho que foi contigo, né, Gabriel?
• 48:31
  SPEAKER_02: O cara falou que senior não...
• 48:34
  SPEAKER_02: Foi só isso o comentário do cara.
• 48:35
  SPEAKER_02: Caralho, o que isso quer dizer, meu Deus do céu?
• 48:38
  SPEAKER_02: É, não lembro o que foi, assim.
• 48:39
  SPEAKER_02: Era um código JavaScript e o cara só,
• 48:41
  SPEAKER_02: tipo,
• 48:42
  SPEAKER_02: botou...
• 48:43
  SPEAKER_02: Ah,
• 48:44
  SPEAKER_02: tá,
• 48:44
  SPEAKER_02: porque tem que chamar as funçãozinhas do JavaScript,
• 48:46
  SPEAKER_02: né?
• 48:47
  SPEAKER_02: For it, essas coisas, tá, entendi.
• 48:48
  SPEAKER_02: Map, tá, entendi.
• 48:50
  SPEAKER_02: É, é meio dodói da cabeça esse cara.
• 48:51
  SPEAKER_02: Eu já...
• 48:51
  SPEAKER_02: Teve um movimento no meio dos anos 2000 que era...
• 48:54
  SPEAKER_02: Não podia usar if na orientação objeto,
• 48:56
  SPEAKER_02: era no if,
• 48:56
  SPEAKER_02: alguma coisa assim.
• 48:57
  SPEAKER_02: Porque tudo tinha que ser polimórfico.
• 48:59
  SPEAKER_02: Tudo, tudo, o tempo inteiro, o código...
• 49:00
  SPEAKER_02: código tinha que ser só reto e o if acontece no runtime.
• 49:04
  SPEAKER_02: Esse é o problema, né?
• 49:05
  SPEAKER_02: Imagina se esse cara tem 10 anos de experiência,
• 49:07
  SPEAKER_02: na época eu tenho 2,
• 49:08
  SPEAKER_02: ele ia falar e você ia falar,
• 49:08
  SPEAKER_02: caralho,
• 49:09
  SPEAKER_02: pode crer,
• 49:09
  SPEAKER_02: você não quer só fazer o if.
• 49:11
  SPEAKER_01: Mas e o Elsie, o Elsie, qual que é a opinião de vocês?
• 49:13
  SPEAKER_01: Usa ou não usa?
• 49:14
  SPEAKER_01: Opa, caralho.
• 49:18
  SPEAKER_01: Diz que senior não usa else também, né?
• 49:20
  SPEAKER_02: É, né?
• 49:21
  SPEAKER_02: É tudo early return.
• 49:22
  SPEAKER_02: Eu não sei de onde essas coisas saíram.
• 49:23
  SPEAKER_02: Do Twitter.
• 49:24
  SPEAKER_02: Mas eu sou do grupo do early return.
• 49:26
  SPEAKER_02: Mas acho que a ideia do curso do Alex ali é boa.
• 49:28
  SPEAKER_02: Aprenda a fazer o difícil.
• 49:30
  SPEAKER_02: Acho que a gente vai fazer uma mentoria disso.
• 49:32
  SPEAKER_01: Vamos lançar um curso.
• 49:34
  SPEAKER_02: Curso da Codecom.
• 49:35
  SPEAKER_01: Não, a maioria já é assim.
• 49:36
  SPEAKER_02: Faz um curso de como fazer simples.
• 49:38
  É.
• 49:38
  SPEAKER_01: Mas eu ia falar, vocês têm alguma indicação?
• 49:41
  Eu anotei aqui o artigo que o Alex sugeriu,
• 49:45
  do G88,
• 49:46
  sobre os mercadores da complexidade.
• 49:49
  Eu queria indicar também o artigo do Mineto,
• 49:52
  que ele passou hoje cedo para a gente,
• 49:53
  que
• 49:54
  SPEAKER_01: Ele deu a sugestão desse tema, mas não pôde vir hoje.
• 49:56
  SPEAKER_01: Que ele fez sobre isso, né?
• 49:59
  SPEAKER_01: Sobre design, software e complexidade no blog da PicPay.
• 50:02
  SPEAKER_01: E a gente também fez um no blog da CodeCon lá.
• 50:06
  SPEAKER_01: Que o título é Complexidade de Código é Ruim.
• 50:08
  SPEAKER_01: Não sei se vocês têm algum outro livro.
• 50:11
  SPEAKER_02: Acho que a gente pode desindicar CleanCode, não ler CleanCode.
• 50:16
  SPEAKER_02: E fugir de algumas coisas.
• 50:18
  SPEAKER_01: Ou leia, mas interprete, né?
• 50:20
  SPEAKER_02: É.
• 50:24
  SPEAKER_01: como produto do seu tempo.
• 50:25
  SPEAKER_01: É,
• 50:26
  SPEAKER_01: eu acho que pode ler depois que você for experiente e pensar,
• 50:29
  SPEAKER_02: ah,
• 50:29
  SPEAKER_02: isso aqui é legal,
• 50:30
  SPEAKER_02: eu não tinha pensado nisso antes.
• 50:32
  SPEAKER_02: Porra, o que é isso?
• 50:32
  SPEAKER_02: Acho que tem que ter a crítica pra ler, né?
• 50:35
  SPEAKER_02: Porque se você ler sem a crítica, vira mandamentos, né?
• 50:38
  SPEAKER_02: Tipo, cada coisa que tá escrita é algo que deve ser feito.
• 50:40
  SPEAKER_02: Porque lembrando,
• 50:41
  SPEAKER_02: se tu não tem nenhuma ideia sobre aquilo,
• 50:43
  SPEAKER_02: a única ideia que existe é a única ideia que tem pra fazer.
• 50:46
  SPEAKER_02: Eu tenho três livros pra indicar que tem a ver com esse tema.
• 50:48
  SPEAKER_02: Três livros de Matoque.
• 50:50
  SPEAKER_02: Um se chama...
• 50:51
  SPEAKER_02: The Practice of Programming.
• 50:52
  Eu não sei se tem em português,
• 50:53
  mas seria tipo como a prática da programação.
• 50:56
  SPEAKER_02: É um livro do Rob Pike e do Brian Kerrigan.
• 50:59
  SPEAKER_02: Pra mim, esse livro é o Clean Code antes do Clean Code, tá?
• 51:02
  SPEAKER_02: Ele fala coisas que o Clean Code tentou falar, mas falou errado.
• 51:05
  Esse é um bom livro pra quem não quer ler o Clean Code,
• 51:08
  The Practice of Programming.
• 51:09
  SPEAKER_02: O outro, que é mais jovem... É o que tem um cachorrinho na capa, assim.
• 51:13
  SPEAKER_02: Um cachorrinho... É, é, um cachorrinho meio linguiça, é. É ele mesmo.
• 51:16
  SPEAKER_02: Ah, boa, boa.
• 51:17
  SPEAKER_02: Não leia esse livro pensando que é pra hoje em dia.
• 51:19
  SPEAKER_02: Lembra que esse livro foi escrito há 20 anos atrás.
• 51:21
  SPEAKER_02: Então tem coisa tipo assim... Pô, sabia que dá pra versionar o código?
• 51:24
  SPEAKER_02: Só pula.
• 51:24
  SPEAKER_02: Vai pras coisas que tu vê que é atemporal.
• 51:26
  SPEAKER_02: Não seja dodói pra falar... Ah, o livro é velho.
• 51:29
  SPEAKER_02: Tá?
• 51:29
  SPEAKER_02: Boa.
• 51:29
  SPEAKER_02: Livro mais recente.
• 51:31
  SPEAKER_02: Tem o do Kent Beck, que se chama Tidy First.
• 51:33
  SPEAKER_02: Esse livro é bom e ele é super fininho.
• 51:35
  SPEAKER_02: Não deve ter 80 páginas.
• 51:37
  SPEAKER_02: É bem de boa de ler.
• 51:38
  SPEAKER_02: Tem capítulo de duas páginas.
• 51:39
  SPEAKER_02: Tu pode abrir, ler duas e amanhã ler duas.
• 51:42
  SPEAKER_02: Aí pra quem é mais hardcore...
• 51:44
  SPEAKER_02: Vocês lembram que tem um livro que todo mundo fala assim,
• 51:46
  SPEAKER_02: você tem que ler esse livro,
• 51:47
  SPEAKER_02: Pragmatic Programming?
• 51:48
  SPEAKER_02: Então, beleza.
• 51:49
  SPEAKER_02: Só que esse livro também tem uns 20 ou 30 anos, né?
• 51:51
  O mesmo autor fez outro livro e o nome do livro é literalmente
• 51:54
  Simplicity.
• 51:56
  SPEAKER_02: E ele é desse ano.
• 51:57
  Então,
• 51:57
  se alguém quiser ler alguma coisa mais atualizada,
• 51:59
  eu recomendo esse.
• 52:00
  E por último,
• 52:00
  tem uma talk que foi o keynote da GoferCon de 2025,
• 52:05
  que fui eu que falei.
• 52:06
  SPEAKER_02: E é literalmente sobre simplicidade,
• 52:07
  SPEAKER_02: aí eu exploro simplicidade do ponto de vista quais são os elementos,
• 52:11
  SPEAKER_02: como é que você identifica,
• 52:12
  por que é importante e quando que você não tem como ficar mais
• 52:16
  simples do que já
• 52:17
  SPEAKER_02: está.
• 52:17
  SPEAKER_02: Aí eu tive que, infelizmente, falar de mim mesmo hoje.
• 52:19
  SPEAKER_02: Desculpa.
• 52:20
  SPEAKER_02: Eu acho que para além disso,
• 52:22
  dá para recomendar ler os PR dos Amiguinho e ver se você
• 52:25
  aprende alguma coisa com
• 52:26
  SPEAKER_02: isso.
• 52:26
  SPEAKER_02: Com esse olhar crítico tentando pensar em simplicidade.
• 52:29
  SPEAKER_02: E é isso aí.
• 52:31
  Ah,
• 52:31
  o Alex falou que ia falar o significado de simples no final do
• 52:35
  podcast.
• 52:36
  SPEAKER_01: Ah, é verdade, simplicidade, né?
• 52:37
  SPEAKER_01: O Alex deixou pro final aí o clickbait.
• 52:40
  SPEAKER_02: Então, tem uma talk, isso tá lá na Meta Talk, né?
• 52:44
  Na talk eu falo de outra talk,
• 52:46
  mas tem uma talk de um cara que se chama George Whitesides.
• 52:51
  E aí ele fez um TED Talk que se chama Simplicidade Nós
• 52:53
  Reconhecemos Quando A Vemos.
• 52:55
  SPEAKER_02: E aí ele falou várias coisas.
• 52:57
  SPEAKER_02: E aí eu tenho o compilado.
• 52:58
  SPEAKER_02: O compilado,
• 52:59
  SPEAKER_02: basicamente,
• 52:59
  SPEAKER_02: que ele tá dizendo,
• 53:01
  SPEAKER_02: em uma frase só,
• 53:01
  SPEAKER_02: depois vocês vão ver com calma,
• 53:02
  SPEAKER_02: porque tem uma talk pra vocês assistirem.
• 53:04
  SPEAKER_02: Ele diz o seguinte,
• 53:05
  SPEAKER_02: simplicidade envolve criar componentes que são,
• 53:07
  SPEAKER_02: aí tem as características,
• 53:08
  SPEAKER_02: confiáveis,
• 53:09
  SPEAKER_02: fáceis de entender,
• 53:11
  SPEAKER_02: que podem ser combinados ou empilhados,
• 53:13
  SPEAKER_02: depende de como você quer combinar,
• 53:15
  SPEAKER_02: para formar outros sistemas.
• 53:17
  SPEAKER_02: E aí,
• 53:17
  SPEAKER_02: esses sistemas maiores que você está formando,
• 53:20
  SPEAKER_02: eles podem ser até mais complexos,
• 53:22
  SPEAKER_02: mas eles vão ser previsíveis.
• 53:23
  SPEAKER_02: E aí,
• 53:24
  SPEAKER_02: uma característica,
• 53:25
  SPEAKER_02: se fosse falar em uma palavra,
• 53:26
  SPEAKER_02: assim,
• 53:26
  SPEAKER_02: para quão simples pode ser,
• 53:28
  SPEAKER_02: é quão acessível o código é.
• 53:30
  SPEAKER_01: Bom demais.
• 53:31
  SPEAKER_01: A gente não pode ir, né?
• 53:32
  SPEAKER_02: Porra, graças a Deus.
• 53:43
  SPEAKER_01: Você escutou Escovando Bits, o podcast da Codecom.
• 53:46
  Siga a Codecom nas redes sociais,
• 53:48
  assine nossa newsletter e participe dos nossos eventos.
• 53:50
  SPEAKER_01: Você encontra todos os links no site codecom.dev.
• 53:54
  SPEAKER_01: Valeu e até a próxima.
• 53:56
  SPEAKER_03: Falou!
• 53:56
  SPEAKER_03: Falou!
• 54:04
  SPEAKER_01: Esse podcast foi editado pela BZT.