Latest / escovando bits podcast / #69 - Desenvolvimento sustentável: Como escrever código que envelhece bem ft. Bruno Rocha

Transcript

#69 - Desenvolvimento sustentável: Como escrever código que envelhece bem ft. Bruno Rocha · escovando bits podcast

0:03
SPEAKER_02: Assine a Codicom Pro, apoie a Codicom e ganhe vários benefícios.
0:17
SPEAKER_02: Olá, você está escutando Escovando Beats, o podcast da Codicom.
0:23
Codicom
0:29
Eu sou o Gabriel e eu não sei o que falar na introdução desse
0:32
episódio,
0:33
desculpa.
0:34
Aqui é o Alexandre e o meu código é tão reciclável que ele tá
0:39
indo direto pro Recycle Bin.
0:40
E eu sou o Bruno Rocha e eu espero que o meu código envelheça
0:44
melhor do que eu.
0:50
SPEAKER_02: O cara comendo um Hot Pocket no café da manhã com um Monster.
0:56
SPEAKER_02: Eu vi um cara que faz isso no Twitter.
0:58
SPEAKER_02: Ele bota lá.
0:59
SPEAKER_02: Café da manhã.
1:00
SPEAKER_02: É um Hot Pocket e um Monster.
1:01
SPEAKER_02: Esse bicho vai morrer com 35 anos.
1:04
Esse aí vai ser aquela típica exceção que nem a avó do cara que
1:08
fumou até os 95 e
1:09
SPEAKER_01: não morreu de câncer,
1:10
SPEAKER_01: sabe?
1:12
SPEAKER_01: Esse cara é a típica exceção da regra.
1:13
SPEAKER_02: É verdade.
1:14
SPEAKER_02: O cara trata o código com o maior amor.
1:16
SPEAKER_02: O computador limpa tudo bonitinho.
1:18
SPEAKER_02: Vai lá e come isso aí no café da manhã.
1:20
SPEAKER_02: Não faz nada.
1:21
SPEAKER_02: E o hardware dele ele não trata bem, né?
1:25
SPEAKER_02: A gente vai só para o nosso intervalo comercial e já volto.
1:31
SPEAKER_00: Pergunta sobre arquitetura e engenharia.
1:37
SPEAKER_00: Só que de software.
1:43
SPEAKER_02: Neste quadro,
1:44
trazemos um especialista do ASUS para tirar dúvidas dos devs
1:47
quando o assunto é
1:47
SPEAKER_02: arquitetura e engenharia de software.
1:50
SPEAKER_02: Hoje estamos aqui com a Larissa Martins,
1:52
SPEAKER_02: Tech Lead,
1:53
SPEAKER_02: para nos ajudar a sanar as dúvidas que recebemos.
1:56
SPEAKER_02: Deploy Sem Medo Existe,
1:58
o que realmente ajuda a ter confiança para colocar uma feature
2:01
nova em produção?
2:02
SPEAKER_00: Eu não gostaria exatamente a palavra mesmo.
2:04
SPEAKER_00: Eu acho que, na verdade, o que acontece mais é a insegurança.
2:07
SPEAKER_00: E eu acho que é um sentimento super genuíno, né?
2:11
Principalmente quando a gente ainda tá conhecendo o produto ou
2:13
tá mexendo em uma
2:14
SPEAKER_00: parte do sistema que a gente sabe que é muito crítica,
2:16
SPEAKER_00: né?
2:17
SPEAKER_00: Eu acredito que o ponto seja que essa insegurança nunca vai sumir 100%.
2:20
SPEAKER_00: Não sei se isso é bom ou ruim de falar pras pessoas.
2:24
SPEAKER_00: Mas o que acontece é que a gente vai ganhando confiança, né?
2:27
SPEAKER_00: Então,
2:27
SPEAKER_00: com o tempo essa insegurança,
2:28
SPEAKER_00: ela vai diminuindo e vai se tornando um pouco mais confiança.
2:32
SPEAKER_00: E tem algumas coisas que ajudam a gente, né?
2:34
SPEAKER_00: Algumas práticas que ajudam a gente a ganhar confiança.
2:37
SPEAKER_00: Uma delas é a questão dos testes, né?
2:40
Então,
2:40
quando a gente tem uma suite de testes bem preparada ali,
2:43
que tem uma cobertura boa...
2:45
SPEAKER_00: A gente sente uma segurança um pouco maior,
2:47
porque a gente tem certeza que o nosso código passou ali por
2:49
toda aquela suite e
2:51
SPEAKER_00: tem um aval ali da suite que deu boa,
2:54
SPEAKER_00: né,
2:54
SPEAKER_00: que a chance de dar problema em produção é menor.
2:58
SPEAKER_00: E também tem uma observabilidade boa,
3:00
SPEAKER_00: né,
3:00
SPEAKER_00: então eu ter monitores,
3:02
SPEAKER_00: ter logs que me ajudam a entender ali a saúde do sistema.
3:06
SPEAKER_00: que vão me trazer essa segurança que,
3:08
SPEAKER_00: não que necessariamente não vá quebrar,
3:10
SPEAKER_00: mas se quebrar,
3:11
SPEAKER_00: eu vou ter esse retorno de uma forma mais rápida ali,
3:13
SPEAKER_00: vão impactar bem menos o usuário.
3:16
Então a gente consegue criar essas blindagens ali pra aumentar
3:19
a nossa confiança.
3:20
SPEAKER_00: Música
3:31
O Perguntas de Engenharia e Arquitetura Socket Software é
3:34
patrocinado pelo ASUS.
3:35
Acesse o link na descrição do episódio para saber mais sobre as
3:38
vagas disponíveis
3:39
SPEAKER_02: para a área de engenharia de software.
3:48
SPEAKER_02: E já estamos de volta, hoje a gente tá aqui com o Bruno Rocha, né?
3:52
SPEAKER_02: Bruno, a gente tava conversando aqui, tu tá 10 anos na Red Hat, né?
3:56
SPEAKER_02: Quer contar quem tu é também, pessoal que não te conhece?
3:58
Sim,
3:59
então,
3:59
eu tô 10 anos na Red Hat,
4:01
já passei por alguns times e projetos diferentes...
4:05
SPEAKER_02: Hoje eu sou principal engineer no Ansible,
4:08
SPEAKER_02: né,
4:08
SPEAKER_02: Ansible é uma plataforma de automação,
4:10
SPEAKER_02: então eu tenho uma plataforma web e uma estrutura de sistema distribuído,
4:16
SPEAKER_02: a gente trabalha muito com eventos e essas coisas,
4:18
SPEAKER_02: então eu trabalho mais na parte de arquitetura,
4:21
SPEAKER_02: né,
4:21
SPEAKER_02: para esse...
4:22
SPEAKER_02: para esse sistema.
4:23
É uma equipe grande,
4:24
a gente tem 180 e poucos devs trabalhando só no Ansible,
4:29
né?
4:30
SPEAKER_02: E no restante da Red Hat são mais de 19 mil trabalhando na companhia.
4:36
SPEAKER_02: E na Red Hat já passei pelos times de qualidade de software,
4:38
SPEAKER_02: foi uma das áreas que eu trabalhei por mais tempo,
4:41
SPEAKER_02: antes de vir para trabalhar na parte de arquitetura e engenharia.
4:44
SPEAKER_02: E é isso,
4:44
SPEAKER_02: eu tô trabalhando com open source,
4:46
SPEAKER_02: software livre,
4:47
SPEAKER_02: Linux,
4:48
SPEAKER_02: desde ali do comecinho dos anos 2000,
4:50
SPEAKER_02: e é isso que eu gosto de fazer,
4:52
SPEAKER_02: né?
4:52
SPEAKER_02: Até brinco que é meio que uma,
4:54
SPEAKER_02: é tipo,
4:56
SPEAKER_02: é quase que um...
4:57
SPEAKER_02: Eu tava até tentando fazer um diagnóstico esses dias,
5:00
SPEAKER_02: né?
5:00
SPEAKER_02: Eu vi lá que tem uma galera que é assim,
5:02
SPEAKER_02: tipo,
5:02
SPEAKER_02: tem gente que é viciado em ficar jogando jogo,
5:05
SPEAKER_02: videogame,
5:06
SPEAKER_02: eu sou meio que maluco,
5:07
SPEAKER_02: viciado de ficar fuçando em computador,
5:09
SPEAKER_02: né?
5:09
SPEAKER_02: Então...
5:10
Me dá um terminal no Linux e umas coisas pra eu configurar que
5:13
eu já fico feliz,
5:14
sabe?
5:14
SPEAKER_02: Eu já me divirto só fuçando e selecionando coisa e vendo se quebra.
5:19
SPEAKER_02: E tive a felicidade de transformar isso em profissão, né?
5:23
SPEAKER_02: Então é isso aí.
5:23
SPEAKER_01: Quebrador de código profissional.
5:25
SPEAKER_01: Cara, pessoas normais têm que gostar de fazer isso, cara.
5:28
SPEAKER_01: Quem não gosta é que é anormal, entendeu?
5:30
SPEAKER_01: Deixa eu fazer uma pergunta aleatória porque eu sou o saudosista aqui.
5:33
SPEAKER_01: Quantos fees listo já foi?
5:34
SPEAKER_02: Ah, no Fizzle eu fui seis.
5:37
SPEAKER_02: Muito bom.
5:37
SPEAKER_01: Eu espero que você sinta a mesma saudade que eu, daquele evento, cara.
5:41
SPEAKER_01: Eu falo pro Gabriel, ele tem que fazer a Codecom Open Source agora.
5:44
SPEAKER_01: Só pra gente reviver as chamas do Fizzle no Brasil.
5:47
SPEAKER_02: Cara,
5:48
SPEAKER_02: eu acho que,
5:48
SPEAKER_02: eu não sei,
5:49
SPEAKER_02: eu acho que isso é muito o reflexo,
5:51
SPEAKER_02: assim,
5:51
SPEAKER_02: de como a indústria,
5:52
SPEAKER_02: né?
5:53
SPEAKER_02: Eu acho que a gente passou por uma fase onde Open Source,
5:56
SPEAKER_02: Free Software,
5:56
SPEAKER_02: era uma coisa que tinha uma magia,
5:58
SPEAKER_02: um negócio diferente,
5:59
SPEAKER_02: especial,
5:59
SPEAKER_02: assim,
5:59
SPEAKER_02: né?
6:00
SPEAKER_02: Hoje em dia, a gente tá numa outra fase.
6:02
SPEAKER_02: Esses eventos estão acontecendo, mas com outra cara, né?
6:04
SPEAKER_02: Mas eu acho que ia ser legal ter algo.
6:06
SPEAKER_01: É que meio que o open source virou normal também, né?
6:09
SPEAKER_01: Ficou muito mais normal, não é mais algo outsider assim, né?
6:12
SPEAKER_01: Virou tipo, é o que há, né?
6:13
SPEAKER_02: É, é o default, né?
6:15
Tipo,
6:15
eu lembro que na época dos primeiros fiz,
6:17
tipo,
6:17
era muito impressionante.
6:18
SPEAKER_02: Você fala assim,
6:19
SPEAKER_02: nossa,
6:19
SPEAKER_02: tem um software aqui que funciona,
6:21
SPEAKER_02: é muito parecido com aquele lá que é proprietário,
6:24
SPEAKER_02: que coisa maravilhosa.
6:25
SPEAKER_02: Hoje em dia é o contrário, né?
6:26
SPEAKER_02: Quando a gente vê um software, a gente já assume.
6:28
SPEAKER_02: Não, isso aí deve ter coisa open source no meio.
6:30
SPEAKER_02: Então ficou meio que mais o comum,
6:32
SPEAKER_02: mas a nostalgia é muito grande,
6:34
SPEAKER_02: até porque era uma coisa,
6:36
SPEAKER_02: eu não sei explicar,
6:36
SPEAKER_02: não sei encontrar palavras,
6:39
SPEAKER_02: o movimento de software livre,
6:41
SPEAKER_02: open source há 15 anos atrás,
6:44
SPEAKER_02: 15,
6:45
SPEAKER_02: 20 anos atrás,
6:45
SPEAKER_02: era um negócio muito louco,
6:48
SPEAKER_02: dá saudade.
6:49
SPEAKER_02: Então,
6:50
SPEAKER_02: o tema do episódio de hoje,
6:52
SPEAKER_02: se você tá lavando a louça aí ou dirigindo e não conseguiu ler,
6:57
SPEAKER_02: é desenvolvimento sustentável,
6:58
SPEAKER_02: como escrever código que envelhece bem.
7:00
SPEAKER_02: Até por isso que a gente fez essas brincadeiras ali no começo.
7:03
SPEAKER_02: E quando a gente tava planejando esse episódio,
7:05
SPEAKER_02: o Alexandre sugeriu,
7:06
SPEAKER_02: cara,
7:07
eu acho que a gente tem que trazer uma pessoa que escreve
7:09
código que precisa
7:10
SPEAKER_02: funcionar por muito tempo,
7:12
SPEAKER_02: assim.
7:12
SPEAKER_02: Tipo,
7:12
alguém que trabalha com open source ou trabalha num Linux ou
7:16
trabalha em alguma
7:17
SPEAKER_02: coisa,
7:17
SPEAKER_02: daí eu lembrei do Bruno.
7:18
Eu não sei se tu chegou a trabalhar já em código que foi pra
7:23
versões de Linux que a
7:24
SPEAKER_02: Red Hat fez,
7:25
SPEAKER_02: alguma coisa assim.
7:26
SPEAKER_02: Sim, né?
7:27
SPEAKER_02: Sim, sim.
7:28
SPEAKER_02: Eu trabalhei no time de qualidade, né?
7:30
SPEAKER_02: Então...
7:31
SPEAKER_02: Assim,
7:31
SPEAKER_02: quando eu trabalhei no time de qualidade,
7:33
eu não atuava diretamente escrevendo o código que ia para o
7:36
Linux ou para os
7:37
SPEAKER_02: sistemas todos,
7:39
SPEAKER_02: mas a gente testava e validava todo o fluxo de entrega e tudo mais desses
7:43
SPEAKER_02: softwares.
7:44
SPEAKER_02: Então, de algum jeito tem ali essa parte, né?
7:47
SPEAKER_02: Mas eu escrevi uma biblioteca em Python antes de eu entrar na Red Hat,
7:51
SPEAKER_02: que é um projeto open source,
7:52
SPEAKER_02: chama-se Dynaconf.
7:54
E o Dynaconf hoje está dentro do top 1% das bibliotecas mais
7:58
usadas no ecossistema Python.
8:00
SPEAKER_02: Então é uma biblioteca de configuração que a galera usa geral.
8:03
SPEAKER_02: Então esse código está rodando em muita coisa que usa Python.
8:08
SPEAKER_02: E é engraçado,
8:09
SPEAKER_02: às vezes eu nem imagino alguém vai lá,
8:11
SPEAKER_02: abre uma issue e fala assim,
8:12
SPEAKER_02: olha,
8:12
SPEAKER_02: eu vou olhar,
8:13
SPEAKER_02: a pessoa trabalha,
8:14
SPEAKER_02: sei lá,
8:15
SPEAKER_02: na OpenAI.
8:15
SPEAKER_02: Eu falo, olha, os caras estão usando.
8:17
SPEAKER_02: Para confilar internamente nas APIs de...
8:20
SPEAKER_02: E assim,
8:21
SPEAKER_02: em agosto agora,
8:21
SPEAKER_02: a Lib fez...
8:23
SPEAKER_02: A Lib fez 10 anos em agosto,
8:25
SPEAKER_02: né?
8:26
SPEAKER_02: Então,
8:26
eu comecei a fazer esse projeto um pouquinho antes de eu entrar
8:30
na Red Hat,
8:30
SPEAKER_02: em outra empresa que eu trabalhava antes.
8:33
SPEAKER_02: E é um projeto open source que tem evoluído,
8:35
SPEAKER_02: assim,
8:35
SPEAKER_02: com contribuição da galera na comunidade e...
8:39
SPEAKER_01: Cara,
8:39
SPEAKER_01: engraçado,
8:39
eu já usei a da Anacomf e não tinha a mínima ideia que era você
8:42
que tinha iniciado
8:43
SPEAKER_01: o projeto.
8:44
SPEAKER_01: Legal.
8:45
SPEAKER_01: Deixa eu fazer uma pergunta.
8:46
SPEAKER_01: A Red Hat é uma empresa que,
8:48
SPEAKER_01: assim,
8:49
SPEAKER_01: todo mundo que é do mundo open source,
8:51
SPEAKER_01: todo mundo de TI conhece a Red Hat,
8:53
SPEAKER_01: né?
8:53
Mas acho que ela não é uma empresa mainstream,
8:55
assim,
8:56
no sentido como a Oracle talvez seja,
8:58
né?
8:58
SPEAKER_01: De que está em todos os lugares, tem propaganda, sei lá...
9:02
SPEAKER_01: em grandes eventos e tal.
9:05
SPEAKER_01: Mas,
9:05
SPEAKER_01: em compensação,
9:06
a Red Hat também é uma empresa que é muito conhecida por fazer
9:08
software estável.
9:10
SPEAKER_01: Então,
9:11
SPEAKER_01: a gente tem desde o sistema operacional até outros produtos que têm essa
9:17
SPEAKER_01: preocupação de serem produtos que sejam longevos e estáveis.
9:21
SPEAKER_01: Pensando nesses grandes sistemas,
9:22
SPEAKER_01: tu falou que trabalhou no time de qualidade e tal,
9:25
SPEAKER_01: essa preocupação é uma preocupação que vem
9:27
SPEAKER_01: desde o dev lá dentro e passa por todo o time,
9:30
SPEAKER_01: ela é uma coisa que é top-down e tem que fazer e pronto,
9:34
SPEAKER_01: como é que é essa cultura,
9:35
SPEAKER_01: começando talvez especificamente pela Red Hat?
9:38
SPEAKER_02: Olha,
9:38
SPEAKER_02: eu acho que isso tem a ver com um negócio,
9:40
SPEAKER_02: um modelo de negócio da Red Hat,
9:42
SPEAKER_02: porque a Red Hat trabalha com open source,
9:44
SPEAKER_02: a missão da Red Hat é fomentar as comunidades,
9:47
SPEAKER_02: né,
9:47
SPEAKER_02: fazer com que o desenvolvimento aconteça no upstream,
9:50
SPEAKER_02: né,
9:50
SPEAKER_02: ajudar o upstream a inovar,
9:53
SPEAKER_02: né,
9:53
SPEAKER_02: então a gente tem aí,
9:54
SPEAKER_02: por exemplo,
9:55
SPEAKER_02: o Fedora Linux,
9:56
SPEAKER_02: a gente tem a parte do Ansible,
9:59
SPEAKER_02: que é toda open source,
10:00
SPEAKER_02: está toda lá no GitHub,
10:02
SPEAKER_02: a parte do Kubernetes,
10:03
SPEAKER_02: né,
10:03
que a Red Hat é uma das empresas aí que fez parte das
10:06
definições do que é hoje o
10:08
SPEAKER_02: Kubernetes,
10:08
SPEAKER_02: né,
10:08
E aí,
10:09
por outro lado,
10:09
o modelo de negócio da Red Hat é produtizar essas plataformas.
10:13
Então,
10:14
a gente pega o que é upstream e transforma no que a gente chama
10:16
de downstream.
10:17
SPEAKER_02: E o downstream, ele é uma versão enterprise daquilo que já é livre.
10:22
Aí você pensa,
10:23
como é que você vai convencer alguém a pagar você por uma coisa
10:26
que já é livre?
10:27
SPEAKER_02: Então aí que está o diferencial?
10:29
SPEAKER_02: O diferencial é justamente fazer com que aquilo envelheça bem,
10:32
fazer com que aquilo entregue um pouco mais de resiliência e de
10:36
garantias para quem
10:37
SPEAKER_02: está pagando.
10:38
SPEAKER_02: Então como é um sistema baseado em subscrição,
10:41
SPEAKER_02: o pagante,
10:42
SPEAKER_02: a empresa que decide contratar Red Hat pagar por uma subscrição,
10:46
O que ela está comprando não é o software,
10:47
ela poderia simplesmente baixar e instalar.
10:49
SPEAKER_02: O que ela está comprando é o fato da gente testar,
10:52
SPEAKER_02: então tem até o tried,
10:56
SPEAKER_02: tested and trusted,
10:57
SPEAKER_02: que é o nosso três T's.
10:59
SPEAKER_02: Então a gente usa o software,
11:01
SPEAKER_02: a gente melhora,
11:02
a gente fomenta a comunidade para que aquilo se desenvolva e
11:06
mantenha-se a...
11:08
SPEAKER_02: atualizado, né?
11:09
SPEAKER_02: Mantenha-se sem ficar defasado.
11:12
SPEAKER_02: A gente testa aquilo muito, né?
11:15
SPEAKER_02: Então,
11:15
SPEAKER_02: os testes são feitos em todos os níveis,
11:17
SPEAKER_02: desde o teste ali de ter que usar em hardware diferente,
11:21
SPEAKER_02: dependendo do que você estiver trabalhando.
11:23
SPEAKER_02: E o trusted é porque a gente fornece contratos, né?
11:26
SPEAKER_02: De suporte,
11:27
SPEAKER_02: onde os clientes têm ali SLA,
11:29
SPEAKER_02: equipe de suporte,
11:30
SPEAKER_02: equipe especializada para responder a incidentes,
11:32
SPEAKER_02: disaster recovery,
11:33
SPEAKER_02: esse tipo de coisa.
11:34
SPEAKER_02: Então,
11:35
SPEAKER_02: Toda a estrutura é baseada em pensar que o software tem que ser estável,
11:39
SPEAKER_02: porque tem que ser estável.
11:40
SPEAKER_02: Se ele não for estável,
11:41
SPEAKER_02: das duas uma,
11:42
SPEAKER_02: ou a gente perde o trusted,
11:44
SPEAKER_02: ou a gente tem que arcar com o custo que aquilo vai dar,
11:48
SPEAKER_02: porque é o que a gente está vendendo.
11:49
SPEAKER_02: Então, para minimizar esse custo, quanto mais estável, melhor.
11:52
SPEAKER_02: Então,
11:52
SPEAKER_02: é uma preocupação que vem já como,
11:54
SPEAKER_02: não só como cultura,
11:56
SPEAKER_02: mas como parte do modelo de negócio.
11:58
O que faz o drive do business em si é que o software tem que
12:01
ser estável e confiável.
12:06
SPEAKER_02: O que tu acha que define um código que envelhece bem?
12:09
SPEAKER_02: Ele é a mesma coisa que ser código limpo, sei lá, algo assim?
12:13
SPEAKER_02: Ah, agora a gente pode entrar em polêmica, né?
12:15
SPEAKER_02: A polêmica do Clean Code.
12:18
SPEAKER_02: Bom, eu pessoalmente não sou um grande fã do Clean Code, né?
12:22
SPEAKER_02: Já li duas vezes o livro.
12:23
SPEAKER_02: O livro e todas as coisas em volta dele.
12:25
SPEAKER_02: Eu acho excelente como um guia de referência e de sugestões, né?
12:30
SPEAKER_02: Mas acho que o que tá ali, né?
12:32
SPEAKER_02: Só pra fazer esse adendo.
12:33
SPEAKER_02: Não é para ser seguido a risca porque tem outras variáveis, né?
12:36
SPEAKER_02: Então não é simples, né?
12:38
Acho que essa receita não é simples de você simplesmente chegar
12:40
e falar assim,
12:41
SPEAKER_02: olha,
12:41
SPEAKER_02: escreva código limpo,
12:42
SPEAKER_02: escreva código seguindo solid e essas receitas todas.
12:47
SPEAKER_02: Eu acho que você tem que saber usar essas ferramentas,
12:50
SPEAKER_02: esses frameworks,
12:51
essas técnicas e encaixar elas dentro do principal que é o seu
12:55
objetivo de
12:56
SPEAKER_02: business,
12:57
SPEAKER_02: né?
12:57
SPEAKER_02: Então nem sempre a empresa que está desenvolvendo, ela quer...
13:01
SPEAKER_02: quer pagar pelo clean, entendeu?
13:02
SPEAKER_02: Porque fazer clean code, ele tem custo, entendeu?
13:05
SPEAKER_02: Fazer software altamente testado é custo, né?
13:08
SPEAKER_02: Fazer isso.
13:09
SPEAKER_02: Então, uma coisa tem que balancear na outra.
13:11
SPEAKER_02: Então,
13:11
eu acho que o que define hoje o software que envelhece bem é
13:14
ele ser um software
13:16
SPEAKER_02: que entrega,
13:17
SPEAKER_02: primeiro,
13:17
SPEAKER_02: o que ele precisa entregar,
13:18
SPEAKER_02: né?
13:19
Não adianta o software que é mais lindo,
13:21
que segue todas as boas práticas...
13:25
e simplesmente não atingir o objetivo,
13:28
é meio que um desperdício,
13:29
talvez.
13:30
SPEAKER_02: Eu já vi muito isso acontecer,
13:31
SPEAKER_02: aquela coisa assim,
13:32
SPEAKER_02: tipo,
13:32
SPEAKER_02: nossa,
13:33
SPEAKER_02: esse software é lindo,
13:33
SPEAKER_02: mas ninguém usa,
13:34
SPEAKER_02: né?
13:35
SPEAKER_02: Tem um meme que a gente fez na Codecom,
13:38
SPEAKER_02: um cara com uma colher gigantesca,
13:39
SPEAKER_02: assim,
13:40
SPEAKER_02: comendo sucrilhos,
13:41
SPEAKER_02: e daí a colher estava escrita assim,
13:43
SPEAKER_02: tipo,
13:43
SPEAKER_02: ah,
13:43
SPEAKER_02: microserviços,
13:45
SPEAKER_02: sei lá,
13:46
SPEAKER_02: todas essas paradas e,
13:47
SPEAKER_02: tipo,
13:47
SPEAKER_02: o seu software com zero usuário.
13:50
SPEAKER_02: Exato.
13:51
SPEAKER_02: Aqui é aquela ferramentinha que você faz com muito preciosismo,
13:54
SPEAKER_02: seguindo todas as regras e tudo mais,
13:56
SPEAKER_02: e no fim tem um usuário e é você mesmo,
13:58
SPEAKER_02: o usuário,
13:58
SPEAKER_02: sabe?
14:00
SPEAKER_02: Mas eu acho que assim,
14:01
SPEAKER_02: pensando em código que,
14:02
SPEAKER_02: digamos assim,
14:03
SPEAKER_02: que envelhece bem e que,
14:06
SPEAKER_02: basicamente,
14:07
SPEAKER_02: vamos definir o que é envelhecer bem.
14:08
SPEAKER_02: O que é um código que envelhece bem?
14:10
SPEAKER_02: Na minha opinião,
14:11
SPEAKER_02: acho que é um código que,
14:13
SPEAKER_02: no futuro,
14:14
ele vai causar menos prejuízo e ele vai conseguir responder à
14:18
mudança de escopo.
14:19
SPEAKER_02: Porque o que a gente definiu hoje,
14:21
SPEAKER_02: daqui a cinco anos,
14:22
SPEAKER_02: provavelmente,
14:23
SPEAKER_02: a não ser que você esteja numa indústria muito estável,
14:26
SPEAKER_02: digamos assim,
14:26
SPEAKER_02: que você está trabalhando lá,
14:28
SPEAKER_02: Existem algumas indústrias que não mudam há 30 anos, né?
14:31
SPEAKER_02: Então não tem muito o que inovar.
14:32
SPEAKER_02: Você falar a palavra inovação, né?
14:34
Dependendo do banco que você tiver,
14:35
os caras vão até falar,
14:36
tira essa pessoa da sala,
14:37
entendeu?
14:41
SPEAKER_02: Inovar é muito complicado.
14:42
SPEAKER_02: Mas na indústria de software,
14:44
SPEAKER_02: de um modo geral,
14:45
SPEAKER_02: a gente...
14:46
SPEAKER_02: 5 anos é um tempo assim que,
14:47
SPEAKER_02: meu,
14:48
SPEAKER_02: às vezes faz o pivô de todo o modelo de negócio de uma empresa.
14:53
E se você fizer um software que não responde bem a essas
14:56
mudanças de escopo,
14:57
SPEAKER_02: de objetivo,
14:58
SPEAKER_02: eu acho que você está fazendo um software que não envelhece bem.
15:01
SPEAKER_02: Ele pode ser lindo.
15:02
SPEAKER_02: Então eu acho que não é só questão de qualidade.
15:03
Eu acho que você pode ter lá aquela coisa maravilhosa feita na
15:07
melhor linguagem
15:07
SPEAKER_02: possível,
15:08
SPEAKER_02: seguindo todos os preceitos e documentações e tudo mais,
15:11
SPEAKER_02: só que chega ali no segundo tempo onde vem um requisito de negócio,
15:17
SPEAKER_02: onde olha,
15:17
SPEAKER_02: agora a gente vai ter que ir para esse outro caminho.
15:19
SPEAKER_02: e simplesmente o software é o problema, o código é o problema.
15:24
Eu lembro que eu até fiz aqui a palestra de AI no Meetup da
15:27
Codecom e o meu título
15:29
SPEAKER_02: era lá que o código é o problema sempre foi o problema,
15:32
SPEAKER_02: não é a solução.
15:33
E nesse caso,
15:33
o software lindo acaba sendo o problema,
15:35
porque você ingesta o seu produto.
15:39
SPEAKER_02: Assim,
15:39
SPEAKER_02: olha,
15:39
SPEAKER_02: tudo bem,
15:40
SPEAKER_02: a gente quer ir para esse caminho,
15:41
SPEAKER_02: mas não pode,
15:42
SPEAKER_02: porque é impossível colocar isso naquele software,
15:44
SPEAKER_02: porque as validações que ele tem não deixam a gente fazer tal coisa.
15:48
SPEAKER_02: Aí você tem que começar a criar um monte de coisa extra,
15:51
SPEAKER_02: sair do meio do caminho,
15:52
SPEAKER_02: criar custo,
15:53
SPEAKER_02: pendurar coisas em volta,
15:54
SPEAKER_02: porque aquele software é tão bom,
15:56
mas de tão bom ele é tão engessado que ele não permite que o
16:01
produto evolua.
16:02
Então eu acho que daria para a gente pensar,
16:04
para resolver essa questão específica,
16:07
É que a gente tem que pensar em formas de que o nosso código
16:12
não seja barreira.
16:14
Eu estou tentando achar uma palavra para exemplificar isso,
16:18
mas substituível.
16:20
A gente tem que pensar em código como algo substituível,
16:23
é isso,
16:23
não ter esse apego.
16:24
SPEAKER_02: Mas tipo,
16:26
SPEAKER_02: eu já ouvi várias pessoas falando sobre isso,
16:28
SPEAKER_02: de tipo,
16:28
SPEAKER_02: quando tu vai programar uma parada,
16:31
SPEAKER_02: tu não pode ficar tentando prever muito o futuro,
16:34
SPEAKER_02: assim,
16:34
SPEAKER_02: né?
16:35
SPEAKER_02: Tu não pode... Mas ao mesmo tempo é tão confuso fazer isso, né?
16:39
SPEAKER_02: Porque tipo, putz...
16:40
SPEAKER_02: Sei lá, eu vou criar um novo model lá, um novo service.
16:45
Como que eu vou,
16:46
tipo,
16:46
pensar que ele pode ser substituído no futuro,
16:49
assim?
16:49
SPEAKER_02: Como que eu... Sei lá, como tem essa visão, sabe?
16:52
SPEAKER_02: Não sei se tu consegue explicar isso.
16:54
SPEAKER_02: Porque pra mim é muito confuso pensar nisso, entendeu?
16:57
SPEAKER_02: Tipo, putz, eu preciso pensar num código que ele pode ser substituível.
17:00
SPEAKER_02: Eu acho que aí,
17:01
SPEAKER_02: nesse caso,
17:01
SPEAKER_02: para a gente evitar um pouco desse esforço que é pensar muito,
17:06
eu acho que a gente pode ser um pouco mais conservador e se
17:10
apegar a padrões bem
17:11
SPEAKER_02: estabelecidos.
17:12
Então,
17:12
por exemplo,
17:13
se você estiver desenvolvendo um site,
17:15
um sistema de e-commerce,
17:16
sei lá,
17:17
E você sabe que hoje a sua funcionalidade principal é ter ali
17:20
uma vitrine de
17:21
SPEAKER_02: produtos,
17:22
SPEAKER_02: aonde tem filtros e tudo mais,
17:24
SPEAKER_02: só que você não sabe no futuro o que vão querer fazer,
17:26
SPEAKER_02: qual a integração que vão querer fazer com outros sistemas.
17:29
SPEAKER_02: Então, o que você tem que fazer?
17:30
SPEAKER_02: Primeiro, se apegar a padrões.
17:32
SPEAKER_02: Então, existem padrões de projetos
17:35
E talvez hoje eles não façam nenhum sentido para o seu sistema,
17:39
eles não falem nada,
17:40
entendeu?
17:41
SPEAKER_02: Mas se você se aderir a esses padrões,
17:43
você vai estar deixando aquela abertura para o futuro sem ter
17:47
que necessariamente
17:48
SPEAKER_02: se preocupar com o futuro.
17:49
Então evitar o autocoplamento pode parecer uma besteira logo de
17:54
início,
17:55
né?
17:55
Tipo,
17:55
olha,
17:55
por que eu já não coloco minha funcionalidade toda aqui mesmo,
17:58
né?
17:58
SPEAKER_02: Dentro desse...
18:00
desse módulo do sistema e no futuro,
18:02
se quiser,
18:02
eu faço copy,
18:03
paste,
18:03
removo daqui.
18:04
SPEAKER_02: Não,
18:04
já existem padrões bem estabelecidos que não custam a gente
18:08
implementar de fazer
18:10
SPEAKER_02: uma arquitetura um pouco mais componível,
18:13
SPEAKER_02: né?
18:14
SPEAKER_02: Eu ia perguntar mais uma coisa sobre esse dos padrões.
18:17
SPEAKER_02: Se tu tem dicas,
18:18
SPEAKER_02: sei lá,
18:18
SPEAKER_02: de três padrões que tu acha que são,
18:21
SPEAKER_02: tipo,
18:22
SPEAKER_02: obrigatórios,
18:22
SPEAKER_02: assim,
18:23
SPEAKER_02: tu usar sempre.
18:24
SPEAKER_02: Tá, eu acho, assim, que...
18:26
SPEAKER_02: Quando a gente entra nesse lance dos padrões, tem várias questões.
18:30
SPEAKER_02: Se você pega aquele livro de padrões de projeto lá do Gang of War,
18:33
SPEAKER_02: o clássico,
18:34
SPEAKER_02: aquilo muito se aplica para Java,
18:38
SPEAKER_02: para um cenário muito específico.
18:40
SPEAKER_02: Hoje em dia, nem tudo ali faz sentido.
18:42
Eu costumo falar bastante disso porque eu trabalho muito com
18:45
Python e pelo menos
18:46
SPEAKER_02: metade dos padrões de projeto não se aplicam a Python.
18:49
SPEAKER_02: Por quê?
18:50
Porque Python é uma linguagem que já tem alguns padrões já
18:53
intrínsecos na própria
18:54
linguagem e outros simplesmente não fazem sentido por ser uma
18:57
linguagem dinâmica,
18:59
SPEAKER_02: uma linguagem que tem duct typing,
19:00
SPEAKER_02: essas coisas assim.
19:01
SPEAKER_02: Então,
19:01
SPEAKER_02: eu acho que quando eu falo em padrões,
19:04
eu não estou nem falando tanto desses padrões de projeto que
19:08
fazem com que a gente
19:09
SPEAKER_02: fique meio pedante na hora que a gente olha para uma classe,
19:12
SPEAKER_02: para um objeto e fique pensando não,
19:14
SPEAKER_02: mas isso aqui não está seguindo o padrão observer,
19:16
SPEAKER_02: o padrão isso,
19:17
SPEAKER_02: o padrão aquilo.
19:18
O que eu estou falando é a gente se apegar mais a protocolos
19:21
que vão permitir que o
19:22
SPEAKER_02: nosso sistema,
19:23
SPEAKER_02: aquilo que a gente desenvolve,
19:25
SPEAKER_02: consiga ser composto com outras coisas.
19:27
SPEAKER_02: Então,
19:28
SPEAKER_02: para dar um exemplo mais simples,
19:30
SPEAKER_02: dependendo do sistema que você está fazendo,
19:33
SPEAKER_02: você pode já começar com uma arquitetura de plugins.
19:35
SPEAKER_02: mesmo que você não tenha plugins.
19:37
SPEAKER_02: Então,
19:37
SPEAKER_02: a funcionalidade que você mesmo está desenvolvendo,
19:40
você já pode criar ela para falar com o core do seu próprio
19:44
sistema usando uma
19:44
SPEAKER_02: arquitetura de plugins.
19:45
SPEAKER_02: Alguns anos atrás,
19:46
SPEAKER_02: eu diria que isso era loucura,
19:48
SPEAKER_02: porque você vai estar pagando o preço de estar fazendo essa integração,
19:52
SPEAKER_02: você tem mais um ponto de falha.
19:53
SPEAKER_02: Mas hoje em dia,
19:54
SPEAKER_02: para qualquer tecnologia que você pegar,
19:56
SPEAKER_02: seja ela framework,
19:58
SPEAKER_02: runtime,
19:59
SPEAKER_02: plataforma,
20:00
SPEAKER_02: você já tem muito bem estabelecidos sistemas que
20:03
SPEAKER_02: muito bons,
20:04
SPEAKER_02: que inclusive vão ajudar você a guiar a sua própria definição da sua
20:08
SPEAKER_02: funcionalidade,
20:09
SPEAKER_02: porque eles já trabalham muito bem com esse sistema de plugins.
20:12
Então,
20:13
se você se apegar a um padrão de plugin,
20:15
você pode desenvolver hoje e jogar fora amanhã.
20:18
SPEAKER_02: Você pode fazer estratégias de feature flagging,
20:21
onde você vai entregar parte do seu deployment rodando uma
20:25
versão de um plugin em
20:26
SPEAKER_02: parte.
20:26
SPEAKER_02: Então, você abre possibilidades para outras coisas.
20:29
SPEAKER_02: Então, esse tipo de padrão
20:32
SPEAKER_02: Eu não sei se eu acharia um nome muito científico,
20:34
SPEAKER_02: técnico para ele,
20:35
SPEAKER_02: mas é deixar o seu código um pouco mais fácil de compor.
20:38
E dos princípios de solid,
20:41
você criar código que seja facilmente substituível.
20:44
Então essa é uma das dicas que eu procuro seguir e que ela não
20:47
exige aquele
20:49
SPEAKER_02: pensamento científico muito aprofundado.
20:51
SPEAKER_02: E que basta você pensar assim,
20:53
SPEAKER_02: olha,
20:53
SPEAKER_02: eu acabei de escrever aqui uma função,
20:55
SPEAKER_02: uma classe,
20:55
SPEAKER_02: um módulo,
20:56
SPEAKER_02: seja o que for.
20:56
O quão difícil é se eu precisar tirar isso daqui hoje e
20:59
substituir por outras coisas?
21:01
SPEAKER_02: E o que eu posso fazer para deixar mais fácil essa substituição?
21:05
SPEAKER_02: Então, eu posso criar mais funções?
21:07
SPEAKER_02: Bora fazer mais funções.
21:08
Eu posso criar um objeto de contexto muito mais estabelecido
21:12
que possa ser passado?
21:13
SPEAKER_02: Então, dependendo da linguagem, dá para você fazer isso.
21:15
SPEAKER_02: Então,
21:16
SPEAKER_02: quando eu falo de padrões,
21:17
SPEAKER_02: é você usar da plataforma que você está desenvolvendo os padrões mais
21:21
SPEAKER_02: estabelecidos,
21:22
SPEAKER_02: ao invés de tentar fazer tudo
21:24
SPEAKER_02: digamos assim, sem pensar no futuro, basicamente.
21:28
SPEAKER_02: Porque hoje pensar no futuro não custa tanto.
21:30
SPEAKER_02: Muita gente já pensou para a gente nesse tipo de problema aí.
21:36
SPEAKER_01: Era isso que eu ia trazer até na pergunta anterior,
21:37
porque a minha percepção é de que quando eu quero construir um
21:41
software que vai
21:41
SPEAKER_01: envelhecer bem,
21:43
SPEAKER_01: eu necessariamente vou apostar em soluções que já são sólidas de mercado.
21:47
SPEAKER_01: Então assim,
21:48
SPEAKER_01: no meu caso,
21:48
SPEAKER_01: por exemplo,
21:49
SPEAKER_01: e aqui é a minha percepção,
21:50
quando eu quero fazer um software que eu vou poder fazer
21:52
manutenção por muito
21:53
SPEAKER_01: tempo,
21:54
SPEAKER_01: Eu vou fazer ele em Python e provavelmente se ele envolver back-end,
21:57
SPEAKER_01: eu vou fazer ele em Django,
21:58
SPEAKER_01: um por familiaridade,
22:00
SPEAKER_01: outro porque eu estou no Django desde a versão 0.96.
22:03
Então eu sei que ele não vai dar um carrinho de pau e virar e
22:07
abandonar o código.
22:09
E também sei que é uma plataforma que tem uma preocupação em
22:12
interface upgrade,
22:14
SPEAKER_01: mantendo a compatibilidade retroativa.
22:18
Essa sensação de que quando a gente quer fazer software que
22:20
envelhece bem,
22:21
SPEAKER_01: escolher tecnologias que já são consolidadas,
22:24
SPEAKER_01: já é um bom caminho para iniciar?
22:27
Ou nem sempre vale a pena apostar na nova versão do framework
22:31
que surgiu amanhã?
22:32
SPEAKER_02: Aquela velha resposta de todo mundo, né?
22:35
SPEAKER_02: Depende.
22:37
SPEAKER_02: Mas eu concordo com você, por exemplo, ó.
22:39
Só para deixar bem claro,
22:40
eu sou um hater do Django,
22:43
assim,
22:43
na comunidade.
22:45
Eu sempre,
22:46
se for para conversar sobre o Django,
22:47
eu vou falar um monte de coisa ruim do Django.
22:49
SPEAKER_02: Mas eu trabalho com o Django hoje,
22:51
SPEAKER_02: então já tem mais de 10 anos que eu trabalho com o Django,
22:54
SPEAKER_02: e eu sei que ele é a melhor opção para aquilo que a gente desenvolve.
22:57
SPEAKER_02: Então,
22:58
SPEAKER_02: saber separar essa coisa do tipo,
23:00
SPEAKER_02: olha,
23:00
SPEAKER_02: eu não gosto dessa tecnologia,
23:01
SPEAKER_02: mas eu entendo o valor dela,
23:03
SPEAKER_02: é uma coisa bastante interessante.
23:05
SPEAKER_02: Então,
23:05
SPEAKER_02: o valor para mim do Django,
23:06
SPEAKER_02: por exemplo,
23:07
SPEAKER_02: entre os que você falou,
23:08
SPEAKER_02: é que ele é bem estabelecido,
23:10
SPEAKER_02: né?
23:10
SPEAKER_02: Então,
23:11
SPEAKER_02: como tem muita gente que depende dele,
23:13
SPEAKER_02: é muito difícil a gente pensar assim,
23:14
SPEAKER_02: olha,
23:15
SPEAKER_02: amanhã ele vai lançar uma versão 6,
23:17
SPEAKER_02: né?
23:17
SPEAKER_02: que quebrou completamente todo mundo.
23:20
SPEAKER_02: A gente não consegue mais envelhecer e deixar o nosso código.
23:23
SPEAKER_02: Porque se isso acontecer,
23:25
você tem pelo menos mais uma centena que está na mesma situação
23:29
que vai conseguir
23:30
SPEAKER_02: encontrar uma solução para resolver esse problema.
23:32
SPEAKER_02: Então,
23:33
SPEAKER_02: eu acho que vale a pena você se apoiar nos ombros dos gigantes,
23:37
SPEAKER_02: como dizem,
23:37
SPEAKER_02: e usar essas ferramentas já prontas.
23:40
SPEAKER_01: Agora, existem tecnologias
23:41
Eu só ia comentar que teve uma quebra bem grande para quem
23:45
trabalha com Python,
23:46
SPEAKER_01: que foi a virada do Python 2 para o Python 3.
23:49
SPEAKER_01: E mesmo ela sendo uma quebra bem grande,
23:51
SPEAKER_01: ela foi uma quebra que foi muito transicionada e bem comunicada,
23:56
SPEAKER_01: e instruindo as pessoas que queriam fazer o upgrade.
23:59
SPEAKER_01: Então,
24:00
SPEAKER_01: quando eu digo,
24:00
SPEAKER_01: às vezes,
24:01
SPEAKER_01: se apoiar em uma biblioteca grande,
24:02
SPEAKER_01: é mais nesse contexto também,
24:04
SPEAKER_01: claro,
24:04
SPEAKER_01: de ter mais milhares de pessoas que vão ter problemas.
24:06
SPEAKER_01: Então, alguém vai te ajudar a achar,
24:08
Mas acho que empresas e soluções e frameworks que têm essa
24:11
preocupação de durabilidade também.
24:13
É,
24:13
o caso do Python é interessante,
24:15
porque foi uma mudança relativamente simples.
24:17
SPEAKER_02: A coisa drástica do Python foi mudar como que as strings eram tratadas,
24:21
SPEAKER_02: a necessidade de você ter strings e unicode,
24:24
e agora tudo se transformar de repente em strings e unicode e
24:27
quebrar código do
24:28
SPEAKER_02: Python 2.
24:29
SPEAKER_02: E o jeito que isso foi feito, foi feito durante 10 anos.
24:34
Então você imagina que para você migrar da versão 2.7 de uma
24:38
linguagem para a
24:38
SPEAKER_02: versão 3,
24:39
SPEAKER_02: demora 10 anos.
24:41
Num sistema comercial,
24:42
provavelmente o business teria empurrado isso em seis meses.
24:47
SPEAKER_02: Como o Python é uma linguagem aberta e que é usada em vários contextos,
24:51
SPEAKER_02: não tem esse push de negócio,
24:54
pode ser feita essa orquestração durante 10 anos para que todo
24:57
mundo migrasse.
24:58
SPEAKER_02: E a própria comunidade criou ferramentas, né?
25:00
SPEAKER_02: Existia uma ferramenta chamada SIX,
25:02
que ela conseguia converter aos poucos gradualmente o seu
25:05
código de Python 2 para
25:07
SPEAKER_02: Python 3.
25:07
SPEAKER_02: E aí você podia rodar tanto no 2 quanto no 3,
25:09
SPEAKER_02: que ela fazia as conversões ali em tempo de runtime.
25:12
SPEAKER_02: Hoje em dia não se usa mais porque já está todo mundo no Python 3.
25:15
SPEAKER_02: Então você ter certeza de que se vai acontecer esse tipo de quebra,
25:19
SPEAKER_02: a comunidade ou quem te fornece a tecnologia vai te dar essa garantia,
25:23
SPEAKER_02: né?
25:23
SPEAKER_02: De você ter ferramentas para evoluir.
25:25
SPEAKER_02: eu acho super importante, né?
25:27
SPEAKER_02: É por isso que,
25:27
SPEAKER_02: assim,
25:28
SPEAKER_02: é meio que enviesada a minha opinião,
25:30
SPEAKER_02: mas eu prefiro ferramentas abertas por conta desse motivo,
25:33
SPEAKER_02: né?
25:33
Porque é muito mais fácil a comunidade como um todo fazer isso
25:37
do que colocar um
25:38
conflito de interesse comercial para empurrar um upgrade ou a
25:41
mudança de alguma
25:42
SPEAKER_02: ferramenta naquele estilo do tipo,
25:44
SPEAKER_02: olha,
25:44
SPEAKER_02: a gente decidiu que vai ser assim e você se vira,
25:47
SPEAKER_02: sabe?
25:47
SPEAKER_02: Você tem que migrar, o problema é seu.
25:49
SPEAKER_02: E isso tem custo, né?
25:51
SPEAKER_02: E eu ia complementar, ah, na sua pergunta que você falou do Django,
25:55
SPEAKER_02: Lembrando que a gente está falando do Django,
25:56
SPEAKER_02: mas acho que isso se aplica a qualquer outra linguagem e tecnologia.
25:59
SPEAKER_02: Todas elas têm aquele framework ou aquele ambiente que é o mais famosão,
26:04
SPEAKER_02: que é o que todo mundo usa.
26:05
SPEAKER_02: Só que tem um detalhe,
26:06
SPEAKER_02: fazer isso que o Python fez,
26:08
SPEAKER_02: por exemplo,
26:08
SPEAKER_02: que o Django faz,
26:09
que é ter as suas versões estáveis e arcar com essa questão de
26:13
demorar para
26:14
SPEAKER_02: alterar,
26:15
SPEAKER_02: tem o custo de demorar mais para inovar.
26:18
SPEAKER_02: de demorar mais para estar no bleeding edge da coisa.
26:21
SPEAKER_02: O Django,
26:22
SPEAKER_02: por exemplo,
26:23
SPEAKER_02: só agora que eles estabilizaram o Channels,
26:25
que é um negócio que veio sendo usado um tempão para fazer a
26:28
parte de sync e tudo
26:30
SPEAKER_02: mais,
26:30
SPEAKER_02: demorou muito tempo.
26:31
SPEAKER_02: Então,
26:32
SPEAKER_02: se você pegar,
26:32
SPEAKER_02: por exemplo,
26:33
SPEAKER_02: há uns cinco anos,
26:34
SPEAKER_02: quando surgiu o FastAPI,
26:36
SPEAKER_02: deve ter até menos de cinco anos quando o FastAPI começou a ficar famoso,
26:40
ele começou a ser usado porque ele abraçou comunicação assim
26:43
que já é logo de cara.
26:45
SPEAKER_02: Então você olhava para o Django e falava,
26:46
SPEAKER_02: dá para fazer assim que no Django,
26:48
SPEAKER_02: mas não é daquele jeito,
26:49
SPEAKER_02: entendeu?
26:50
SPEAKER_02: Não parece nativo, é só agora.
26:52
SPEAKER_02: Então demora para essas coisas acontecerem.
26:54
SPEAKER_02: E eu estou vendo isso acontecer de novo com AI.
26:56
SPEAKER_02: Então hoje em dia,
26:58
SPEAKER_02: se você quiser desenvolver a gente para AI,
27:01
SPEAKER_02: se você quiser trabalhar com o MCP,
27:03
SPEAKER_02: com os outros protocolos novos aí da moda,
27:07
provavelmente,
27:08
se você está no meio Python,
27:09
você vai usar o FastAPI,
27:11
sabe?
27:11
SPEAKER_02: Que não é tão estável quanto o Django,
27:13
SPEAKER_02: provavelmente vai ter quebras aí de compatibilidade,
27:18
SPEAKER_02: mas ele está na crista da onda da inovação,
27:21
SPEAKER_02: entendeu?
27:21
SPEAKER_02: Na hora que essas empresas aí,
27:24
SPEAKER_02: essa indústria lançar um novo protocolo,
27:26
SPEAKER_02: você pode ter certeza que não vai dar dois dias,
27:28
SPEAKER_02: já vai ter um
27:29
SPEAKER_02: alguma coisa ali no FastAPI.
27:31
Enquanto no Django a gente vai esperar 3,
27:33
4,
27:34
5 anos para estar estabilizado.
27:35
SPEAKER_02: Então é mais que aquela janela de oportunidade para você aproveitar.
27:39
SPEAKER_02: Só que esse código que você gera com essas ferramentas mais modernas,
27:42
SPEAKER_02: ele não é um código feito para envelhecer.
27:44
SPEAKER_02: Essa que é a questão.
27:45
Então você quando investe em inovação desse nível,
27:48
você já tem que contar com esse custo.
27:50
SPEAKER_02: Você já tem que contar com
27:52
SPEAKER_02: Eu não estou fazendo isso aqui para durar 10 anos, entendeu?
27:55
Eu estou fazendo isso daqui para aproveitar a minha janela de
27:57
oportunidade agora e
27:59
SPEAKER_02: em algum momento eu vou pagar o débito técnico se ele vier.
28:01
SPEAKER_02: Pois é,
28:02
SPEAKER_02: eu ia te perguntar sobre isso também,
28:04
SPEAKER_02: sobre esse equilíbrio entre inovação e manutembilidade.
28:13
SPEAKER_02: Eu nem sei se essa palavra existe.
28:16
SPEAKER_02: Mas existe, né?
28:16
SPEAKER_02: Manutenibilidade.
28:18
SPEAKER_02: Manutenibilidade.
28:19
SPEAKER_02: Isso aí.
28:20
SPEAKER_02: Tipo,
28:20
SPEAKER_02: isso é uma parada que...
28:22
Escrever código que dura é uma preocupação que tem que ser só
28:26
de pessoas que fazem
28:28
SPEAKER_02: esses projetos open source que são usados por muitas empresas.
28:33
Ah,
28:33
desenvolver um plugin,
28:35
sei lá,
28:35
desenvolver uma SDK que muita gente está usando.
28:38
SPEAKER_02: Ou tu acha que isso é uma parada que qualquer deve fazer?
28:42
SPEAKER_02: Tipo,
28:42
Mesmo que trabalhe num produto que é muito inovador,
28:44
que muda o tempo todo.
28:45
SPEAKER_02: É, eu acho que qualquer dev tem que fazer, né?
28:49
SPEAKER_02: É aquela coisa, você tem que fazer o seu best forte, o seu melhor.
28:53
SPEAKER_02: E você vai sempre balancear isso com o conflito de interesse.
28:57
SPEAKER_02: A gente como dev,
28:58
SPEAKER_02: engenheiro,
28:59
SPEAKER_02: arquiteto,
29:00
SPEAKER_02: a gente está em constante conflito de interesse com o pessoal de produto,
29:05
SPEAKER_02: né?
29:05
SPEAKER_02: A gente costuma dizer, nós estamos juntos, o nosso objetivo é o mesmo...
29:09
SPEAKER_02: Mas vamos falar bem a verdade,
29:11
SPEAKER_02: a gente gosta de código bonito,
29:13
SPEAKER_02: a gente gosta de resolver problemas que são interessantes,
29:17
SPEAKER_02: a gente gosta de inventar coisas que vão dar orgulho para a gente depois.
29:21
SPEAKER_02: E o produto,
29:22
SPEAKER_02: por outro lado,
29:23
SPEAKER_02: ele está naquele push do tipo,
29:25
SPEAKER_02: olha,
29:25
SPEAKER_02: eu preciso entregar logo,
29:27
SPEAKER_02: eu preciso vender,
29:28
SPEAKER_02: eu preciso ter uma feature para apresentar lá no meu...
29:31
na próxima conferência que eu vou fazer para que eu consiga
29:34
fechar mais alguns contratinhos.
29:36
SPEAKER_02: Então a gente está nessa... Esse é o trabalho, na verdade.
29:39
SPEAKER_02: O trabalho é estar nessa fricção e fazer essas concessões,
29:43
SPEAKER_02: esses trade-offs e negociar com o produto e falar assim,
29:46
SPEAKER_02: olha,
29:47
SPEAKER_02: beleza,
29:47
SPEAKER_02: isso aqui eu vou abrir mão.
29:48
SPEAKER_02: Eu abro mão da gente fazer testes tier 1, 2 e 3.
29:52
SPEAKER_02: Vamos entregar o release só com o tier 1 de testes.
29:56
SPEAKER_02: Vamos fazer só uma... Tudo bem, disso eu abro mão.
29:58
SPEAKER_02: Tem coisas que os devs não vão abrir mão.
30:00
SPEAKER_02: Então assim,
30:01
SPEAKER_02: você tem que saber,
30:02
SPEAKER_02: é complicado porque é muito mais humano do que técnico,
30:04
SPEAKER_02: mas você tem que saber alinhar essas coisas.
30:06
Mas eu acho que ainda assim existe vantagem para quem é
30:09
desenvolvedor e também para
30:11
SPEAKER_02: quem é produto.
30:12
Se você colocar essas coisas de um jeito que vai trazer o
30:15
benefício do longo prazo
30:17
SPEAKER_02: e que fique bem comunicado do tipo,
30:19
SPEAKER_02: olha,
30:19
SPEAKER_02: se a gente seguir essas práticas agora,
30:23
SPEAKER_02: a gente vai evitar tais custos.
30:25
É mais fácil de você convencer quem está ali do lado do
30:28
produto,
30:29
dos stakeholders.
30:30
SPEAKER_02: Então é preciso ter esse data-driven.
30:32
SPEAKER_02: Mas eu acho que o dev mesmo, na prática, ele consegue fazer coisas.
30:35
SPEAKER_02: Por exemplo,
30:36
SPEAKER_02: uma coisa que eu acho que o dev consegue fazer,
30:38
SPEAKER_02: e eu sempre gosto de falar de sistemas polêmicos,
30:41
SPEAKER_02: porque eu estou há 15 ou mais anos ouvindo coisas desse tipo,
30:45
SPEAKER_02: e meio que se tornaram as leis do nosso faroeste chamado BolhaDev.
30:50
Por exemplo,
30:50
existe uma lei que diz assim,
30:52
você não deve comentar código.
30:53
SPEAKER_02: Acho que todo mundo já ouviu isso.
30:55
SPEAKER_02: Você coloca comentário no código,
30:57
SPEAKER_02: quase que a galera quer falar assim,
30:59
SPEAKER_02: sai daqui,
31:00
SPEAKER_02: tá muito errado,
31:02
SPEAKER_02: né?
31:02
E eu vejo que essa é uma daquelas coisas que o pessoal adotou
31:07
cegamente,
31:08
sabe?
31:08
SPEAKER_02: Sem pensar muito e não faz muito sentido, sabe?
31:11
SPEAKER_02: A gente tem o comentário de código,
31:14
SPEAKER_02: ele é uma ferramenta que se for bem usada,
31:16
SPEAKER_02: ele ajuda o código a envelhecer bem.
31:18
SPEAKER_02: Sim, sabe?
31:19
Não dá pra gente simplesmente olhar como uma coisa simples e
31:22
tenha todas as nuances aí,
31:24
né?
31:25
Tipo aquela coisa do Júnior que comenta num um mais um,
31:29
ele comenta está somando um mais um?
31:32
SPEAKER_02: Claro que existe esse cenário, né?
31:33
SPEAKER_02: Da ingenuidade, né?
31:35
SPEAKER_02: Mas eu acho que a gente não deve levar...
31:37
SPEAKER_02: esse tipo de coisa como regra,
31:39
SPEAKER_02: principalmente hoje em dia,
31:40
SPEAKER_02: que a gente está usando mais AI,
31:41
SPEAKER_02: mais agentes,
31:42
SPEAKER_02: mais automação em cima de código,
31:44
SPEAKER_02: você transformar o código em algo que possa ser lido mais facilmente,
31:49
SPEAKER_02: ajuda ele a envelhecer muito bem.
31:50
SPEAKER_02: Então,
31:51
SPEAKER_02: eu tenho hoje um pensamento em que ele ainda não está 100% formado,
31:57
SPEAKER_02: mas eu tenho visto,
31:58
SPEAKER_02: eu tenho lido muita coisa,
31:59
SPEAKER_02: inclusive do pessoal mais famoso aí,
32:01
SPEAKER_02: que são os nossos filósofos devs,
32:03
SPEAKER_02: tipo o
32:04
SPEAKER_02: o Uncle Bob, etc.
32:06
SPEAKER_02: Eu tenho visto até esses caras falarem coisas nesse sentido,
32:09
SPEAKER_02: que é,
32:09
SPEAKER_02: por exemplo,
32:10
SPEAKER_02: quanto mais documentação o software tem,
32:12
SPEAKER_02: talvez pior seja.
32:14
SPEAKER_02: E quando eu falo documentação,
32:16
é aquela documentação clássica em que você tem um lugar
32:19
separado do código para
32:20
SPEAKER_02: você ir consultar o que o código faz.
32:22
SPEAKER_02: Então,
32:23
SPEAKER_02: meio que é um antepadrão que a gente meio que adotou,
32:25
SPEAKER_02: talvez para deixar a responsabilidade de documentar para depois.
32:28
SPEAKER_02: Mas eu vejo que,
32:29
SPEAKER_02: visto que o melhor código que eu tenho visto,
32:32
SPEAKER_02: que eu tenho passado na minha carreira nesses anos,
32:35
SPEAKER_02: é aquele código que eu não preciso ir para outro lugar para entender ele.
32:38
SPEAKER_02: O contexto dele está no próprio código.
32:40
SPEAKER_02: Então, a documentação é o código.
32:42
Se o código em si não é expressivo o suficiente para você ler
32:46
uma expressão daquela
32:48
SPEAKER_02: linguagem e saber o que ela está fazendo...
32:50
SPEAKER_02: Beleza, toda linguagem tem comentário.
32:53
SPEAKER_02: Então você coloca ali quatro,
32:55
SPEAKER_02: cinco,
32:55
SPEAKER_02: seis linhas de comentário bem feito,
32:57
SPEAKER_02: bem estruturado,
32:58
porque a gente passa uma carreira inteira aprendendo como
33:00
escrever sintaxe da
33:01
SPEAKER_02: linguagem muito bem escrita,
33:03
SPEAKER_02: como passar dos linters até espaçamento.
33:08
SPEAKER_02: Tudo isso a gente leva numa boa.
33:10
SPEAKER_02: Agora,
33:10
SPEAKER_02: quando vem a questão vamos escrever comentários bem escritos,
33:14
SPEAKER_02: é sempre uma questão que pega muita gente,
33:16
SPEAKER_02: né?
33:17
SPEAKER_02: E aquela coisa,
33:17
SPEAKER_02: se você estruturar bem o comentário,
33:19
SPEAKER_02: o comentário ele vive junto com o código,
33:21
SPEAKER_02: ele evolui junto com o código,
33:23
SPEAKER_02: ele explica o código e ajuda a gente a entender o futuro.
33:26
SPEAKER_02: Então eu vou dizer que parece uma coisa simples,
33:29
mas foram muitas vezes que eu peguei código alheio de oito anos
33:33
atrás e que olhando
33:34
SPEAKER_02: para aquilo ali eu olhava e falava assim,
33:36
SPEAKER_02: eu não tenho a menor ideia do que esse negócio está fazendo.
33:39
SPEAKER_02: Vamos achar algum comentário, alguma mensagem de comite.
33:42
SPEAKER_02: Se tivesse colocado...
33:43
SPEAKER_02: Daí tu vai ver o comentário é não toque,
33:45
SPEAKER_02: isso funciona,
33:46
SPEAKER_02: eu não sei porquê.
33:49
SPEAKER_02: Olha, acontece, né?
33:51
SPEAKER_02: Mas eu acho que essa coisa da gente evitar o comentário vem disso, né?
33:54
Que eu não sei a verdade de onde surgiu,
33:57
mas tem anos que eu escuto essa coisa.
33:58
SPEAKER_02: Não é do Código Limpo também?
34:00
SPEAKER_02: Não é do Clean Code isso?
34:01
SPEAKER_02: Eu acho que o Código Limpo
34:03
SPEAKER_02: ele foi mal interpretado nesse ponto.
34:05
Porque eu acho que talvez o que o código limpo queira dizer é
34:07
exatamente isso que
34:08
SPEAKER_02: eu falei de outro jeito.
34:10
SPEAKER_02: Que é assim,
34:11
você deve escrever o seu código de um jeito tão expressivo que
34:15
você não precise do
34:16
SPEAKER_02: comentário.
34:17
SPEAKER_02: Entendi.
34:17
SPEAKER_02: Então,
34:18
SPEAKER_02: por exemplo,
34:18
SPEAKER_02: ao invés de eu ter uma variável chamada EC,
34:21
SPEAKER_02: eu chamo aquela variável de Enabled Components.
34:24
SPEAKER_02: Aí eu não preciso botar um comentário dizendo o que significa esse.
34:27
SPEAKER_02: Então você usar a nomenclatura que tenha significado.
34:30
SPEAKER_02: Mas ele não quis dizer não use comentário.
34:33
SPEAKER_02: Não quis dizer não use comentário, exatamente.
34:35
SPEAKER_02: Aquela coisa do tipo,
34:36
SPEAKER_02: ao invés de você ter números mágicos no meio do seu código,
34:39
SPEAKER_02: você abrir o código e tem lá uns 54,
34:41
SPEAKER_02: você criar lá uma constante chamada refresh interval.
34:46
SPEAKER_02: Então o próprio código se auto...
34:49
SPEAKER_02: documenta,
34:49
eu acho que é isso que ele quis dizer mas o pessoal entendeu do
34:52
tipo assim sai
34:53
SPEAKER_02: codando,
34:54
passa pelos linters e nunca coloque comentário e aí a gente
34:57
chegou nesse nível de
34:59
SPEAKER_02: ver uns códigos muito loucos,
35:00
SPEAKER_02: muito malucos que não dá pra entender,
35:02
mas eu acho que esse é um dos pontos que eu acho que vale a
35:04
pena e eu acho que eu
35:06
SPEAKER_02: poderia traduzir em assim,
35:08
SPEAKER_02: o código tem que se explicar sozinho
35:11
porque ele é mais lido do que escrito e hoje em dia inclusive
35:16
ele é lido até por
35:17
não humanos então os não humanos também vão utilizar esses
35:22
contextos para entregar
35:24
valor então acho que esse é um ponto para fazer o código que
35:28
vive mesmo que o
35:29
SPEAKER_02: código seja uma porcaria
35:30
SPEAKER_02: Se o comentário explicar o porquê que ele é uma porcaria,
35:32
SPEAKER_02: numa segunda leva de refaturação,
35:35
SPEAKER_02: talvez quem tiver mais afim,
35:38
SPEAKER_02: mais motivado ou mais experiente naquele momento vai falar,
35:41
SPEAKER_02: ah não,
35:41
SPEAKER_02: isso aqui eu sei resolver,
35:42
SPEAKER_02: né?
35:42
SPEAKER_02: Então acho que é um dos pontos aí que dá pra gente desmistificar, né?
35:47
SPEAKER_02: Eu acho que todo dev pode fazer isso, né?
35:48
Independente do tamanho do sistema,
35:51
não é um negócio que tem um custo,
35:52
né?
35:52
SPEAKER_02: Não é um negócio assim,
35:53
SPEAKER_02: você não vai atrasar seu sprint,
35:55
SPEAKER_02: porque você vai colocar comentário e documentação e melhorar como que tá
35:58
SPEAKER_02: organizadas constantes do seu código,
36:01
SPEAKER_02: né?
36:03
SPEAKER_01: You've got mail.
36:29
SPEAKER_01: Qual a relação entre a transportadora e a farinha?
36:31
SPEAKER_01: Ele, não, não, é porque a gente usava SVN na empresa.
36:34
SPEAKER_01: E a gente tinha uma estrutura que criava o banco, a estrutura sozinha.
36:37
SPEAKER_01: E a gente sempre usava isso como boilerplate pra todos os projetos.
36:40
SPEAKER_01: Então todos os projetos daquela firma tinham um negócio de padaria.
36:43
SPEAKER_01: E eles faziam isso por quê?
36:44
SPEAKER_01: Porque eles não sabiam recriar a estrutura e funcionava.
36:47
SPEAKER_01: E aí isso ia pra todo mundo, sabe?
36:49
SPEAKER_01: Mas...
36:50
SPEAKER_01: essa aleatoriedade passa.
36:51
SPEAKER_01: O que eu ia perguntar também é o seguinte,
36:53
SPEAKER_01: quando a gente olha pela questão de...
36:55
SPEAKER_01: A gente está falando muito aqui sobre código que sobreviva ao tempo,
36:58
SPEAKER_01: né?
36:59
E a gente poder fazer manutenção dele ao longo do tempo,
37:01
que significa que ele envelheça bem.
37:03
SPEAKER_01: Mas isso não é uma preocupação que todo mundo tem que ter, né?
37:06
SPEAKER_01: Eu digo,
37:07
SPEAKER_01: estou começando um projetinho agora,
37:09
SPEAKER_01: vou querer testar,
37:10
SPEAKER_01: fazer um microsasco que todo deve,
37:11
SPEAKER_01: quer fazer agora.
37:12
SPEAKER_01: Eu não necessariamente preciso me preocupar que ele envelheça bem, né?
37:15
Se eu tomar alguns pequenos cuidados que a gente vai falar de
37:17
deixar uma estrutura
37:18
SPEAKER_01: ok,
37:18
SPEAKER_01: eu não preciso ficar pensando,
37:20
SPEAKER_01: meu,
37:20
SPEAKER_01: será que essa estrutura,
37:21
SPEAKER_01: essa arquitetura,
37:22
SPEAKER_01: ela vai resistir por 15 anos?
37:24
SPEAKER_01: Talvez o teu produto não dure esse tempo todo, né?
37:26
SPEAKER_02: Ah, sim, com certeza.
37:27
SPEAKER_02: E essa paralisia por análise, né?
37:30
SPEAKER_02: Análise, parálise.
37:31
Eu já passei muitas vezes que é aquela coisa de tanto ficar
37:34
querendo fazer o
37:35
SPEAKER_02: projeto ficar bom,
37:36
SPEAKER_02: ele não ficou pronto.
37:38
SPEAKER_02: Eu,
37:38
SPEAKER_02: em 2012,
37:41
SPEAKER_02: eu decidi iniciar um projeto open source,
37:43
SPEAKER_02: investir não só tempo,
37:44
SPEAKER_02: mas dinheiro também naquilo,
37:46
SPEAKER_02: né?
37:46
SPEAKER_02: E o meu objetivo não era nada ambicioso, né?
37:50
SPEAKER_02: Eu queria recriar o WordPress em Python.
37:52
SPEAKER_02: E, assim, eu fiz, né?
37:55
SPEAKER_02: Se você acessar hoje, tá lá no GitHub, lá chama Coca, né?
37:58
SPEAKER_02: Coca, que é um bichinho lá da Austrália, Coca Project.
38:00
SPEAKER_02: Tem lá o projeto, tá feito todo em Python.
38:03
E ele chegou num ponto onde muita gente usando,
38:06
empresas grandes utilizando e tudo mais.
38:08
Só que eu fiquei paralisado justamente nessa questão de que eu
38:13
nunca estava satisfeito.
38:14
Eu queria que ficasse melhor,
38:16
eu queria que tivesse 100% de cobertura de teste.
38:18
Eu queria que fosse extremamente genérico a ponto de eu poder
38:23
tratar qualquer tipo
38:24
de conteúdo vindo de qualquer lugar e que não tivesse conflitos
38:28
e que fosse
38:28
SPEAKER_02: perfeito.
38:29
Até o ponto que aquilo virou um burnout na minha vida e eu não
38:32
quis mais olhar para
38:33
SPEAKER_02: aquilo,
38:33
SPEAKER_02: entendeu?
38:34
SPEAKER_02: É claro que nesse caso era um projeto pessoal,
38:36
um projeto que era eu e eu que me importava com aquilo e os
38:39
usuários daquele
38:40
SPEAKER_02: momento.
38:41
Mas se você fizer isso que nem você falou no microsize,
38:43
você vai correr o mesmo risco.
38:45
Você vai correr o risco de começar e não conseguir terminar ele
38:48
por conta dessa
38:49
SPEAKER_02: necessidade de encontrar a perfeição.
38:51
Então acho que nem todo mundo deve se preocupar com isso num
38:54
primeiro momento,
38:55
né?
38:55
SPEAKER_02: Eu gosto de uma frase que o criador do C++,
38:58
SPEAKER_02: se eu não me engano,
38:59
SPEAKER_02: eu não sei falar o nome dele,
39:00
SPEAKER_02: acho que é Bjorn Sterop,
39:02
SPEAKER_02: é uma coisa assim o nome dele,
39:04
SPEAKER_02: mas ele tem uma frase que é assim,
39:05
SPEAKER_02: make it work,
39:07
SPEAKER_02: make it right,
39:08
SPEAKER_02: make it fast.
39:09
SPEAKER_02: Então são três fases para desenvolver software.
39:11
SPEAKER_02: Então a primeira é faz funcionar.
39:13
SPEAKER_02: Basicamente é,
39:15
SPEAKER_02: não importa muito qual padrão que você está usando,
39:17
SPEAKER_02: qual linguagem,
39:18
SPEAKER_02: qual biblioteca,
39:19
SPEAKER_02: você tem um objetivo que você quer entregar,
39:22
SPEAKER_02: né?
39:22
SPEAKER_02: Então faz ele funcionar, né?
39:23
SPEAKER_02: Então faz...
39:24
SPEAKER_02: No segundo ponto,
39:25
SPEAKER_02: você vai olhar para aquilo e vai falar assim,
39:27
SPEAKER_02: tá uma porcaria,
39:28
SPEAKER_02: vamos fazer corretamente.
39:29
SPEAKER_02: E aí você tem sempre a chance, né?
39:31
SPEAKER_02: Quando você escreve código, não tá escrito na pedra, né?
39:34
SPEAKER_02: Tipo, a compilação é só depois, né?
39:36
SPEAKER_02: Você sempre tem a chance de recompilar.
39:38
SPEAKER_02: Então vamos agora modularizar,
39:40
SPEAKER_02: vamos recopiar umas funções para colocar nos módulos mais bonitinhos...
39:44
SPEAKER_02: Vamos colocar uma arquitetura de plugin aqui onde precisa.
39:47
SPEAKER_02: Beleza, fez correto?
39:48
SPEAKER_02: Provavelmente vai estar lento, né?
39:50
Vai estar uma carroça porque você fez as piores decisões e
39:54
escolheu as piores integrações.
39:55
SPEAKER_02: Então agora vamos pensar em fazer ele ficar rápido.
39:57
SPEAKER_02: Mas pelo menos se você desistir em um desses três níveis de preocupação,
40:02
SPEAKER_02: você já tem a coisa funcionando e entregando,
40:05
SPEAKER_02: né?
40:05
SPEAKER_02: Então você não corre o risco de perder o time to market, né?
40:08
SPEAKER_02: Então,
40:08
SPEAKER_02: eu acho que vale a pena seguir essa filosofia,
40:11
SPEAKER_02: principalmente quando o projeto é um projeto de CEO sozinho,
40:15
SPEAKER_02: né?
40:15
SPEAKER_02: E tu comentou sobre isso, né?
40:17
SPEAKER_02: Deves quererem um código perfeito, tu mesmo falou que teve esse problema.
40:21
SPEAKER_02: Tipo, a diferença entre refatorar e reescrever do zero.
40:25
SPEAKER_02: Tu acha que tem um manual, assim, de quando fazer um ou outro?
40:30
SPEAKER_02: Ou é melhor só deixar lá e...
40:32
SPEAKER_02: Tá tudo bem?
40:33
SPEAKER_02: Cara,
40:33
SPEAKER_02: eu acho que assim,
40:35
SPEAKER_02: um dos grandes problemas que eu vi e que foi parte de autoanálise minha,
40:39
SPEAKER_02: que eu passei por isso várias vezes,
40:41
SPEAKER_02: é o fato da gente se apegar a código como se ele fosse arte.
40:45
SPEAKER_02: Isso acontece muito com o Dev, sabe?
40:47
SPEAKER_02: É aquela coisa,
40:48
SPEAKER_02: eu escrevi aqui umas classes,
40:50
SPEAKER_02: uns módulos,
40:52
um negócio muito legal que funciona muito bem e eu não quero
40:55
jogar isso fora.
40:56
SPEAKER_02: E eu passei muito por isso, né?
40:58
SPEAKER_02: Eu acho que tem muita gente que passa por isso.
40:59
SPEAKER_02: Então,
41:00
SPEAKER_02: acho que assim,
41:00
SPEAKER_02: uma das primeiras características que a gente tem que adquirir é esse
41:03
SPEAKER_02: desprendimento,
41:04
SPEAKER_02: sabe?
41:05
SPEAKER_02: Essa facilidade de deletar código sem dó, entendeu?
41:08
SPEAKER_02: Porque assim, se você já escreveu uma vez...
41:10
E eu tô falando de um mundo onde a gente nem tinha AI ainda pra
41:13
reescrever,
41:14
né?
41:15
SPEAKER_02: Hoje ainda você pode deletar e pedir pra AI refazer pra você.
41:18
SPEAKER_02: Mas eu ainda tô com o meu pensamento em uma época onde,
41:20
SPEAKER_02: assim,
41:20
SPEAKER_02: se eu fiz uma vez,
41:21
SPEAKER_02: eu sou capaz de fazer de novo e talvez melhor,
41:24
SPEAKER_02: né?
41:24
SPEAKER_02: Mesmo que eu não tenha exatamente aquele,
41:27
SPEAKER_02: lembre exatamente de como foi a ordem que eu fiz as coisas,
41:30
SPEAKER_02: a probabilidade de eu fazer melhor vai ser grande.
41:32
SPEAKER_02: Então,
41:33
SPEAKER_02: eu sei que é sofrido,
41:34
SPEAKER_02: eu sofri pra conseguir adquirir essa habilidade,
41:38
SPEAKER_02: mas hoje eu deleto o código sem dó nenhuma.
41:40
SPEAKER_02: sabe, tipo, vamos fazer de novo, isso aqui tá ruim?
41:43
SPEAKER_02: Tá lento?
41:44
SPEAKER_02: Beleza, o que que é mais importante?
41:46
SPEAKER_02: Ser rápido?
41:47
SPEAKER_02: Então beleza,
41:47
SPEAKER_02: então vamos começar de novo,
41:49
SPEAKER_02: vai lá,
41:49
SPEAKER_02: define de novo a função,
41:50
SPEAKER_02: objeto,
41:51
SPEAKER_02: módulo e começa a fazer,
41:52
SPEAKER_02: né,
41:53
SPEAKER_02: e aí você usa o antigo como referência pra você olhar,
41:56
SPEAKER_02: pra você copiar coisa,
41:57
SPEAKER_02: mas reescrever o código eu acho que não é um
42:00
uma coisa muito...
42:01
não é um negócio que deveria ser levado tão a sério,
42:05
entendeu?
42:05
SPEAKER_02: Porque se for parar pra pensar, esse é o nosso trabalho, né?
42:08
SPEAKER_02: Escrever código é o nosso trabalho.
42:09
SPEAKER_02: A gente tem evitado, né?
42:12
SPEAKER_02: Evitar, tipo, reescrever, mas é a parte do que a gente tem que fazer.
42:16
SPEAKER_02: Então, eu hoje sou mais assim do tipo, vamos refazer do zero, né?
42:21
SPEAKER_02: Vamos botando as linhas de código de novo,
42:22
SPEAKER_02: ela vai ajudar a gente a reorganizar os pensamentos,
42:25
SPEAKER_02: né?
42:25
SPEAKER_02: Agora, existem casos onde você não tem tempo para fazer isso.
42:29
SPEAKER_02: Aí que vem o problema.
42:31
Você não tem tempo ou você não tem...
42:34
Não deixam você simplesmente fazer,
42:36
se for numa empresa.
42:37
SPEAKER_02: Se você chegar numa empresa grande,
42:39
SPEAKER_02: que tem todo um processo de aprovação,
42:41
SPEAKER_02: e você simplesmente falar,
42:43
SPEAKER_02: olha,
42:43
SPEAKER_02: tal componente está muito lento,
42:45
SPEAKER_02: eu quero reescrever do zero.
42:46
SPEAKER_02: Complicado, né?
42:47
Muito trauma que você vai acabar gerando ali o pessoal lembrar
42:52
de problemas assim.
42:53
SPEAKER_02: Então...
42:53
É necessário você também conseguir lapidar código existente e
42:57
nesse ponto tem o
42:59
SPEAKER_02: código existente,
43:00
SPEAKER_02: o código legado,
43:01
SPEAKER_02: vamos dizer assim.
43:02
SPEAKER_02: Se ele não for modular,
43:04
SPEAKER_02: aquela coisa que você consegue substituir pequenas partes dele,
43:07
SPEAKER_02: então você sabe que tem lá umas funções,
43:09
SPEAKER_02: eu vou trocar só aquelas funções e vamos ver se melhora.
43:12
SPEAKER_02: Se o código for tão alinhado que você não consegue fazer isso,
43:15
SPEAKER_02: eu acho que você já tem a sua próxima tarefa,
43:18
SPEAKER_02: que é transformar aquele código em um código modular,
43:20
SPEAKER_02: porque não tem outro jeito de refatorar.
43:23
SPEAKER_02: sabe,
43:23
SPEAKER_02: refatorar,
43:24
SPEAKER_02: pegar aquele arquivo de 50 mil linhas e sair reescrevendo ele,
43:27
SPEAKER_02: é loucura,
43:28
SPEAKER_02: é loucura,
43:29
SPEAKER_02: é ficar entrando num loop ali,
43:32
SPEAKER_02: no rabbit hole ali,
43:33
SPEAKER_02: você nunca vai sair daquilo,
43:35
SPEAKER_02: então é aquela coisa,
43:36
SPEAKER_02: tenho que refatorar legado,
43:37
SPEAKER_02: primeira coisa,
43:38
SPEAKER_02: como acoplado ele é?
43:39
SPEAKER_02: o quão modularizado ele está.
43:41
SPEAKER_02: Então, a primeira tarefa é essa.
43:43
Vamos tentar fazer com que eu consiga tirar e colocar coisas
43:46
aqui para eu testar,
43:47
SPEAKER_02: para eu poder comparar.
43:48
SPEAKER_02: Eu consegui alterar componentes.
43:51
SPEAKER_02: É muito amplo,
43:52
SPEAKER_02: é difícil de falar,
43:52
SPEAKER_02: mas para ficar num esquema mais tangível,
43:55
SPEAKER_02: é aquela velha história de você ter um código lá cheio de funções...
43:59
SPEAKER_02: E você simplesmente fala assim,
44:00
essa função aqui eu vou comentar ela e eu vou escrever outra
44:03
implementação dela que
44:04
SPEAKER_02: vai fazer talvez não tudo que ela faz,
44:06
SPEAKER_02: mas vai fazer mais simples e vamos ver se resolve o gargalo.
44:09
SPEAKER_02: Conseguir isolar os problemas é o que faz você saber o que refatorar.
44:14
SPEAKER_02: E se não tiver desse jeito, nem dá para começar, na minha opinião.
44:17
SPEAKER_01: Já tentei.
44:19
Normalmente o código que ninguém quer mexer é porque ninguém
44:21
sabe por onde começar,
44:22
SPEAKER_01: porque ele tá tão ruim que o cara não quer nem começar.
44:26
SPEAKER_02: Às vezes você nem sabe nem aonde colocar os debuggins, né?
44:29
SPEAKER_02: Você não sabe onde pôr os breakpoints,
44:30
você não sabe onde colocar os prints porque você não sabe o que
44:32
tá acontecendo.
44:33
então modularizar o código é o primeiro passo então eu acho que
44:38
também é mais uma
44:38
coisa que qualquer dev consegue fazer na hora que está
44:40
escrevendo tipo assim não
44:42
vai alterar em nada o custo do seu software não vai alterar em
44:45
nada o tempo que
44:46
você demora para desenvolver se ao invés de você fazer aquela
44:49
função gigante
44:50
SPEAKER_02: Você partir para aplicar os princípios do Solid aí e criar funções com
44:55
SPEAKER_02: responsabilidade única,
44:57
SPEAKER_02: você criar contextos que possam ser substituíveis facilmente.
45:02
SPEAKER_02: Então, esse tipo de padrão, eu acho que vale a pena desde o começo.
45:06
SPEAKER_02: Por mais que seja uma aplicação simples hoje em dia, sabe?
45:09
SPEAKER_02: Já é bem definido e não traz custo, sabe?
45:12
SPEAKER_02: Não é uma coisa que fala assim,
45:13
SPEAKER_02: olha,
45:13
SPEAKER_02: se eu seguir isso daqui,
45:15
SPEAKER_02: eu vou estar impedindo o meu projeto de ser entregue em cinco dias.
45:19
SPEAKER_02: Não muda nada.
45:20
SPEAKER_02: Você,
45:21
SPEAKER_02: sabe,
45:22
SPEAKER_02: aquela coisa assim,
45:22
SPEAKER_02: eu criar três,
45:23
SPEAKER_02: quatro funções não é o que vai atrasar a minha sprint,
45:26
SPEAKER_02: sabe?
45:26
SPEAKER_02: Ah, eu vou colocar tudo no arquivo só porque aí eu entrego mais rápido.
45:30
SPEAKER_02: Não, não existe, sabe?
45:31
SPEAKER_02: Criar arquivos hoje em dia não tem custo, então... Ainda não tem custo.
45:37
SPEAKER_02: Ainda não tem custo, né?
45:41
SPEAKER_02: Pra gente ir encerrando,
45:43
SPEAKER_02: então,
45:43
SPEAKER_02: eu não sei se tu quer deixar dicas,
45:46
SPEAKER_02: livros,
45:47
SPEAKER_02: enfim,
45:48
SPEAKER_02: cursos,
45:49
SPEAKER_02: canais do YouTube pra acompanhar,
45:52
SPEAKER_02: pra quem quer escrever códigos mais duradouros,
45:55
SPEAKER_02: quer aprender mais sobre isso.
45:57
SPEAKER_02: Olha,
45:57
SPEAKER_02: não sei se eu sou muito bom para dar essas dicas,
45:59
porque eu costumo ver o pessoal dar muitas referências
46:03
científicas no assunto.
46:04
SPEAKER_02: Então,
46:04
SPEAKER_02: poderia vir aqui e falar dos livros de Design Pattern,
46:07
SPEAKER_02: Docking Code,
46:08
SPEAKER_02: Domain Driven Design,
46:10
SPEAKER_02: todas essas coisas.
46:11
SPEAKER_02: Só que eu vou te falar bem o que eu acredito hoje.
46:13
SPEAKER_02: Eu acredito que todo esse material,
46:15
SPEAKER_02: toda essa literatura,
46:17
SPEAKER_02: ela tem um valor gigante para te trazer material,
46:20
SPEAKER_02: para te trazer vocabulário,
46:22
SPEAKER_02: para te trazer contexto.
46:24
SPEAKER_02: Só que eu vejo com olhos muito ruins hoje,
46:28
porque eu passei por isso e eu já fui uma das pessoas que
46:31
ficava apegada a essas
46:33
SPEAKER_02: coisas de filosofia,
46:34
SPEAKER_02: de programação.
46:35
SPEAKER_02: Então,
46:36
SPEAKER_02: ficar apegado a uma filosofia,
46:37
SPEAKER_02: a um padrão,
46:38
SPEAKER_02: a um autor,
46:39
SPEAKER_02: eu acho que isso é um negócio que não ajuda.
46:41
SPEAKER_02: O que ajuda é você destrinchar aquilo e trazer aquilo para a prática.
46:45
SPEAKER_02: E a minha opinião é que só tem um jeito de você saber fazer,
46:49
SPEAKER_02: por exemplo,
46:50
SPEAKER_02: refatoração de código legado.
46:52
SPEAKER_02: Que é fazendo refatoração de código legado, entendeu?
46:55
Só tem um jeito de você fazer código que vai durar muito e que
47:00
tenha tudo isso que
47:01
SPEAKER_02: a gente falou,
47:01
SPEAKER_02: que é sustentabilidade,
47:03
SPEAKER_02: ser muito bem composto,
47:04
SPEAKER_02: que é você passar pela experiência...
47:06
SPEAKER_02: de fazer o errado.
47:07
SPEAKER_02: Então,
47:08
se você passa pela experiência de fazer um software que ele é
47:11
tão acoplado a ponto
47:13
SPEAKER_02: de você sentir a dor de,
47:14
SPEAKER_02: olha,
47:14
SPEAKER_02: agora eu queria trocar tal componente e eu não posso.
47:17
SPEAKER_02: Então,
47:18
SPEAKER_02: isso te traz,
47:19
SPEAKER_02: se você,
47:19
SPEAKER_02: é claro que só isso por si só não ajuda,
47:21
SPEAKER_02: mas se isso acontecer com você na sua carreira ou num projeto pessoal,
47:25
SPEAKER_02: numa empresa,
47:26
SPEAKER_02: e você conseguir usar isso,
47:27
SPEAKER_02: né,
47:28
SPEAKER_02: pra te gerar essa reflexão,
47:30
isso é o que vai fazer com que na próxima vez você consiga
47:33
saber o que evitar,
47:34
SPEAKER_02: né.
47:34
SPEAKER_02: Você saber qual caminho diferente ir.
47:37
SPEAKER_02: Então não tem atalho, eu acho.
47:39
SPEAKER_02: Eu acho que eu tento,
47:41
eu dou aulas e durante as minhas aulas eu tenho uma
47:45
característica que muita gente
47:46
SPEAKER_02: gosta.
47:47
Felizmente a maioria gosta,
47:49
mas tem uma parcela que não aceita muito bem,
47:51
que é o seguinte.
47:52
SPEAKER_02: Eu gosto de solução ruim nas minhas aulas.
47:55
SPEAKER_02: Então se você fizer meu curso de Python,
47:57
SPEAKER_02: por exemplo,
47:58
SPEAKER_02: a gente faz coisas lá que parecem não ter sentido nenhum.
48:01
a gente começa recriando o nosso framework do zero,
48:04
desde a primeira linha.
48:05
SPEAKER_02: Vamos recriar um framework ao invés de usar os que já existem.
48:08
SPEAKER_02: E aí,
48:08
SPEAKER_02: a hora que a gente termina esse experimento,
48:10
SPEAKER_02: eu começo a falar para os alunos assim,
48:12
SPEAKER_02: ó,
48:12
SPEAKER_02: tá vendo isso aqui que a gente fez?
48:13
SPEAKER_02: É uma porcaria.
48:14
SPEAKER_02: Isso aqui não escala por isso, por isso, por aquilo.
48:17
SPEAKER_02: Tá vendo isso aqui que a gente fez pra ler variáveis de ambiente?
48:20
SPEAKER_02: É uma porcaria,
48:20
SPEAKER_02: tem brecha de segurança aqui,
48:21
SPEAKER_02: ó.
48:22
SPEAKER_02: Você vai tá abrindo o seu sistema pra quem tá atacando.
48:24
SPEAKER_02: Então, é meio que um balde de água fria, sabe?
48:27
SPEAKER_02: Depois da primeira semana da pessoa que tá ali estudando e aprendendo,
48:30
SPEAKER_02: ela falou,
48:30
SPEAKER_02: nossa,
48:31
SPEAKER_02: fiz o meu framework do zero.
48:32
SPEAKER_02: E aí você vem e fala assim,
48:33
SPEAKER_02: olha,
48:34
eu acho que é muito importante você passar por esse sofrimento
48:37
que parece mágico,
48:38
SPEAKER_02: que parece lindo de você fazer as coisas do zero,
48:40
SPEAKER_02: mas tudo isso tem isso,
48:42
SPEAKER_02: isso,
48:42
SPEAKER_02: isso e isso de ruim.
48:43
SPEAKER_02: É por isso que você vai escolher usar o Django.
48:45
SPEAKER_02: É por isso que você vai escolher usar o FastAPI.
48:47
SPEAKER_02: Entendeu?
48:48
SPEAKER_02: Porque esses problemas já estão resolvidos.
48:51
SPEAKER_02: Então você abre uma... Você já responde uma questão aí, né?
48:54
Do tipo assim...
48:54
Se é tão fácil fazer uma coisa do zero,
48:56
por que eu não faço?
48:57
SPEAKER_02: Porque o fácil...
48:59
SPEAKER_02: Ele é só virtual, né?
49:00
SPEAKER_02: Só uma coisa que a gente... Esses detalhes é que são complexos.
49:03
SPEAKER_02: Só que assim,
49:04
SPEAKER_02: se você não passa por esse problema,
49:07
SPEAKER_02: se você não passa pela dor de cabeça que é criar algo,
49:11
SPEAKER_02: ou não só criar,
49:12
SPEAKER_02: mas lidar com algo que não está bem arquitetado,
49:16
SPEAKER_02: é muito difícil você conseguir inovar nesse sentido,
49:20
SPEAKER_02: né?
49:20
SPEAKER_02: Você conseguir ser criativo para achar soluções.
49:22
SPEAKER_02: E aí nesse ponto,
49:23
SPEAKER_02: é claro que você pode pensar,
49:24
SPEAKER_02: mas nem todo mundo vai conseguir ter a possibilidade de ter esse tipo de
49:28
SPEAKER_02: experiência,
49:28
SPEAKER_02: é claro.
49:29
SPEAKER_02: Mas aí é aquela coisa,
49:30
a gente tem que se basear nas experiências que já existem e é
49:34
por isso que existem
49:35
SPEAKER_02: esses padrões.
49:36
SPEAKER_02: Solid vem disso,
49:37
SPEAKER_02: vem de pessoas que sofreram com softwares que não eram,
49:40
SPEAKER_02: não permitiam ser componíveis.
49:43
SPEAKER_02: Então vamos lá,
49:43
SPEAKER_02: vamos criar o conceito de single responsibility,
49:47
SPEAKER_02: substituição e tudo mais para que agora o software possa ser composto.
49:51
SPEAKER_02: O clean code
49:53
vem da experiência de você ver código que é difícil de ler,
49:56
que é difícil de entender.
49:58
SPEAKER_02: Então, usar um pouco de tudo isso e fazer aquela coisa, fazer coisas.
50:03
Fazer coisas que são,
50:04
em primeira instância,
50:05
inúteis,
50:06
mas que te trazem essa bagagem aí.
50:09
Então,
50:10
eu acho que essa é a única coisa que eu posso...
50:12
Não é um livro,
50:13
sabe?
50:14
SPEAKER_02: Não é um... É a vida.
50:16
SPEAKER_02: É, e...
50:18
Não é só a vida,
50:18
é tipo assim,
50:19
colocar a mão no código e fazer as coisas,
50:22
entendeu?
50:23
SPEAKER_02: Mesmo que elas sejam ruins.
50:24
SPEAKER_02: Quanto mais código ruim você faz,
50:26
SPEAKER_02: mais você melhora o código que você,
50:29
SPEAKER_02: a próxima vez que você fizer.
50:30
SPEAKER_02: Então,
50:30
SPEAKER_02: eu acho que essa,
50:31
a gente tem uma certa banalização na nossa indústria da palavra
50:35
experiência,
50:36
SPEAKER_02: né?
50:36
SPEAKER_02: Você fala assim,
50:37
SPEAKER_02: olha,
50:37
SPEAKER_02: eu trabalho com programação tem,
50:39
SPEAKER_02: sei lá,
50:40
SPEAKER_02: oito anos,
50:40
SPEAKER_02: eu sou um dev experiente.
50:42
SPEAKER_02: Mas não necessariamente o tempo se traduz em experiência, né?
50:45
SPEAKER_02: Tipo assim,
50:46
SPEAKER_02: é muito claro que a experiência depende disso,
50:50
SPEAKER_02: depende desse transtorno que você viveu,
50:53
SPEAKER_02: né?
50:53
SPEAKER_02: Desse incômodo, né?
50:56
De você estar desconfortável com alguma coisa pra adquirir a
50:59
experiência com aquilo,
51:01
né?
51:01
SPEAKER_02: Então...
51:02
SPEAKER_02: Basicamente é isso.
51:03
SPEAKER_02: Não tenha medo de fazer as coisas que são chatas, basicamente.
51:07
Não tenha medo de enfrentar um código legado e ter que fazer
51:11
essa refatoração.
51:12
SPEAKER_02: É a minha dica principal,
51:14
principalmente para quem está começando e quer aprender a fazer
51:16
as coisas de um
51:17
SPEAKER_02: jeito direito.
51:17
SPEAKER_02: Mas não veja isso como modelo a ser seguido.
51:20
SPEAKER_02: Veja justamente o contrário.
51:21
SPEAKER_02: Veja como eu posso fazer melhor do que isso.
51:24
SPEAKER_02: Essa é a minha mensagem.
51:25
obrigado aí Bruno pela participação foi muito bom trocar ideia
51:29
contigo e fica
51:30
aberto o convite né pra voltar outras vezes boa aí pra quem só
51:34
tá ouvindo o cara
51:35
tem uns cinco chapéus vermelhos atrás dele então ele ele condiz
51:39
com o lugar o
51:41
SPEAKER_02: plural não é chapéus chapéus ele tem cinco hats ali atrás mais fácil né
51:50
SPEAKER_02: E são reds.
51:52
SPEAKER_02: E os teclados também, aqui não dá pra ver, mas tem os teclados lá.
51:55
SPEAKER_02: Ando testando muitos.
51:58
SPEAKER_02: Até achar um que eu ainda não achei, um que seja muito bom.
52:00
SPEAKER_02: Tem um hobby novo aí, além da programação, teclados.
52:04
SPEAKER_02: O hobby novo é tentar encontrar um teclado que seja perfeito, né?
52:08
SPEAKER_02: Que não dê dor das mãos.
52:10
SPEAKER_02: Patrocina o Bruno.
52:12
SPEAKER_02: Eu tenho ele salvo aqui, mas eu não testei ainda.
52:14
Eu tenho aqui o Moonlander,
52:16
eu tenho ali em cima tem o Vortex Core,
52:18
que é aquele 40%.
52:19
SPEAKER_02: Quase não tem tecla pra você digitar.
52:21
SPEAKER_02: Já testei de tudo, cara.
52:22
SPEAKER_02: Tô tentando achar alguma coisa.
52:25
SPEAKER_01: Faz um post review no blog lá.
52:29
Eu ainda tô na esperança de que esses whispers da vida ainda
52:32
vão resolver o meu problema.
52:34
SPEAKER_02: Eu só vou simplesmente parar aqui e sair ditando o código, né?
52:38
SPEAKER_02: Na linha 34, cria uma função com tais parâmetros.
52:41
SPEAKER_02: E eu já tô testando, ele funciona parcialmente, assim, né?
52:45
SPEAKER_02: Ainda não é uma experiência super legal, mas quem sabe, né?
52:49
SPEAKER_02: Deixar de usar o teclado talvez seja o teclado perfeito.
52:54
SPEAKER_02: Fica a dica, então.
52:54
SPEAKER_02: Fica a dica, né?
53:05
Codicom nas redes sociais,
53:06
assine nossa newsletter e participe dos nossos eventos.
53:09
SPEAKER_02: Você encontra todos os links no site codicom.dev.
53:12
SPEAKER_02: Valeu e até a próxima!
53:14
SPEAKER_02: Valeu!
53:22
SPEAKER_02: Esse podcast foi editado pela BZT.