Depure como um desenvolvedor sênior: fluxo de controle do programa de depuração

A partir de agora, publiquei os 3 primeiros vídeos do curso e publicarei o quarto amanhã. Pretendo publicar dois vídeos por semana no YouTube para maximizar o impacto, mas aqui, postarei apenas uma aula por semana para evitar supersaturação.

Gravei cerca de 4 horas de conteúdo de vídeo e ainda não terminei o 2º módulo de oito. Este curso será muito detalhado e intensivo.

Estou trabalhando na plataforma do curso agora, fazendo um bom progresso, e espero publicá-lo em breve aqui . Pode já estar no ar quando você ler isso!

É importante para mim que a experiência do usuário na plataforma do curso seja satisfatória. Portanto, evitei o DRM o máximo possível. Espero que as pessoas respeitem isso e o esforço que estou colocando nisso.

Estou construindo a plataforma do curso no Spring Boot 3 com GraalVM para que seja idealmente enxuta, rápida e bastante simples. Pretendo hospedar os vídeos no YouTube como vídeos não listados para proporcionar uma experiência de visualização decente.

Isso significa que os desenvolvedores podem trair minha confiança e compartilhar vídeos não listados. Espero que não.

Meu raciocínio aqui é baixa sobrecarga e excelente desempenho. Eu também gostaria de tornar o curso gratuito em alguns anos. Ao usar o YouTube, posso tornar o curso gratuito tornando os vídeos públicos.

O vídeo a seguir discute o fluxo de controle na depuração. Isso começa com o básico, mas pode se aprofundar bastante para salto para linha, retorno forçado, etc. Essas são ferramentas que podem mudar significativamente a maneira como depuramos o código.

Não se esqueça de conferir meu livro e se inscrever no canal do YouTube para vídeos futuros!

Transcrição

Bem-vindo de volta à segunda parte da depuração no Scale, onde você pode aprender os truques secretos da depuração.

Nesta seção, discutiremos o aspecto mais básico da depuração. Atingimos um ponto de interrupção. O que agora?

Bem, é aqui que os depuradores nos permitem controlar o fluxo para investigar como tudo funciona em um ambiente controlado.

Então, o que está na agenda para hoje?

Discutiremos a revisão e o código. Espero que a maior parte desta lista seja familiar para você. Os dois últimos itens em que interrompemos o fluxo de controle podem não ser familiares para você. Tenho certeza que a maioria de vocês não está familiarizada com o último item da agenda. Como eu sei? Fique ligado e descubra!

Passo por cima, dentro, fora e força

Step over é a forma mais básica de controle de fluxo. Deixamos o código na linha ser executado e, em seguida, podemos inspecionar os resultados no painel de variáveis. É simples e fácil.

Nesse caso, eu apenas apertei o botão aqui algumas vezes, mas também poderia apertar F8 para obter o mesmo efeito…

A seguir, discutiremos duas operações distintas, entrar e sair. Step into entra no método que invocamos. Observe que, se não houver um método para entrar na etapa, a operação funcionará como a passagem.

Temos duas operações de entrada. O regular e o passo de força em que normalmente age da mesma maneira. Precisamos da versão de força quando queremos entrar em uma API que o IntelliJ normalmente ignorará. Podemos pressionar F7 para entrar em um método. Podemos pressionar Shift F7 para forçar a entrada.

Quando terminamos de olhar para um método e não nos importamos com o resto, podemos sair. Isso executa o restante do método e retorna.

Observe que se tivermos um ponto de interrupção antes do retorno, ele ainda pararia no ponto de interrupção, como vemos neste caso. Podemos pressionar este botão aqui para sair ou podemos pressionar shift-F8 para fazer a mesma coisa.

Continuar e correr para o cursor

Continue procede com a execução do projeto até que o ponto de interrupção seja atingido novamente. Isso também é chamado de currículo. É um recurso simples que usamos muito. Você pode continuar pressionando a versão especial do botão play aqui. O atalho também ajuda porque a gente usa muito, é o F9.

Run to cursor nos permite pular linhas que são desinteressantes e alcançar o código que importa. Podemos definir um ponto de interrupção nessa linha para obter o mesmo efeito, mas às vezes isso é mais conveniente, pois elimina a necessidade de definir e desarmar um ponto de interrupção.

Podemos pressionar este botão para ir até o cursor ou podemos usar ALT-F9 como atalho para esse recurso.

Forçar retorno e exceção de lançamento

Esse recurso é conhecido como retorno forçado no IntelliJ/IDEA.

Para ver a opção de retorno forçado, clicamos com o botão direito do mouse no rastreamento de pilha e podemos ver um conjunto de opções. Uma opção ainda mais interessante é drop frame que mostrarei em breve.

Observe a opção throw exception que é idêntica a force return, mas lança uma exceção do método.

Depois de clicar nessa opção, é exibida uma caixa de diálogo para inserir o valor de retorno do método. Isso me permite alterar o valor retornado do método, o que é muito útil quando desejo depurar um bug difícil de reproduzir.

Imagine um caso em que uma falha acontece com um cliente, mas você não consegue reproduzi-la. Nesse caso, posso simular o que o cliente pode estar experimentando retornando um valor diferente do método.

Aqui, o valor é uma variável booleana, então é simples. Mas seu código pode retornar um objeto; usando esta técnica, você pode substituir esse objeto por um valor arbitrário. Um bom exemplo seria nulo, e se esse método retornasse nulo, ele reproduziria o problema que meu usuário está enfrentando?

Da mesma forma, lançar exceção nos permite reproduzir casos extremos, como lançar uma exceção devido a uma falha arbitrária.

Depois de pressionar OK, retornamos com um valor diferente. Nesse caso, eu estava no limite do método, mas poderia ter feito isso no início do método e pulado totalmente a execução do método.

Isso nos permite simular casos em que um método pode falhar, mas queremos zombar de seu comportamento. Isso pode fazer sentido se não conseguirmos reproduzir o comportamento visto pelo cliente. Podemos simular usando ferramentas como esta.

Soltar quadro

Drop frame é quase tão revolucionário, mas também é mais um “truque legal”. Aqui, entrei em um método por engano. Opa, eu não queria fazer isso. Eu queria mudar alguma coisa antes de entrar... Felizmente, há queda de quadro.

Vimos que posso alcançá-lo no menu do botão direito; você também pode clicar aqui para acioná-lo.

Soltar quadro efetivamente descarta o quadro de pilha. É uma operação de desfazer. Mas não é exatamente isso. Ele não pode desfazer as alterações de estado que ocorreram no método em que entramos.

Portanto, se você entrar no método e as variáveis que não estão na pilha forem alteradas, elas permanecerão alteradas.

Variáveis na pilha são aquelas variáveis que o método declara ou aceita como argumentos, essas serão redefinidas. No entanto, se uma dessas variáveis aponta para um objeto, esse objeto reside na pilha e as alterações não podem ser redefinidas desenrolando a pilha.

Este ainda é um recurso muito útil, semelhante ao retorno forçado, com a exceção de que retornará à linha atual, não à próxima linha. Portanto, não retornará um valor.

Isso fica ainda melhor do que isso!

Pular para Linha

Saltar para a linha é um recurso secreto no IntelliJ. Funciona, mas os desenvolvedores não sabem disso. Você precisa instalar o plug-in Jump to Line para usá-lo. Como ele tem uma contagem de instalação relativamente baixa, presumo que as pessoas simplesmente não saibam que ele existe. Porque este é um plugin obrigatório. Isso mudará a maneira como você depura!

Com salto para linha, podemos mover o ponteiro da instrução atual para uma posição diferente no método. Podemos arrastar a seta à esquerda para trazer a execução para um novo local. Observe que isso funciona em ambas as direções, posso mover a execução atual para frente e para trás.

Isso não executa o código intermediário, ele literalmente move a instrução atual para uma nova posição. É tão legal, tenho que mostrar de novo...

Se você vir um bug, basta arrastar a execução de volta e reproduzi-la. Você pode alterar os valores das variáveis e reproduzir o problema várias vezes até entendê-lo completamente.

Podemos pular o código que está falhando, etc. Isso é espetacular. Não preciso recompilar o código. Se você já teve um caso em que acidentalmente ultrapassou uma linha e, “Oops. Não era isso que eu queria.”

Então parei o depurador e comecei do zero. Este é o plug-in para você. Isso aconteceu com todo mundo!

Podemos apenas arrastar a execução de volta e fazer tudo de novo. É absolutamente fantástico!

Finalmente

No próximo vídeo, falaremos brevemente sobre o relógio. Vamos nos aprofundar muito no sexto vídeo da série. Então fique ligado!

Se você tiver alguma dúvida, use a seção de comentários. Obrigada!