DEV Community: Davi Jonck

The Enemy of Comfort: What UFC Fighter Ian Garry Taught Me About Technical Debt

Davi Jonck — Wed, 18 Feb 2026 20:33:31 +0000

I’ve been following the UFC closely, and Ian Garry’s trajectory always strikes a specific chord with me. He calls himself "The Future," but what truly defines him isn’t the trash talk it’s his absolute allergy to comfort.

He changes gyms, travels the world to train where he is the "white belt" in the room, and purposefully exposes himself to chaos. For him, comfort is a prerequisite for defeat.

In software development, I see the exact opposite pattern repeating constantly.

Many teams avoid refactoring or modernizing their stack under the excuse of "not breaking what works." They call it "stability." But let’s be honest: the technical term for this is stagnation.

We often kick the can down the road on refactoring because it’s uncomfortable. But staying in that comfort zone is expensive. The data is brutal:

The Cost of "Bad Code" (Stripe Data) Stripe conducted a massive global study (The Developer Coefficient) and found that developers spend, on average, 42% of their work week dealing with "Bad Code" and technical debt.

Think about that. Almost half of a team's week—and the company's budget—is burned just keeping the lights on, fixing the past instead of building the future.

Discomfort Pays Off (McKinsey Data) If anyone thinks "innovation is too much work," McKinsey has a financial counter-argument.

In their Developer Velocity report, they analyzed 440 companies and found that those with the courage to adopt modern tools and step out of the traditional comfort zone grow revenue 4x to 5x faster than their conservative competitors.

The Binary Choice
Ian Garry understands that if he doesn't evolve his grappling or wrestling, he will get run over. In our field, if a company doesn't pay down technical debt and fears touching the legacy code, it becomes the dinosaur in the room.

The choice is binary:

Embrace the discomfort of learning and refactoring now.

Accept that 42% of your future will be spent fixing today's bugs.

I prefer the discomfort. What about you?

O que Ian Garry, lutador do UFC e um codebase legado têm em comum? Mais do que você imagina.

Davi Jonck — Wed, 18 Feb 2026 20:32:28 +0000

Acompanho o UFC e a trajetória do Ian Garry sempre me pega num ponto específico. O cara se autodenomina "The Future", mas o que realmente define ele não é a falação, é a alergia ao desconforto. Ele muda de academia, treina onde é o "faixa branca" da sala, se expõe ao caos de propósito.

Pra ele, conforto é o pré-requisito da derrota.

No desenvolvimento de software, vejo esse padrão se repetir constantemente no mercado. Muitos times evitam a refatoração ou a modernização da stack sob o pretexto de "não mexer em time que está ganhando". Chamam de "estabilidade", mas o nome técnico disso é estagnação.

E não sou eu quem está dizendo que isso sai caro.

A Stripe rodou um estudo global (The Developer Coefficient) e descobriu que devs gastam, em média, 42% do tempo de trabalho lidando com "Bad Code" e dívida técnica.

Pensa nisso. Quase metade da sua semana — e do dinheiro da empresa — vai pro lixo só pra manter as luzes acesas, corrigindo o passado em vez de construir o futuro.

E se você acha que "inovar dá muito trabalho", a McKinsey tem um contra-argumento financeiro. No relatório Developer Velocity, eles analisaram 440 empresas e viram que quem tem a coragem de adotar ferramentas modernas e sair da zona de conforto cresce a receita 4x a 5x mais rápido do que os concorrentes conservadores.

O Ian Garry entende que se ele não evoluir o jogo de chão ou o wrestling, ele vai ser atropelado. Na nossa área, se a gente não paga a dívida técnica e fica com medo de mexer no legado, a gente vira o dinossauro da sala.

A escolha é binária: ou você abraça o desconforto de aprender e refatorar agora, ou aceita que vai passar 42% do seu futuro corrigindo bugs de hoje.

Eu prefiro o desconforto. E você?

The Biggest Mistake Beginner Programmers Make: The Illusion of Complete Knowledge 📖

Davi Jonck — Sun, 02 Mar 2025 03:49:44 +0000

I have been mentoring some beginner programmers and noticed a common mistake: many say they can't develop something because they don't know how to do a small part of what they need and end up giving up. But the truth is, no one knows how to do everything. Most of the time, to build something, we need to research, test, and learn along the way.

Most tell me they can't create an application because they don't know how to implement a specific part, such as user authentication, database connections, or API integration. But here’s the truth: this is completely normal! Even with years of experience, I never start a project knowing 100% how everything will be done.

Software development does not require you to have all the answers before you begin but rather to know where and how to find solutions. Technology is constantly evolving, and even the most experienced developers spend a lot of time researching, learning, and testing.

If you're starting and facing this barrier, here are some tips💡:

🔹 Start small – Don’t try to build a massive system all at once. Break it down into smaller parts and solve them step by step.

🔹 Research as needed – If you don’t know how to implement login in an app, research authentication. If you need to connect to a database, look for tutorials on that.

🔹 Test and learn through practice – Programming is a continuous learning process. You’ll only understand how the pieces fit together when you start assembling the puzzle.

🔹 Talk to other developers – Many times, someone has already faced the same problem and can provide quicker guidance.
**
The important thing is to start. Knowledge comes with time. No programmer knows everything, but all know how to find what they need. So stop waiting for the perfect moment and start building! 🚀
**

O Maior Erro dos Programadores Iniciantes: A Ilusão do Conhecimento Completo 📖

Davi Jonck — Sun, 02 Mar 2025 03:43:22 +0000

Tenho mentorado alguns programadores iniciantes e percebi um erro comum, muitos dizem que não conseguem desenvolver algo porque não sabem fazer uma pequena parte do que precisam e acabam desistindo. Mas a verdade é que ninguém sabe fazer tudo. Na maior parte das vezes, para conseguir desenvolver algo, precisamos pesquisar, testar e aprender no processo.

A maioria me diz que não consegue criar um aplicativo porque não sabe como fazer determinada parte, como autenticação de usuários, conexão com um banco de dados ou integração com uma API. Mas aqui está a verdade: isso é completamente normal! Mesmo com alguns anos de experiência, nunca começo um projeto sabendo nem 50% de como tudo será feito.

O desenvolvimento de software não exige que você tenha todas as respostas antes de começar, mas sim que saiba onde e como buscar soluções. A tecnologia está sempre evoluindo, e até os programadores mais experientes passam boa parte do tempo pesquisando, aprendendo e testando.

Se você está começando e sente essa barreira, aqui vão algumas dicas 💡:

🔹 Comece pequeno – Não tente criar um sistema gigante de uma vez. Divida em partes menores e resolva aos poucos.

🔹 Pesquise conforme a necessidade – Se não sabe como implementar login em um app, pesquise sobre autenticação. Se precisa conectar ao banco, procure tutoriais sobre isso.

🔹 Teste e aprenda na prática – Programação é um aprendizado contínuo. Você só entenderá como as peças se encaixam quando começar a montar o quebra-cabeça.

🔹 Converse com outros desenvolvedores – Muitas vezes, alguém já passou pelo mesmo problema e pode te dar um direcionamento mais rápido.

O importante é começar. O conhecimento vem com o tempo. Nenhum programador sabe tudo, mas todos sabem como encontrar o que precisam. Então, pare de esperar o momento perfeito e comece a construir! 🚀

Guia Iniciante para Unidades de Medida em CSS

Davi Jonck — Thu, 05 Oct 2023 19:19:37 +0000

Este é um artigo para aqueles que estão começando no front-end ou estão querendo relembrar das unidades de medidas utilizadas no CSS.

CSS é uma ferramenta indispensável. Elá permite que o Dev controle a aparência e o layout de uma página web garantindo uma experiência de usuário agradável. No entanto, antes de mergulharmos de cabeça no mundo do design web, é crucial entender um dos pilares fundamentais do CSS: as unidades de medida.

Pixels (PX)

Ao começar a explorar as unidades de medida CSS, é natural começar com a unidade "px", abreviação de "pixels". Os pixels são uma unidade de medida absoluta, o que significa que eles têm um valor fixo e não dependem de outros fatores, como o tamanho da tela ou a configuração do dispositivo. Aqui estão alguns pontos importantes a serem considerados sobre os pixels:

Vantagens
Oferecem uma consistência visual sólida. Quando você usa "px" para definir tamanhos de fonte, margens, bordas e elementos gráficos, esses elementos aparecem da mesma forma em todos os dispositivos, proporcionando uma experiência de usuário previsível.
Desvantagem
No entanto, uma desvantagem dos pixels é que eles não se adaptam automaticamente a diferentes tamanhos de tela. Isso pode ser um desafio em um mundo onde os dispositivos têm uma ampla gama de resoluções. Portanto, ao usar "px", é importante estar ciente de como isso afetará a responsividade do seu design.

Curiosidade sobre PX:

Você sabia que o Pixel do CSS não é realmente um pixel da tela do dispositivo. Em vez disso o CSS utiliza de algo que chamamos de "Pixel de referência" que é geralmente maior que o pixel físico real.

Porcentagem (%)

As porcentagens, representadas pela unidade de medida "%", são fundamentais no mundo do CSS, especialmente quando se trata de criar layouts flexíveis e responsivos. Ao contrário dos pixels, as porcentagens são unidades de medida relativas que se baseiam no tamanho do elemento pai. Aqui estão alguns conceitos-chave relacionados às porcentagens:

Vantagens

Uma das maiores vantagens das porcentagens é a capacidade de criar layouts responsivos. Elementos dimensionados em porcentagem se adaptam automaticamente ao tamanho do seu contêiner, o que significa que eles podem se ajustar a diferentes tamanhos de tela.

Escalabilidade

As porcentagens são ideais para criar designs escaláveis. Isso é particularmente útil ao definir larguras de contêineres que se expandem ou contraem conforme o tamanho da janela do navegador.

Unidades Relativas "em" e "rem"

As unidades "em" e "rem" são unidades de medida relativas no CSS que têm uma relação direta com o tamanho da fonte. Essas unidades oferecem uma maneira flexível e escalável de definir tamanhos e espaçamentos em relação ao texto. Vamos explorar essas unidades em detalhes:

Unidade "em":

A unidade "em" é relativa ao tamanho da fonte do elemento pai.
Se você definir um elemento com um tamanho de fonte de 1.5em, ele terá 1,5 vezes o tamanho da fonte do seu elemento pai.
3.2. Unidade "rem" (Root em):

Unidade "rem"

É relativa ao tamanho da fonte do elemento raiz (normalmente, o elemento ).
Isso a torna uma escolha poderosa para criar layouts escaláveis, pois não depende da hierarquia de elementos pai-filho.

Vantagens das Unidades Relativas:

As unidades "em" e "rem" facilitam a criação de layouts responsivos e acessíveis, pois se adaptam automaticamente ao tamanho da fonte definido pelo usuário ou ao tamanho da fonte raiz.
Elas são particularmente úteis para definir margens, preenchimentos e tamanhos de fonte, permitindo uma experiência de usuário consistente e adaptável.

Unidades de Medida de Viewport: "vw", "vh", "vmin" e "vmax"

As unidades de medida de viewport, ou unidades de visualização, são uma categoria especial de unidades de medida CSS que estão diretamente relacionadas ao tamanho da janela de visualização do navegador. Elas permitem que você dimensione elementos com base na altura e largura visíveis na tela. Vamos explorar essas unidades de medida de viewport em detalhes:

Unidade "vw" (Viewport Width):

A unidade "vw" representa uma fração da largura total da janela de visualização do navegador.
Por exemplo, 1vw é igual a 1% da largura total da janela.

Unidade "vh" (Viewport Height):

A unidade "vh" representa uma fração da altura total da janela de visualização do navegador.
1vh é igual a 1% da altura total da janela.

Unidade "vmin" (Viewport Minimum):

A unidade "vmin" é igual ao valor mínimo entre "vw" e "vh".
Isso significa que ela se baseia na menor dimensão da janela de visualização, tornando-a útil para criar elementos proporcionais em qualquer direção.

Unidade "vmax" (Viewport Maximum):

A unidade "vmax" é igual ao valor máximo entre "vw" e "vh".
Ela se baseia na maior dimensão da janela de visualização, permitindo que você crie elementos proporcionais que se ajustam à tela.

Vantagens das Unidades de Medida de Viewport:

As unidades de viewport são ideais para criar layouts que se adaptam perfeitamente ao tamanho da tela, independentemente do dispositivo.
Elas são especialmente úteis para criar designs responsivos e elementos proporcionais, como fontes, imagens e espaçamentos.

Unidades de Texto: "ex" e "ch"

As unidades "ex" e "ch" são unidades de medida de texto no CSS que se baseiam no tamanho da fonte utilizada em um elemento. Elas são úteis para dimensionar elementos em relação ao texto e à largura dos caracteres. Vamos explorar essas unidades em detalhes:

Unidade "ex":

A unidade "ex" é baseada na altura da letra minúscula "x" no tipo de letra utilizado.
Ela é útil para dimensionar elementos com base na altura do texto, como a altura de uma caixa que acomodará o texto.

Unidade "ch" (Character Width):

A unidade "ch" é baseada na largura de um caractere "0" no tipo de letra utilizado.
Ela permite dimensionar elementos com base na largura dos caracteres, como definir a largura de uma caixa para acomodar um determinado número de caracteres.

Vantagens das Unidades de Texto:

As unidades "ex" e "ch" proporcionam uma maneira consistente de dimensionar elementos em relação ao texto, independentemente do tamanho da fonte utilizado.
Elas são especialmente úteis ao criar elementos que devem se adaptar ao conteúdo de texto dinâmico, garantindo uma aparência harmoniosa.

Conclusão

Com uma compreensão sólida das unidades de medida CSS, você está pronto para criar sites que se destacam no mundo digital, oferecendo uma experiência de usuário excepcional em qualquer dispositivo ou tela. Boa sorte em sua jornada de desenvolvimento web, e que seus projetos sejam sempre responsivos e visualmente impressionantes!

Java 02 - Debunking the Myth of Complete Security: Understanding the Limitations of Encapsulation in Java

Davi Jonck — Sat, 15 Jul 2023 19:56:51 +0000

Encapsulation in Java is not primarily focused on security but rather on the concept of data hiding and abstraction. It is one of the four fundamental principles of object-oriented programming (OOP), along with inheritance, polymorphism, and abstraction.

What is Encapsulation in Java ?

Encapsulation is the practice of bundling data (attributes) and methods that operate on that data within a single unit called a class. The data is kept private (usually achieved using access modifiers like private), and external entities can only access or modify it through the public methods provided by the class. This approach aims to hide the implementation details of the class, making it easier to maintain and understand.

Does encapsulation improve security?

While encapsulation can improve code organization and maintainability, it does not directly address security concerns. However, it can indirectly contribute to security in the following ways:

Controlled Access: By hiding the internal data and exposing only necessary methods, encapsulation helps control access to sensitive information, reducing the risk of unauthorized modification or misuse.

Preventing Accidental Modifications: Encapsulation prevents accidental modifications of data by ensuring that only specific methods can alter the internal state of an object. This can help prevent unintended side effects that might otherwise compromise security.

Abstraction and Complexity Reduction: Encapsulation encourages creating well-defined interfaces for classes, reducing the complexity of interactions with other classes. This, in turn, can help minimize potential security vulnerabilities that may arise from complex, tightly coupled code.

Conclusion

While encapsulation has some indirect benefits for security, it's essential to note that it is not a standalone security mechanism. Proper security measures should be implemented at various levels, such as input validation, authentication, authorization, and other security best practices, to ensure a system is robust and secure.

In summary, while encapsulation is not inherently focused on security, it contributes to better code organization, maintainability, and controlled access to data, which can indirectly help in building more secure Java applications when used in conjunction with other security practices.

Java 01 - Jasypt: Protecting sensitive data with encryption.

Davi Jonck — Sun, 04 Jun 2023 16:57:25 +0000

Data security is a critical aspect of any application or system, especially when it comes to sensitive information such as passwords, credit card numbers, or personal data. Encryption is a widely used technique to protect this sensitive data, making it unintelligible to anyone without the correct key. One of the popular libraries for encryption in Java is Jasypt.

What is Jasypt?

Jasypt is a Java encryption library that provides comprehensive features for protecting sensitive data in applications. It is easy to use and supports various cryptographic algorithms, including AES (Advanced Encryption Standard), DES (Data Encryption Standard), RSA (Rivest-Shamir-Adleman), and others.

Developed by Daniel Fernández, the Jasypt library was created to simplify the encryption process in Java and provide an additional layer of security to applications.

How to use Jasypt?

Implementation in your Project's dependencies

Jasypt website where you can find all the information First you have to add in your pom.xml the jasypt dependency as you can see below.

  <dependencies>
      <dependency>
          <groupId>org.jasypt</groupId>
          <artifactId>jasypt</artifactId>
          <version>1.9.3</version>
      </dependency>
  </dependencies>

Using simple encryption

Let's use the example that we want to encrypt a password.

01) The first step is to import the BasicTextEncryptor class from the Jasypt library


import org.jasypt.util.text.BasicTextEncryptor;

02) Keep in mind that we create the password with some program, to make it simpler I will create a string as an example.

String password = "my_password";

03) Create a new instance of the BasicTextEncryptor class.

BasicTextEncryptor textEncryptor = new BasicTextEncryptor();

04) The next step is to create an encryption key for the textEncryptor object using the setPassword method.

textEncryptor.setPassword("my_encryption_key");

05) Next we use the encrypt method to encrypt this password.

String encryptedPassword = textEncryptor.encrypt(password);

That's it! Now we have an encrypted password, remembering this is the simplest way to use this library.

06)You can save this encrypted password in a file or just show it in the console to see if it's working.

  System.out.println("Encrypted password: " + encryptedPassword);

07) To decrypt previously encrypted data, you need to use the same encryption key or algorithm you used in the encryption step, and then instead of using the encypt method we use decrypt.

Example of a simple ready-made program.

import org.jasypt.util.text.BasicTextEncryptor;
public class EncryptionExample {

    public static void main(String[] args) {
        String password = "my_password";
        String encryptionkey = "my_key";

        BasicTextEncryptor textEncryptor = new BasicTextEncryptor();
        textEncryptor.setPassword(encryptionkey);

        String encryptedText = textEncryptor.encrypt(password);
        System.out.println("Encrypted text: " + encryptedText);

        String decryptedText = textEncryptor.decrypt(encryptedText);
        System.out.println("Decrypted text: " + decryptedText);
    }
}

For those who want to dig deeper.

I will leave a project from my github where I created an application that generates passwords based on the desired conditions and saves them in an encrypted
in an encrypted notepad. It then allows you to decrypt the passwords and create a new file
file, which will be deleted in 30 seconds, containing all passwords.

https://github.com/DaviJonck/Password-Generator-and-Encryptor

Java 01 - Jasypt: Protegendo dados sensíveis com criptografia.

Davi Jonck — Tue, 30 May 2023 16:15:45 +0000

A segurança de dados é um aspecto crítico em qualquer aplicativo ou sistema, especialmente quando se trata de informações sensíveis, como senhas, números de cartão de crédito ou dados pessoais. A criptografia é uma técnica amplamente utilizada para proteger esses dados confidenciais, tornando-os ininteligíveis para qualquer pessoa que não possua a chave correta. Uma das bibliotecas populares para criptografia em Java é o Jasypt.

O que é Jasypt?

Jasypt é uma biblioteca de criptografia em Java que fornece recursos abrangentes para proteger dados sensíveis em aplicativos. Ela é fácil de usar e oferece suporte a vários algoritmos criptográficos, incluindo AES (Advanced Encryption Standard), DES (Data Encryption Standard), RSA (Rivest-Shamir-Adleman), entre outros.

Desenvolvida por Daniel Fernández, a biblioteca Jasypt foi criada visando simplificar o processo de criptografia em Java e fornecer uma camada adicional de segurança aos aplicativos.

Como usar o Jasypt?

Implementação nas dependências do seu Projeto

Site do Jasypt onde pode encontrar todas as informações

Primeiramente você tem que adicionar no seu pom.xml a dependência do jasypt como pode ver a baixo.

  <dependencies>
      <dependency>
          <groupId>org.jasypt</groupId>
          <artifactId>jasypt</artifactId>
          <version>1.9.3</version>
      </dependency>
  </dependencies>

Usando uma criptografia simples

Vamos usar o exemplo de que queremos criptografar uma senha.

01) O primeiro passo é importar a classe BasicTextEncryptor da biblioteca do Jasypt

import org.jasypt.util.text.BasicTextEncryptor;

02) Tenha em mente que criamos a senha com algum programa, para deixar mais simples vou criar uma string como exemplo.

String password = "minha_senha";

03) Cria-se uma nova instância da classe BasicTextEncryptor

BasicTextEncryptor textEncryptor = new BasicTextEncryptor();

04) O Próximo passo é criar uma chave de criptografia para o objeto textEcrpytor usando o método setPassword.

textEncryptor.setPassword("minha_chave_de_criptografia");

05) Em seguida utilizamos o método encrypt para criptografar esta senha.

String encryptedPassword = textEncryptor.encrypt(password);

Pronto! Agora temos uma senha criptografada, lembrando isso é a maneira mais simples de utilizar essa biblioteca.

06)Pode-se salvar em um arquivo essa senha criptografada ou simplesmente mostrar no console para ver se esta funcionando.

  System.out.println("Senha criptografada: " + encryptedPassword);

07) Para descriptografar dados previamente criptografados, você precisará utilizar a mesma chave ou algoritmo de criptografia usado na etapa de criptografia, e depois ao invéz de utilizar o método encypt utilizamos o decrypt.

Exemplo de um programa pronto simples.

import org.jasypt.util.text.BasicTextEncryptor;

public class EncryptionExample {

    public static void main(String[] args) {
        String password = "minha_senha";
        String chaveDeCriptografia = "minha_chave_de_criptografia";

        BasicTextEncryptor textEncryptor = new BasicTextEncryptor();
        textEncryptor.setPassword(chaveDeCriptografia);

        String encryptedText = textEncryptor.encrypt(password);
        System.out.println("Texto criptografado: " + encryptedText);

        String decryptedText = textEncryptor.decrypt(encryptedText);
        System.out.println("Texto descriptografado: " + decryptedText);
    }
}

Para quem quiser se aprofundar mais.

Vou deixar um projeto do meu github onde criei uma aplicação que gera senhas com base nas condições desejadas e as salva em um bloco
de notas criptografado. Em seguida, permite descriptografar as senhas e criar um novo arquivo
que será excluído em 30 segundos, contendo todas as senhas.

https://github.com/DaviJonck/Password-Generator-and-Encryptor