diff --git a/_posts/2024-10-22-erros-aprendizado.md b/_posts/2024-10-22-erros-aprendizado.md new file mode 100644 index 00000000..09e9bdf1 --- /dev/null +++ b/_posts/2024-10-22-erros-aprendizado.md @@ -0,0 +1,345 @@ +--- +title: "Erros de Aprendizado Para Se Evitar Como Desenvolvedor de Software" +ref: software-developer-learning-mistakes +lang: pt +layout: post +author: Carlos Schults +description: Neste artigo, trago uma lista dos mais importantes erros de aprendizado para se evitar como dev +permalink: /pt/erros-aprendizados +img: /img/software-developer-learning-mistakes/cover.webp +tags: +- opinião +- carreira +--- + +![]({{ page.img }}) +Foto de Francisco De Legarreta C. na Unsplash + +{% capture content %} +Agradeço ao amigo [André Gonçalves da Silva](https://www.linkedin.com/in/andre-godasi/) por ler e revisar esboços deste post, e sugerir melhorias. +{% endcapture %} +{% include callout.html type="info" title="Info" content=content %} + +Se você trabalha com desenvolvimento de software, com certeza já ouviu frases do tipo "Nunca pare de estudar", "Tem que se atualizar sempre", "A nossa área muda muito rápido", e assim por diante. + +Claro, todas essas frases estão certas, em algum nível. Mas sair por aí repetindo como um papagaio "nunca pare de estudar" não é a coisa mais **útil** do mundo no sentido de fornecer um direcionamento para o seu aprendizado. + +O que acaba acontecendo na prática é que muita gente, por não ter aprendido a aprender da forma correta, comete muitos erros de aprendizado que comprometem seu desenvolvimento profissional. Esses erros podem levar a um progresso lento, frustração e até mesmo estagnação na carreira - algo que ninguém está a fim de passar. + +Por isso, nesse post, resolvi trazer um compilado do que acredito serem os erros mais comuns de aprendizado que devs em geral cometem. Essa lista é fruto de anos de experiência pessoal, observação de colegas desenvolvedores e muitas conversas com gente da área. Eu sei na prática do que estou falando porque muitos desses erros são coisas que eu já cometi. + +(Sendo sincero, alguns eu ainda cometo e tô sempre precisando me policiar para parar, mas não conta pra ninguém. ;)) + +Identificar e entender esses erros é o primeiro passo para superá-los. Ao evitá-los, você pode otimizar seu processo de aprendizado, acelerar seu crescimento profissional e se manter relevante em um campo que está sempre evoluindo. + +Então, sem mais delongas, aqui vai a lista dos erros de aprendizado para você evitar. Para cada erro, você vai ver: + +- a explicação do erro +- o problema que ele causa +- como remediá-lo + +Bora lá? + +## Índice +- [Achar Que Apenas Consumo de Conteúdo == Aprendizado](#achar-que-apenas-consumo-de-conteúdo--aprendizado) +- [Não Aplicar o Conteúdo dos Recursos de Aprendizado](#não-aplicar-o-conteúdo-dos-recursos-de-aprendizado) +- [Falta de Foco](#falta-de-foco) +- [Falta de Consistência](#falta-de-consistência) +- [Subestimar a Importância das Bases](#subestimar-a-importância-das-bases) +- [Viver Embaixo de Uma Pedra (Não se antenar com o que está acontecendo)](#viver-embaixo-de-uma-pedra-não-se-antenar-com-o-que-está-acontecendo) +- [Conclusão](#conclusão) + +## Achar Que Apenas Consumo de Conteúdo == Aprendizado + +Comecei a lista com esse que acredito ser o erro de aprendizado mais comum atualmente, pelo simples fato de que a gente vive em uma época onde se produz conteúdo pra caramba. + +### Por que caímos nessa armadilha? + +Consumir conteúdo é **fácil, conveniente e(potencialmente) divertido.** Vamos entender o porquê: + +- Fácil: É algo passivo, você não tem que pensar muito ou tomar decisões, e o ser humano tende a procurar o caminho do menor esforço. +- Conveniente: Você pode geralmente consumir o conteúdo enquanto faz outras coisas: + - Ouvir um podcast enquanto se exercita ou lava a louça + - Assistir um vídeo enquanto almoça + - Ler posts no Reddit enquanto espera na fila do banco +- Divertido: Muitos criadores percebem que, pra engajar o público, precisam adicionar um toque de entretenimento e transformar o conteúdo numa performance que segure a atenção. + +Pronto, a armadilha está montada. Aí você vai lá, bola uma estratégia para preencher cada momento livre do dia com o consumo de podcasts, vídeos no Youtube, blog posts, Reddit, e sei lá o que mais. + +### As consequências desse erro + +No fim, você vai ter: + +1. Consumido seu tempo com informações superficiais +2. Retido quase nada do que consumiu +3. Um vago sentimento de que "aprendeu" alguma coisa + +Mas e na hora de aplicar isso de maneira significativa no seu dia-a-dia? É aí que a conta não fecha. + +A longo prazo, as consequências podem ser ainda mais sérias: + +- Estagnação profissional, pois você não está realmente desenvolvendo novas habilidades +- Frustração ao perceber que não está progredindo como esperava +- Possível burnout ao tentar constantemente "ficar por dentro" de tudo + +Pra deixar bem claro: o erro aqui não é "consumir conteúdo." E sim achar que apenas o consumo desenfreado de conteúdo é o suficiente para você evoluir como profissional. + +### Como remediar esse erro + +A solução é simples em teoria, o que não necessariamente significa que é fácil. Aqui vai: + +**Diminua a parcela do seu tempo de aprendizado que você gasta com consumo passivo de conteúdos, e aumenta a parcela gasta com aprendizado prático, principalmente projetos pessoais.** + +As sugestões aqui são: + +- Crie ou contribua com um projeto open-source +- Faça um site ou aplicativo para uma ONG, entidade assistencial, ou sua igreja +- Solucione algum problema que você ou algum familiar tem criando uma automação simples +- Reinvente a roda:[ Implemente uma tecnologia ou ferramenta conhecida](https://github.com/codecrafters-io/build-your-own-x) (exemplos: git, Docker, um servidor HTTP) simplesmente com o objetivo de aprender. + +A lista acima não é exaustiva, mas serve apenas pra começar a te inspirar. Cinco minutos de Google ou de conversa com o Chat GTP vai render muitas ideias de projetos legais para fazer. + +## Não Aplicar o Conteúdo dos Recursos de Aprendizado + +Se você comprar um livro e não o ler, você joga dinheiro fora. Se você comprar o livro, ler, e o aprendizado daquilo não impactar a maneira como você faz seu trabalho, então você desperdiça o seu dinheiro e o seu tempo! + +O mesmo se aplica a cursos, tutoriais, e outros recursos de aprendizado. Ser desenvolvedor de software é uma profissão prática; como você espera se beneficiar do que aprendeu, se não o colocar em prática? + +Antes que alguém reclame: sim, é claro que existem livros, vídeos, etc., cujo conteúdo não tem uma aplicação prática direta. Talvez você tenha lido [O Mítico Homem-Mês](https://pt.wikipedia.org/wiki/The_Mythical_Man-Month) pra pegar alguns insights e aprender sobre a história do desenvolvimento de software, mas isso não muda necessariamente como você escreve código. E tá tudo bem, esses casos existem – use seu bom senso. + +Como o erro #2 difere do anterior? + +A gente pode resumir o primeiro erro como “gastar 100% do seu tempo de aprendizado com o consumo de conteúdo.” Ou seja, você não faz mais nada além de consumir coisas. + +Este erro aqui é na linha de “não aplicar o que você aprende com o conteúdo assistido.” + +Ou seja, é possível cometer o segundo erro sem cometer o primeiro. Por exemplo, você pode dedicar 60% do seu tempo de aprendizado à criação de projetos pessoais e 40% ao consumo de conteúdo. Mas se ainda sim você não aplicar de nenhuma forma o conteúdo que você aprendeu nesses 40% do tempo, você vai ter cometido o erro #2. Ficou claro? + +### Motivo Desse Erro + +Por que tanta gente (este que vos fala incluso) comete esse erro? Provavelmente o que rola aqui é uma certa pressão psicológica que muitos sentimos, no sentido de atingir números. Quantas pessoas você conhece que criam umas metas assim? + +- Ler x livros técnicos por ano +- Fazer y cursos até o segundo semestre +- etc… + +Se você se sente realmente a fim de atingir esse tipo de meta, não tem jeito: precisa “gastar” o menor tempo possível com cada conteúdo. Do contrário, a conta não fecha. + +### Problemas Causados Por Este Erro + +Uma consequência grave que você pode sofrer com este erro é a falta de motivação. Você leu todos os livros famosos da área que te indicaram, concluiu todos os cursos no seu [PDI](https://mereo.com/blog/pdi/), e parece que nada mudou. Assim fica difícil ter a motivação pra insistir no aprendizado, quando a sensação é de que nada disso gera impacto real na maneira como você trabalha. + +É essa a tal da frustração com a falta de evolução na carreira, que a gente citou no erro anterior. Outra consequência séria desse erro é o próprio desperdício de tempo, dinheiro e energia: o aprendizado é um investimento que precisa ter um retorno para ser justificado. + +### Qual a solução? + +O remédio para este erro tem dois passos: + +1. Priorizar qualidade ao invés de quantidade +2. Aplique constantemente o que aprendeu + +Então, aqui fica a minha sugestão prática:: **só inicie outro curso/livro/etc após ter aplicado o aprendizado do anterior.** + +Por exemplo, digamos que você está fazendo um curso na Udemy. Após cada aula ou seção, pare e crie um pequeno projeto no qual você exercita o que você acabou de aprender. Não precisa ser um projeto grande, nem mesmo útil. De preferência, jogue fora depois de terminar: o importante é a prática. + +Aqui estão mais alguns exemplos: + +- Após assistir um tutorial de programação, dedique tempo para replicar o projeto por conta própria, sem olhar o vídeo +- Leu um artigo sobre uma nova técnica de refatoração? Aplique-a em um projeto pessoal ou no trabalho +- Ouviu um podcast sobre boas práticas de código? Revise um projeto antigo e veja onde você pode aplicar essas práticas + +Com relação à leitura de livros técnicos, recentemente eu criei uma regra pra mim: quando eu termino um livro, eu só posso começar outro depois que eu tiver aplicado o conteúdo do livro que acabei de ler. Essa aplicação pode ter diferentes formas: + +- fazer os exercícios do livro, caso tenha +- criar um ou mais projetos para exercitar aquele conteúdo +- propor/implementar uma nova prática no meu trabalho baseado no que aprendi + +No fim das contas, é isso que importa: que você dê um jeito de aplicar o conteúdo aprendido pra melhorar a sua vida profissional. Uma pilha de livros cujo conteúdo não te impactou só serve pra juntar poeira ou de suporte para monitor. + +## Falta de Foco + +Existem muito mais coisas “aprendíveis” do que você tem tempo ou energia para aprender. Você nunca vai saber tudo, e nunca vai zerar a sua fila de coisas para aprender. Isso é um fato e você precisa aceitar e abraçar esse fato, a não ser que você esteja muito a fim de um burnout. + +Infelizmente, a gente sente a pressão de “estar sempre estudando”, mesmo que essa frase em si não tenha nenhuma utilidade—não oferece nenhuma ajuda sobre *o quê* estudar, ou que estratégias usar. + +É comum que essa pressão venha das nossas próprias empresas: + +- Leia o livro x! +- Faça esse curso! +- Conclua essa trilha! + +E essas pessoas são bem intencionadas, mas isso não muda o fato de que você tem uma quantidade limitada de tempo no seu dia e, mais importante, uma quantidade limitada de energia no tempo que você tem disponível + +Mas aí você cede à pressão e acaba cometendo o erro desse item: ficar pulando de curso em curso, livro em livro, tutorial em tutorial, sem nunca concluir nada, ou pelo menos atingir algum progresso significativo. + +### Um Disclaimer + +Olha só: eu sei que no dia-a-dia do trabalho, é muito comum a gente se deparar com um número enorme de problemas diferentes que precisam ser resolvidos, e o prazo é sempre pra ontem. Nestas situações, muitas vezes a coisa correta é sim aprender somente o superficial de um assunto para conseguir dar conta da demanda e gerar valor para o usuário o mais rápido possível. + +**A habilidade de distinguir quando é a hora de investir em um certo item de maneira mais aprofundada e quando um conhecimento superficial basta** é algo que é extremamente valioso para a carreira de qualquer profissional, e a única maneira de aperfeiçoar essa habilidade é com a prática. + +O erro que eu aponto neste item é uma situação diferente do cenário acima. Mais especificamente, o erro é sobre tentar aprender muitas coisas ao mesmo tempo, de maneira aprofundada, com recursos densos. + +### Problemas Causados Por Este Erro + +O principal problema causado pela falta de foco é que você nunca se aprofunda em nada. Você fica com uma vaga impressão de conhecimento em um milhão de coisas, mas quando rola uma situação crítica no qual o conhecimento aprofundado faria falta, você não tem o que mostrar. + +Como eu já disse antes, é impossível se aprofundar em tudo. Mas você deveria, sim, se aprofundar nas coisas que mais importam, aquelas que geram maior valor para sua carreira. Me refiro aos tais dos fundamentos que muita gente fala, mas vou falar mais a respeito disso em outro tópico. + +### Como Remediar + +Este erro talvez seja o mais difícil de remediar, porque a solução envolve uma dose alta de autoconhecimento e um senso muito forte de priorização. + +No geral, a dica é: **defina UM ponto de evolução para sua carreira, e foque nele por um tempo considerável, até avaliar que fez progresso.** + +Alguns exemplos de pontos de melhoria: + +- Melhorar meus conhecimentos de paralelismo, concorrência, e performance +- Aprender os principais design patterns e saber aplicá-los em projetos reais +- Adquirir habilidades avançadas em SQL +- Aprender uma nova linguagem e chegar em um nível produtivo + +Não é fácil identificar este ponto de melhoria, mas aqui vão algumas dicas: + +* Peça feedback dos gestores e colegas. +* Converse com algum mentor técnico em quem você confia. +* Se você está ativamente participando de processos seletivos para vagas e tem falhado, analise os pontos nos quais foi mal nas entrevistas para identificar onde melhorar. +* Se não está ativamente procurando, finja que está. Peça para algum amigo ou mentor fazer uma mock interview com você, e depois peça feedback honesto. + +## Falta de Consistência + +O que é melhor, dedicar 30 minutos por dia pra aprender, todos os dias, ou 5 horas no final de semana, uma vez a cada três meses? A resposta é óbvia. + +A nossa profissão é prática, é necessária prática deliberada e consistente para que você internalize as coisas que aprende a saiba usar quando chegar a hora. + +### Consequências + +As consequências aqui são bem óbvias, né? Simplesmente não tem como fazer progresso se você não se esforça com consistência. Isso na verdade se aplica em praticamente qualquer coisa na vida: atividade física, aprendizado de idiomas, tocar um instrumento, e por aí vai. + +Se você investe, por exemplo, 1 hora por semana para aprender algo, isso dá um total de cerca de 51 horas no ano. Agora, se você aprender 15 minutos todos os dias, isso dá um total de 5475 minutos no ano, **o que dá mais de 91 horas**! + +Estudar só uma vez por semana tem outra desvantagem. Se surgir algum imprevisto e você precisar faltar, quando voltar já terão se passado duas semanas. Assim, fica complicado manter o ritmo; você precisa lembrar de onde parou 14 dias atrás, e retomar o contexto perdido não é nada fácil. + +### Como Remediar + +Solucionar esse erro requer pensar em estratégias para que o aprendizado se torne uma parte natural da sua rotina diária. + +Para começar, defina o **tempo **que você vai dedicar diariamente, de forma _realista_**. Não adianta se comprometer com 2 horas de aprendizado diário se a sua rotina simplesmente não permite isso. + +Outra coisa essencial é escolher o **horário** do seu tempo de aprendizado. Pra fixar bem o hábito, o ideal seria que fosse no mesmo horário todos os dias. Ao escolher esse horário, leve em consideração como seus níveis de energia mudam durante o dia. Você é uma pessoa matinal? Coloque seu tempo de aprendizado na parte da manhã. Do contrário, à noite. + +Vou dar o exemplo do que funciona pra mim. Eu sei que se for deixar meu tempo de aprendizado para depois do trabalho, vou estar muito cansado e provavelmente não vou fazer. Então, para mim, o melhor é reservar cerca de 50 minutos antes do trabalho para o aprendizado. + +Pra fazer do aprendizado um hábito, a chave é integrar na rotina e diminuir o atrito. Sabe aquela galera que dorme de roupa de academia? Mesma ideia pro estudo. Deixe o PC ligado com o VS Code aberto no seu projeto, ou configure o navegador pra abrir direto no curso da Udemy. Quanto mais fácil começar, melhor. + +Também é interessante que a hora de decidir o que aprender e a hora de aprender sejam momentos distintos. Se você tem 50 minutos por dia para o aprendizado, mas gasta 20 desses minutos todos os dias decidindo o que vai ler/praticar/assistir, você está desperdiçando 40% do seu tempo. + +Então vai a dica: no sábado, você vai definir a sua rotina de aprendizado para a semana seguinte. Você criar uma planilha definindo os dias e o que você vai fazer, ou criar um board no [Trello](https://trello.com/), ou mesmo usar papel e caneta, não importa. O importante é você já ter isso definido de antemão. Aí, nos dias da semana, você simplesmente confere e segue o planejamento feito. + +Finalmente, algo que funciona para muitas pessoas é fazer algum tipo de compromisso público. Você declara, publicamente—por exemplo, no seu Linkedin—que vai estudar sem faltar durante x dias. O simples fato de ter feito esse compromisso frequentemente ajuda as pessoas a manterem a rotina sem faltar. + +Uma iniciativa legal nesse sentido é o [100 Dias de Código,](https://www.100diasdecodigo.dev/) que incentiva pessoas a codarem durante 100 dias seguidos, sem falta, interagindo com outros participantes no processo. + +## Subestimar a Importância das Bases + +Muita gente subestima a importância de se aprender os fundamentos da computação. Sim, estou falando daquelas coisas chatas que você não gostava de estudar na faculdade: algoritmos e estruturas de dados, teoria da computação, complexidade de algoritmos, e por aí vai. + +Esse pessoal argumenta que você não precisa saber dessas coisas todas pra fazer o seu código funcionar. Sim, isso pode ser verdade boa parte do tempo, mas não sempre. + +A gente pode pensar na computação como várias camadas que abstraem a camada anterior. Quando você está trabalhando em uma camada, você geralmente não precisa se preocupar com as outras. Isso é uma coisa boa, e é literalmente o motivo pelo qual a gente usa abstrações: “esconder” coisas que não são essenciais, diminuindo a complexidade do que você precisa lidar. + +### Consequências + +Infelizmente, as abstrações não são perfeitas. Como já nos advertiu Joel Spolsky mais de 20 anos atrás, [as abstrações em algum momento vazam](https://www.joelonsoftware.com/2002/11/11/the-law-of-leaky-abstractions/). + +Em outras palavras: só porque você usa um ORM não significa que você não tem que saber SQL. Mesmo quem usa uma linguagem gerenciada como C# ou Java pode se beneficiar de ter um entendimento sobre gerenciamento de memória: no mínimo, você vai ser capaz de escrever código que usa lifetimes de maneira correta, não cria alocações desnecessárias e coloca pressão no garbage collector. + +Falta de entendimento de complexidade de algoritmos pode derrubar um sistema. Você testa localmente seu código com algumas poucas centenas de valores, mas quando aquilo vai ao ar e tem que lidar com milhões de itens, ele simplesmente não dá conta. + +Em resumo: você consegue fazer algo que “funciona” sem conhecimento de fundamentos. Porém, funciona em parte dos cenários, parte do tempo, com desempenho inaceitável, e sem levar em conta edge cases. + +Além dos problemas que a falta de uma base sólida pode causar nos sistemas em que você trabalha, este erro pode trazer outra consequência bem séria para sua carreira. + +Sim, estou falando de você não ser capaz de passar nos processos seletivos das empresas. É muito comum que empresas, principalmente as de fora do país, utilizem desafios técnicos que requerem um bom conhecimento em tópicos como algoritmos, estrutura de dados, complexidade, concorrência e paralelismo, o modelo de memória da sua linguagem preferida, entre outros. + +Não ter esse conhecimento significa ser reprovado sumariamente nos processos. + +### Solução + +Se você não tem faculdade, recomendo fortemente que estude Ciência da Computação. Caso já tenha terminado a faculdade mas esqueceu todos aqueles tópicos, procure relembrar/reforçar esses conceitos. + +Na internet você pode achar de sobra conteúdo sobre Ciência da Computação. Por exemplo, o projeto [Teach Yourself Computer Science](https://github.com/Clemensss/TeachYourselfCS-PT/blob/master/TeachYourselfCS-PT.md) tem um roadmap de tópicos para aprender, com bibliografia e vídeos de aulas de universidades renomadas. + +O [NeetCode ](https://neetcode.io/roadmap)é um site que traz um roadmap de estudo de algoritmos e estruturas de dados. Também oferece cursos e a funcionalidade de praticar questões reais usadas em entrevistas de emprego. + +## Viver Embaixo de Uma Pedra (Não se antenar com o que está acontecendo) + +Achei que seria interessante que o último erro fosse exatamente o oposto do primeiro. Enquanto o erro que abre a lista era “apenas consumir conteúdo e achar que está aprendendo”, esse aqui é “nunca consumir conteúdo nenhum.” + +### Por Que Isso é Um Problema? + +Nós trabalhamos em uma área que muda constantemente, e cada vez mais rápido. Não se manter atualizado pode levar a: + +- Obsolescência das suas habilidades +- Perda de oportunidades de carreira +- Dificuldade em resolver problemas usando abordagens mais eficientes +- Falta de inspiração para inovação no seu trabalho diário + +Em outras palavras: falta de atualização prejudica seu desempenho no seu trabalho atual, e ao mesmo tempo diminui suas chances de conseguir um potencial novo emprego. Não é isso que você quer, né? + +### Encontrando o equilíbrio + +Por um lado, utilizar cada segundo livre para consumir cada podcast/artigo/vídeo que seja possível não é uma boa estratégia. É como comer muita porcaria que não é nutritiva: você vai se sentir cheio, mas aquela comida não vai trazer os benefícios que seu corpo precisa. + +Mas por outro lado, não consumir conteúdo *nenhum* é igualmente ruim. Como desenvolvedor, é importantíssimo que você tenha pelo menos uma noção do que está acontecendo no mundo do desenvolvimento de software. + +### O que manter no radar + +Aqui vai uma pequena lista de coisas que seria interessante manter no seu radar: + +1. Lançamento de livros técnicos sobre temas que você se interessa, ou de autores que você já acompanha +2. Novas funcionalidades da versão mais recente da sua linguagem ou framework principais +3. Ferramentas ou técnicas que podem facilitar a sua vida +4. Tendências emergentes na indústria (por exemplo, IA.) + +### Onde encontrar conteúdo relevante + +Existem muitas fontes de informação valiosas para desenvolvedores. Aqui estão algumas sugestões: + +1. **Reddit**: + - [r/programming](https://old.reddit.com/r/programming) para um apanhado geral + - Subreddits específicas como r[/csharp](https://old.reddit.com/r/csharp), [r/java](https://old.reddit.com/r/java), [r/golang](https://old.reddit.com/r/golang), etc. +2. **Hacker News**: Excelente para notícias e discussões sobre tecnologia em geral +3. **YouTube**: + - Pesquise por canais relacionados aos seus interesses específicos + - Assista a palestras de conferências de tecnologia +4. **Blogs técnicos**: + - De empresas de tecnologia (por exemplo, blog de engenharia do [Netflix](https://netflixtechblog.com/), [Spotify](https://engineering.atspotify.com/), etc.) + - De desenvolvedores influentes na sua área +5. **Podcasts de tecnologia**: Ótimos para consumir informação enquanto faz outras atividades + +## Conclusão + +Chegamos ao fim da lista. Espero que o compilado de erros de aprendizado que você acabou de ler seja útil para sua carreira. Com essa lista eu cobri o que não fazer, mas o que você deve fazer então? + +Talvez no futuro eu escreva um post apenas sobre isso: como aprender da maneira correta, e no que focar. Deixa aí nos comentários caso você se interesse em algo assim. + +Mas, por enquanto, para saber o que fazer, basta imaginar uma estratégia de aprendizado que seja o contrário dos erros acima: + +- Aprenda com **consistência**, de preferência um pouco todos os dias; +- Tenha **foco**: privilegia um ponto principal de melhoria por vez; +- Prefira um **aprendizado baseado em projetos**, suplementado em partes por consumo de conteúdo +- Ao consumir conteúdo, sempre **aplique o que aprendeu** de alguma forma prática +- Aprender sobre ferramentas é importante, mas ter **fundamentos sólidos** é mais importante + +Agora vem a dica mais importante que eu posso deixar. + +**Feito é melhor que perfeito.** + +Pulou um dia de aprendizado? Não tem importância, continue no próximo. Dedicou 30 minutos ao seu projeto ao invés dos 50 que tinha planejado? Ainda é infinitamente melhor do que não ter feito nada. + +Tendências são mais importantes do que data points. Estar indo na direção certa é mais significativo do que metas arbitrárias do tipo “vou ler 6 livros técnicos em 2024”. + +É difícil lidar com a pressão de desenvolvimento constante que a gente sente nessa área, eu sei bem disso. Na medida do possível, tente relaxar. Não se martirize demais. Você está indo na direção certa. + +Só o fato de ter lido até o final um post de quase 4 mil palavras demonstra que você é muito mais interessado(a) em seu desenvolvimento que a maioria. Por isso, eu lhe agradeço muito. Se precisar de ajuda, não hesite em [entrar em contato.](https://carlosschults.net/sobre/) diff --git a/_posts/2024-10-22-learning-mistakes.md b/_posts/2024-10-22-learning-mistakes.md new file mode 100644 index 00000000..5692c35d --- /dev/null +++ b/_posts/2024-10-22-learning-mistakes.md @@ -0,0 +1,346 @@ +--- +title: "Learning Mistakes to Avoid As a Software Developer" +ref: software-developer-learning-mistakes +lang: en +layout: post +author: Carlos Schults +description: This post brings you a list of the most important learning mistakes to avoid as a developer +permalink: /en/learning-mistakes +img: /img/software-developer-learning-mistakes/cover.webp +tags: +- opinion +- carreer +--- + +![]({{ page.img }}) +Photo by Francisco De Legarreta C. on Unsplash + + +{% capture content %} +Thanks to my friend [André Gonçalves da Silva](https://www.linkedin.com/in/andre-godasi/) for reading and reviewing earlier drafts of this post +{% endcapture %} +{% include callout.html type="info" title="Info" content=content %} + +If you work in software development, you've certainly heard phrases like "Never stop learning," "You have to stay updated," "Our field changes very quickly," and so on. + +Of course, all these phrases are right, to some degree. But going around repeating "never stop learning" like a parrot isn't the most **useful** thing in terms of providing direction for your learning. + +What often happens in practice is that many people, having never learned how to learn properly, make many learning mistakes that compromise their professional development. These mistakes can lead to slow progress, frustration, and even career stagnation - something nobody wants to experience. + +That's why, in this post, I decided to compile what I believe are the most common learning mistakes that developers generally make. This list is the result of years of personal experience, observation of fellow developers, and many conversations with people in the field. I know what I'm talking about from practical experience because many of these mistakes are things I've made myself. + +(Being honest, I still make some of them and I'm always having to check myself to stop, but don't tell anyone. ;)) + +Identifying and understanding these mistakes is the first step to overcoming them. By avoiding them, you can optimize your learning process, accelerate your professional growth, and stay relevant in a field that's always evolving. + +So, without further ado, here's the list of learning mistakes to avoid. For each mistake, you'll see: + +- the explanation of the mistake +- the problem it causes +- how to fix it + +Let's go! + +## Table of Contents +- [Thinking That Content Consumption == Learning](#achar-que-apenas-consumo-de-conteúdo--aprendizado) +- [Not Applying the Content from Learning Resources](#não-aplicar-o-conteúdo-dos-recursos-de-aprendizado) +- [Lack of Focus](#falta-de-foco) +- [Lack of Consistency](#falta-de-consistência) +- [Underestimating the Importance of Fundamentals](#subestimar-a-importância-das-bases) +- [Living Under a Rock (Not Keeping Up with What's Happening)](#viver-embaixo-de-uma-pedra-não-se-antenar-com-o-que-está-acontecendo) +- [Conclusion](#conclusão) + +## Thinking That Content Consumption == Learning + +I started the list with what I believe to be the most common learning mistake currently, simply because we live in an era where content is produced in massive quantities. + +### Why Do We Fall Into This Trap? + +Consuming content is **easy, convenient, and (potentially) fun.** Let's understand why: + +- Easy: It's passive, you don't have to think much or make decisions, and humans tend to seek the path of least resistance. +- Convenient: You can usually consume content while doing other things: + - Listen to a podcast while exercising or washing dishes + - Watch a video while eating lunch + - Read posts on Reddit while waiting in line at the bank +- Fun: Many creators realize that to engage their audience, they need to add entertainment value and transform the content into a performance that holds attention. + +There you have it - the trap is set. Then you go ahead and create a strategy to fill every free moment of your day with podcasts, YouTube videos, blog posts, Reddit, and whatever else. + +### The Consequences of This Mistake + +In the end, you will have: + +1. Consumed your time with superficial information +2. Retained almost nothing of what you consumed +3. A vague feeling that you "learned" something + +But when it comes to applying this meaningfully in your daily life? That's where things don't add up. + +Long-term, the consequences can be even more serious: + +- Professional stagnation, as you're not really developing new skills +- Frustration when realizing you're not progressing as expected +- Possible burnout from constantly trying to "keep up" with everything + +To be clear: the mistake here isn't "consuming content." It's thinking that just mindlessly consuming content is enough for you to evolve as a professional. + +### How to Fix This Mistake + +The solution is simple in theory, which doesn't necessarily mean it's easy. Here it is: + +**Decrease the portion of your learning time spent on passive content consumption, and increase the portion spent on practical learning, especially personal projects.** + +Here are some suggestions: + +- Create or contribute to an open-source project +- Make a website or application for a nonprofit, charitable organization, or your church +- Solve a problem that you or a family member has by creating a simple automation +- Reinvent the wheel: [Implement a known technology or tool](https://github.com/codecrafters-io/build-your-own-x) (examples: git, Docker, an HTTP server) simply with the goal of learning. + +The list above isn't exhaustive but serves just to start inspiring you. Five minutes of Google or ChatGPT will yield many ideas for cool projects to do. + +## Not Applying the Content from Learning Resources + +If you buy a book and don't read it, you're wasting money. If you buy the book, read it, and the learning doesn't impact how you do your work, then you're wasting both your money and your time! + +The same applies to courses, tutorials, and other learning resources. Being a software developer is a practical profession; how do you expect to benefit from what you've learned if you don't put it into practice? + +Before anyone complains: yes, of course there are books, videos, etc., whose content doesn't have a direct practical application. Maybe you read [The Mythical Man-Month](https://en.wikipedia.org/wiki/The_Mythical_Man-Month) to get some insights and learn about software development history, but that doesn't necessarily change how you write code. And that's fine, these cases exist – use your common sense. + +How does mistake #2 differ from the previous one? + +We can summarize the first mistake as "spending 100% of your learning time consuming content." In other words, you don't do anything beyond consuming things. + +This mistake here is along the lines of "not applying what you learn from the content watched." + +In other words, it's possible to make the second mistake without making the first one. For example, you might dedicate 60% of your learning time to creating personal projects and 40% to content consumption. But if you still don't apply in any way the content you learned in those 40% of the time, you'll have made mistake #2. Is that clear? + +### Reason for This Mistake + +Why do so many people (including yours truly) make this mistake? Probably what happens here is a certain psychological pressure that many of us feel, in terms of hitting numbers. How many people do you know who create goals like this? + +- Read x technical books per year +- Complete y courses by the second semester +- etc... + +If you really feel like achieving this type of goal, there's no way around it: you need to "spend" as little time as possible with each piece of content. Otherwise, the math doesn't work. + +### Problems Caused By This Mistake + +A serious consequence you might suffer from this mistake is lack of motivation. You read all the famous books in the field that were recommended to you, completed all the courses in your [IDP](https://www.indeed.com/hire/c/info/individual-development-plan-examples), and it seems like nothing changed. It's hard to stay motivated to persist in learning when it feels like none of it has real impact on how you work. + +That's the frustration with lack of career evolution that we mentioned in the previous mistake. Another serious consequence of this mistake is the waste of time, money, and energy itself: learning is an investment that needs to have a return to be justified. + +### What's the Solution? + +The remedy for this mistake has two steps: + +1. Prioritize quality over quantity +2. Constantly apply what you learned + +So, here's my practical suggestion: **only start another course/book/etc. after you've applied the learning from the previous one.** + +For example, let's say you're taking a Udemy course. After each lesson or section, stop and create a small project where you exercise what you just learned. It doesn't need to be a big project, or even useful. Preferably, throw it away after you finish: the important thing is the practice. + +Here are some more examples: + +- After watching a programming tutorial, dedicate time to replicate the project on your own, without looking at the video +- Read an article about a new refactoring technique? Apply it to a personal project or at work +- Heard a podcast about code best practices? Review an old project and see where you can apply these practices + +Regarding technical books, I recently created a rule for myself: when I finish a book, I can only start another one after I've applied the content of the book I just finished. This application can take different forms: + +- do the book's exercises, if it has any +- create one or more projects to exercise that content +- propose/implement a new practice at work based on what I learned + +In the end, that's what matters: that you find a way to apply the learned content to improve your professional life. A stack of books whose content didn't impact you only serves to collect dust or as a monitor stand. + +## Lack of Focus + +There are many more "learnable" things than you have time or energy to learn. You'll never know everything, and you'll never clear your learning queue. This is a fact and you need to accept and embrace this fact, unless you're really in the mood for burnout. + +Unfortunately, we feel the pressure to "always be studying," even though that phrase itself isn't helpful—it offers no guidance about *what* to study, or what strategies to use. + +It's common for this pressure to come from our own companies: + +- Read book x! +- Take this course! +- Complete this learning path! + +And these people are well-intentioned, but that doesn't change the fact that you have a limited amount of time in your day and, more importantly, a limited amount of energy in the time you have available. + +But then you give in to the pressure and end up making the mistake of this item: jumping from course to course, book to book, tutorial to tutorial, without ever completing anything, or at least achieving any significant progress. + +### A Disclaimer + +Look: I know that in day-to-day work, it's very common to encounter a huge number of different problems that need to be solved, and the deadline is always yesterday. In these situations, often the right thing is indeed to learn just the surface level of a topic to be able to handle the demand and generate value for the user as quickly as possible. + +**The ability to distinguish when it's time to invest in a certain item more deeply and when surface knowledge is enough** is something that's extremely valuable for any professional's career, and the only way to perfect this ability is through practice. + +The mistake I point out in this item is a different situation from the above scenario. More specifically, the mistake is about trying to learn many things at the same time, in depth, with dense resources. + +### Problems Caused By This Mistake + +The main problem caused by lack of focus is that you never go deep into anything. You end up with a vague impression of knowledge in a million things, but when a critical situation arises where deep knowledge would be necessary, you don't have anything to show. + +As I've said before, it's impossible to go deep into everything. But you should, indeed, go deep into the things that matter most, those that generate the most value for your career. I'm referring to those fundamentals that many people talk about, but I'll talk more about that in another topic. + +### How to Fix It + +This mistake might be the hardest to fix, because the solution involves a high dose of self-knowledge and a very strong sense of prioritization. + +In general, the tip is: **define ONE point of evolution for your career, and focus on it for a considerable time, until you evaluate that you've made progress.** + +Some examples of improvement points: + +- Improve my knowledge of parallelism, concurrency, and performance +- Learn the main design patterns and know how to apply them in real projects +- Acquire advanced SQL skills +- Learn a new language and reach a productive level + +It's not easy to identify this point of improvement, but here are some tips: + +* Ask for feedback from managers and colleagues. +* Talk to a technical mentor you trust. +* If you're actively participating in job interviews and failing, analyze the points where you did poorly in the interviews to identify where to improve. +* If you're not actively looking, pretend you are. Ask a friend or mentor to do a mock interview with you, and then ask for honest feedback. + +## Lack of Consistency + +What's better, dedicating 30 minutes per day to learning, every day, or 5 hours on the weekend, once every three months? The answer is obvious. + +Our profession is practical, deliberate and consistent practice is necessary for you to internalize the things you learn and know how to use them when the time comes. + +### Consequences + +The consequences here are pretty obvious, right? There's simply no way to make progress if you don't make consistent effort. This actually applies to pretty much anything in life: physical activity, language learning, playing an instrument, and so on. + +If you invest, for example, 1 hour per week to learn something, that gives a total of about 51 hours in the year. Now, if you learn 15 minutes every day, that gives a total of 5,475 minutes in the year, **which is more than 91 hours**! + +Studying just once a week has another disadvantage. If something unexpected comes up and you need to miss it, when you return two weeks will have passed. This way, it becomes complicated to keep the momentum going; you need to remember where you stopped 14 days ago, and regaining the lost context isn't easy at all. + +### How to Fix It + +Solving this mistake requires thinking about strategies to make learning become a natural part of your daily routine. + +To start, define **duration**: that is, how much time you'll dedicate daily, in a _realistic_ way. There's no point in committing to 2 hours of daily learning if your routine simply doesn't allow it. + +Another essential thing is choosing the **time** of your learning period. To really establish the habit, ideally it would be at the same time every day. When choosing this time, take into consideration how your energy levels change throughout the day. Are you a morning person? Put your learning time in the morning. If not, at night. + +I'll give an example of what works for me. I know that if I leave my learning time for after work, I'll be too tired and probably won't do it. So, for me, the best is to reserve about 50 minutes before work for learning. + +To make learning a habit, the key is to integrate it into your routine and reduce friction. You know those people who sleep in their gym clothes? Same idea for studying. Leave your PC on with VS Code open in your project, or configure the browser to open directly to the Udemy course. The easier it is to start, the better. + +It's also interesting that the time to decide what to learn and the time to learn be distinct moments. If you have 50 minutes per day for learning, but spend 20 of those minutes every day deciding what to read/practice/watch, you're wasting 40% of your time. + +So here's the tip: on Saturday, define your learning routine for the following week. You can create a spreadsheet defining the days and what you'll do, or create a board in [Trello](https://trello.com/), or even use paper and pen, it doesn't matter. What's important is that you have this defined beforehand. Then, during the weekdays, you simply check and follow the planning made. + +Finally, something that works for many people is making some kind of public commitment. You declare, publicly—for example, on your LinkedIn—that you'll study without missing for x days. The simple fact of having made this commitment often helps people maintain the routine without missing. + +A cool initiative in this sense is [100 Days of Code](https://www.100daysofcode.com/), which encourages people to code for 100 consecutive days, without fail, interacting with other participants in the process. + +## Underestimating the Importance of Fundamentals + +Many people underestimate the importance of learning computer science fundamentals. Yes, I'm talking about those boring things you didn't like studying in college: algorithms and data structures, computer theory, algorithm complexity, and so on. + +These people argue that you don't need to know all these things to make your code work. Yes, this might be true most of the time, but not always. + +We can think of computing as several layers that abstract the previous layer. When you're working in one layer, you usually don't need to worry about the others. This is a good thing, and it's literally the reason why we use abstractions: to "hide" things that aren't essential, reducing the complexity of what you need to deal with. + +### Consequences + +Unfortunately, abstractions aren't perfect. As Joel Spolsky warned us more than 20 years ago, [abstractions eventually leak](https://www.joelonsoftware.com/2002/11/11/the-law-of-leaky-abstractions/). + +In other words: just because you use an ORM doesn't mean you don't have to know SQL. Even those who use a managed language like C# or Java can benefit from having an understanding of memory management: at minimum, you'll be able to write code that uses lifetimes correctly, doesn't create unnecessary allocations, and puts pressure on the garbage collector. + +Lack of understanding of algorithm complexity can bring down a system. You test your code locally with a few hundred values, but when it goes live and has to deal with millions of items, it simply can't handle it. + +In summary: you can make something that "works" without knowledge of fundamentals. However, it works in some scenarios, some of the time, with unacceptable performance, and without taking edge cases into account. + +Beyond the problems that lack of a solid foundation can cause in the systems you work on, this mistake can bring another very serious consequence for your career. + +Yes, I'm talking about not being able to pass companies' hiring processes. It's very common for companies to use technical challenges that require good knowledge in topics like algorithms, data structures, complexity, concurrency and parallelism, the memory model of your preferred language, among others. + +Not having this knowledge means being summarily rejected in these processes. + +### Solution + +If you don't have a college degree, I strongly recommend studying Computer Science. If you've already finished college but forgot all those topics, try to remember/reinforce these concepts. + +On the internet, you can find plenty of content about Computer Science. For example, the [Teach Yourself Computer Science](https://github.com/Clemensss/TeachYourselfCS-PT/blob/master/TeachYourselfCS-PT.md) project has a roadmap of topics to learn, with bibliography and video lectures from renowned universities. + +[NeetCode](https://neetcode.io/roadmap) is a site that provides a roadmap for studying algorithms and data structures. It also offers courses and the ability to practice real questions used in job interviews. + +## Living Under a Rock (Not Keeping Up with What's Happening) + +I thought it would be interesting if the last mistake was exactly the opposite of the first. While the error that opens the list was "just consuming content and thinking you're learning," this one is "never consuming any content at all." + +### Why Is This a Problem? + +We work in a field that changes constantly, and increasingly quickly. Not staying updated can lead to: + +- Obsolescence of your skills +- Loss of career opportunities +- Difficulty in solving problems using more efficient approaches +- Lack of inspiration for innovation in your daily work + +In other words: lack of updating hurts your performance in your current job, and at the same time reduces your chances of getting a potential new job. That's not what you want, right? + +### Finding the Balance + +On one hand, using every free second to consume every possible podcast/article/video isn't a good strategy. It's like eating lots of junk food: you'll feel full, but that food won't bring the benefits your body needs. + +But on the other hand, consuming *no* content is equally bad. As a developer, it's extremely important that you have at least a notion of what's happening in the software development world. + +### What to Keep on Your Radar + +Here's a small list of things that would be interesting to keep on your radar: + +1. Release of technical books about topics you're interested in, or from authors you already follow +2. New features in the latest version of your main language or framework +3. Tools or techniques that can make your life easier +4. Emerging industry trends (for example, AI) + +### Where to Find Relevant Content + +There are many valuable sources of information for developers. Here are some suggestions: + +1. **Reddit**: + - [r/programming](https://old.reddit.com/r/programming) for a general overview + - Specific subreddits like [r/csharp](https://old.reddit.com/r/csharp), [r/java](https://old.reddit.com/r/java), [r/golang](https://old.reddit.com/r/golang), etc. +2. **Hacker News**: Excellent for news and discussions about technology in general +3. **YouTube**: + - Search for channels related to your specific interests + - Watch technology conference talks +4. **Technical Blogs**: + - From technology companies (for example, engineering blogs from [Netflix](https://netflixtechblog.com/), [Spotify](https://engineering.atspotify.com/), etc.) + - From influential developers in your area +5. **Technology Podcasts**: Great for consuming information while doing other activities + +## Conclusion + +We've reached the end of the list. I hope this compilation of learning mistakes you just read is useful for your career. With this list I covered what not to do, but what should you do then? + +Maybe in the future I'll write a post just about that: how to learn the right way, and what to focus on. Leave a comment if you're interested in something like that. + +But, for now, to know what to do, just imagine a learning strategy that's the opposite of the mistakes above: + +- Learn with **consistency**, preferably a little every day +- Have **focus**: prioritize one main improvement point at a time +- Prefer **project-based learning**, supplemented in part by content consumption +- When consuming content, always **apply what you learned** in some practical way +- Learning about tools is important, but having **solid fundamentals** is more important + +Now comes the most important tip I can leave you with. + +**Done is better than perfect.** + +Skipped a day of learning? No big deal, continue the next day. Dedicated 30 minutes to your project instead of the planned 50? That's still infinitely better than having done nothing. + +Trends are more important than data points. Going in the right direction is more significant than arbitrary goals like "I'll read 6 technical books in 2024." + +It's difficult to deal with the constant development pressure we feel in this field, I know that well. As much as possible, try to relax. Don't be too hard on yourself. You're going in the right direction. + +Just the fact that you've read to the end of a post of almost 4,000 words shows that you're much more interested in your development than most. For that, I thank you very much. If you need help, don't hesitate to [get in touch.](https://carlosschults.net/sobre/) diff --git a/img/software-developer-learning-mistakes/cover.webp b/img/software-developer-learning-mistakes/cover.webp new file mode 100644 index 00000000..d79c2caa Binary files /dev/null and b/img/software-developer-learning-mistakes/cover.webp differ