DEV Community: Anderson Bosa

How to Configure Cursor with Java

Anderson Bosa — Fri, 20 Jun 2025 13:35:49 +0000

Objective

Configure the Cursor IDE to work with Java projects that use a different version of Runtime. In this guide, Corretto v17.0.13 will be used. You will learn how to configure your Cursor to run and debug your Java applications and tests.

Please feel free to make suggestions and comments: https://sandwiche.me/andersonbosadev

Getting started

Start by installing the following extensions (you can add them to the .vscode/extensions.json file so the IDE recommends them)

{
    "recommendations": [
        // for now, not available in marketplace of Cursor IDE (only VSCODE) 🥺
        "oracle.oracle-java", 
        "vscjava.vscode-java-debug",
        "vscjava.vscode-java-pack",
        "oracle.oracle-java",
        "vscjava.vscode-maven",
        "vscjava.vscode-java-dependency",
        "vmware.vscode-boot-dev-pack"
    ]
}

After installing these extensions, we need to disable some extensions because they cause malfunction. To do this, disable the redhat.java extension, which will also disable some others (as they depend on it), resulting in the following extensions being disabled:

redhat.java
    vscjava.vscode-java-test
    vmware.vscode-spring-boot
    vscjava.vscode-spring-boot-dashboard

2. Shenanigans

We need the oracle.oracle-java extension for everything to work, but it is not available in the Cursor IDE Marketplace (at the time of this guide). Therefore, a workaround is needed to download and install the extension in Cursor.

It's possible, but it's a bit tricky. Fortunately, I found an application that helps us, and I made it available in my repository after doing a Code Review.

Access the application below to search and download the VSIX for the oracle.oracle-java extension:

https://andersonbosa.github.io/vsix-downloader-webui/

Go to Cursor, Open “Command Prompt” (cmd + shift + p) and type “extensions: vsix“ to find the “Extensions: Install from VSIX” functionality.

Then just select the file and install it.

If everything was successful so far, the extension will appear in the extensions menu.

3. Configure your Runtime ☺️

To make everything work, you just need to define where your Runtime is installed in your Cursor IDE settings.

Open “Command Prompt” (cmd + shift + p) and type “pref user json“ to find the option with the JSON of your settings and add the key jdk.jdkhome with the path of your Runtime.

"jdk.jdkhome": "/Users/anbosa/Library/Java/JavaVirtualMachines/corretto-17.0.13/Contents/Home",

To validate that everything is as expected, select a test you want to run and right-click. The following options will appear:

Now you have Cursor configured to work with Java in a defined Runtime ☺️

The Power Of Git Log: You don't know how to use it.

Anderson Bosa — Mon, 28 Apr 2025 22:41:32 +0000

TL;DR
Why I wrote this
What is git log?
The -G Option: Searching for Changes in Code
The -S Option: Tracking Additions and Removals of Lines
Key Differences Between -G and -S

TL;DR

This article explains how to use git log with the -G and -S options to track changes in your codebase more effectively.

-G<regex> searches for commits where lines matching a regex were modified (added or removed).
-S<regex> finds commits where the number of occurrences of a string changed (added or deleted).
Key difference: -G detects edits to matching lines; -S detects changes in the presence/absence of the pattern.

Why I wrote this

I needed to identify which tests I needed to perform for my PR, which changed the version of the Go runtime environment. Since there were several previous PRs with the details of the manual tests and other information I needed, I could search for another colleague's PR. However, there was a problem: how could I find a PR with this change among so many PRs and Cards? Manually it was not feasible.

Well, I immediately, already knowing a little about "git log", started looking for how I could find changes in the go.mod file that matched the regular expression ^go [0-9]. And voila, I found several PRs, rich in information that I needed :3

git log -G'^go [0-9]' -- go.mod

What is git log?

Before we delve into the specific options, let’s briefly understand what the git log command does. The git log command is used to display the commit history of a Git repository. It provides various options to filter and format this information, allowing developers to examine changes and understand the timeline of a project efficiently.

The `-G` Option: Searching for Changes in Code

The -G<regex> option allows you to look for changes in the commit history where the patch text (the differences made in the code) contains added or removed lines that match a specific regular expression.

How It Works

When you use -G, Git will scan the diffs of commits and show you only those that include lines added or removed that match your given regex pattern. This is especially useful when you are interested in a specific function, variable, or code pattern that may have undergone changes over time.

Example Use Case

Suppose you want to track the history of changes to a function called calculateSum. You can run:

git log -G'calculateSum'

This command will show you all commits that altered this function, along with the relevant diffs. It’s a powerful way to track how a particular piece of code has evolved throughout the project, allowing you to connect changes with specific commits.

The `-S` Option: Tracking Additions and Removals of Lines

In contrast, the -S<regex> option, often referred to as the "pickaxe" option, helps you find commits that specifically add or remove lines matching a given regex pattern. This means you’re interested not just in the changes themselves but in whether the number of occurrences of the specified string has changed.

How It Works
When you invoke the -S option, Git checks each commit to see if the number of occurrences of the specified string (or pattern) has increased or decreased. If the matches changed, it logs that commit, allowing you to understand when and why a particular pattern came into or out of use.

Example Use Case

If you want to see when the calculateSum function was added or removed entirely from the codebase, you can use:

git log -S'calculateSum'

This command will return commits that specifically dealt with the existence of that function, helping you identify when it was introduced or deleted.

Key Differences Between `-G` and `-S`

As illustrated in the original documentation excerpt, the primary distinction between these two options lies in what they track:

-G: Focuses on the content of the patch. It finds any modifications to the lines that match the regex.
-S: Concentrates on the count of occurrences. It will look for commits where the count of the matching string has changed.

For instance, if a function appears with a new name but has the same logic, -G may detect this change, whereas -S won't show a result since the string count hasn't changed.

Conclusion

As developers, mastering these tools can lead us to a deeper understanding of our projects, facilitate smarter debugging, and improve overall collaboration within teams. So go ahead, explore these options, and share your discoveries with fellow developers in your network!

Subdomain or Subfolder: Which Is Better for Your Site’s SEO?

Anderson Bosa — Thu, 27 Feb 2025 11:27:02 +0000

When it comes to search engine optimization (SEO), a common question for developers and site owners is: Should I use a subdomain or a subfolder? Both options have their strengths, but the choice you make can directly affect how your site ranks in search results. In this article, we’ll break down the pros and cons of each approach to help you decide which one might work best for your main site’s SEO.

What’s a Subdomain?

A subdomain is an extension of your main domain that search engines treat as a separate site. It looks like this: blog.example.com. This setup is great when you need clear separation between different parts of your site.

Pros of Using Subdomains

Niche targeting: Subdomains shine when you’re dealing with distinct audiences or products. They let you craft tailored SEO strategies for each segment, which is handy for sites with diverse content.
Geographic targeting: If your site serves multiple regions or languages, subdomains can be a perfect fit. Global companies often use them to deliver localized experiences, like us.example.com or br.example.com.
Organization: For large sites, subdomains can improve user experience by keeping navigation clean and avoiding a cluttered or confusing structure.

Cons of Using Subdomains

Split domain authority: The biggest downside? Search engines see subdomains as separate entities. That means backlinks and authority built on a subdomain don’t directly boost your main domain (example.com). This can slow down your overall SEO progress.
Extra SEO effort: Since subdomains are treated as standalone sites, you’ll need to optimize each one individually. That takes more time and resources—tough if you don’t have a dedicated SEO team.

What’s a Subfolder?

Subfolders (or subdirectories) are part of your main domain, structured like this: example.com/blog. From an SEO perspective, they keep all your optimization efforts tied to a single domain.

Pros of Using Subfolders

Brand consistency: Want a unified brand experience? Subfolders are the way to go. By keeping everything under your main domain, you ensure a seamless and cohesive journey for visitors.
Stronger domain authority: Unlike subdomains, all traffic, backlinks, and authority from subfolders feed directly into your main domain. This can give your search rankings a faster boost.
Simpler SEO: Managing one SEO strategy is already a big task for most sites. Subfolders keep everything centralized, making it easier to create content, earn backlinks, and track performance.

Cons of Using Subfolders

Harder to target diverse audiences: If your site serves multiple products or groups with different needs, subfolders might make it trickier to focus on specific niches. A unified structure can dilute your targeting efforts.
Complex navigation: For sites with tons of content, cramming everything into subfolders can make navigation messy. That could hurt user experience and, indirectly, your SEO.

Which Works Best for Your Site?

If your main goal is to boost the ranking of your primary domain (example.com), subfolders (example.com/blog) are usually the better choice. They consolidate your site’s authority and amplify the impact of backlinks and optimized content.

But if you’re targeting a diverse audience or need separate SEO strategies for different markets, subdomains might be the way to go. They give you flexibility to tailor content and keywords for specific groups without affecting other parts of your site.

Final Thoughts

The subdomain vs. subfolder decision hinges on your site’s type and SEO goals. For simplicity and a quick way to build domain authority, subfolders are the most efficient option. But if you’re juggling distinct niches or need flexible organization, subdomains could be your best bet.

Now that you’ve got the pros and cons, pick the approach that fits your site’s needs and start optimizing your online presence!

Got questions about boosting your site’s SEO? Drop a comment! ✌️

References

Do you know how to evaluate performance of your Java applications?

Anderson Bosa — Thu, 27 Feb 2025 11:23:42 +0000

Recently, while chatting with an Expert here at MELI (Mercado Livre), I asked more about his past experiences, curious about the problems he’s tackled. That’s when he shared a particular scenario with me that piqued my interest: the impact of boxing and unboxing in poorly implemented algorithms. I won’t share his real case due to NDA reasons. However, I went off to study this topic myself, and now I’m bringing what I’ve learned in this post for you all.

If you work with Java, you’ve dealt with collections and autoboxing, but are you aware of the hidden cost of these automatic conversions? I hope you enjoy the content, and all feedback is welcome—thanks!

First, What Are Boxing and Unboxing?

In Java, boxing is the automatic conversion of a primitive type (e.g., int) into its wrapper equivalent (e.g., Integer). Unboxing is the reverse process. This has been around since Java 5 with autoboxing, making life easier when using APIs like ArrayList, which only accept objects. Here’s a basic example:

int primitive = 42;  
Integer wrapper = primitive; // Autoboxing  
int backAgain = wrapper;     // Autounboxing

It seems simple, but the problem arises when these conversions happen on a large scale or in poorly designed algorithms.

Some Terms That Came Up

The Heap is the memory area where Java allocates objects and arrays. It’s a global memory space, accessible by different threads in the application.

The Stack is a memory area used to store local variables (primitives or object references) and method execution details (parameters, scope variables, return address).

The Garbage Collector, meanwhile, is the JVM’s automatic janitor. It’s responsible for finding objects in the Heap that no longer have active references (nobody’s pointing to them anymore) and freeing up their memory for reuse.

Why Does This Affect Performance?

Primitive types are stored in the stack and are super lightweight—an int takes up 4 bytes. An Integer, on the other hand, is an object in the heap, with metadata overhead (it can reach 16 bytes or more, depending on the JVM). Each boxing creates a new object, increasing memory usage and the garbage collector’s workload. In loops or massive operations, this cost piles up fast.

Hands-On

Comparing Boxing vs. Primitives. Let’s test this with real code. The goal here is to sum 10 million integers in two ways:

Using an ArrayList (with boxing)
Using an int array.

GitHub Repository: https://github.com/andersonbosa/boxing-performance-test/blob/main/src/BoxingPerformanceTest.java

I kept it in the repo for better readability.

The results on your computer might vary slightly from those below (since computational power differs between machines):

Time with array (primitive): 29 ms  
Memory used by primitive array: 0 MB  
----------------------------------------  
Time with ArrayList (boxing): 171 ms  
Memory used by ArrayList: 288 MB

Why? With the ArrayList, every int becomes an Integer (10 million objects!), while the array uses just contiguous memory (TL;DR: fast access, slow insertion) for primitives. The garbage collector also has to clean up those objects afterward, adding to the impact.

Sure, you might be thinking you’re not about to go summing 10 million numbers, right? So let’s move on—I’ll show the impact of boxing/unboxing in poorly thought-out real-world algorithms.

Spoiler

Try setting the size to 500_000_000 to see the consequences!

Beware of Poorly Implemented Algorithms

Nested loops (a loop inside a loop) handling request data, authentication operations, or hash calculations processing large input volumes—what do they have in common? The memory and CPU overhead can easily scale, turning functional code into a bottleneck. Here are some practical examples I picked up from my research and chats with colleagues who’ve faced these issues in real systems:

Authentication: Batch ID Verification

A REST API validates user IDs from a JWT against an authorized list.

import java.util.List;  
import java.util.Set;  
import java.util.HashSet;  

public class AuthService {  
    private static final Set<Integer> AUTHORIZED = new HashSet<>(List.of(1001, 1002, 1003));  

    public boolean validateIds(List<Integer> userIds) {  
        for (Integer id : userIds) { // Unboxing  
            if (!AUTHORIZED.contains(id)) { // More unboxing  
                return false;  
            }  
        }  
        return true;  
    }  
}

For a request with thousands of IDs (e.g., batch validation), each Integer requires unboxing. The alternative? Use int[] and IntHashSet (from the FastUtil library).

Request Processing: Status Filtering

Imagine an endpoint that filters HTTP status codes (e.g., 200, 404, etc.) from received logs.

import java.util.ArrayList;  
import java.util.List;  

public class LogProcessor {  
    public List<Integer> filterStatus(List<Integer> statusCodes) {  
        List<Integer> filtered = new ArrayList<>();  
        for (Integer code : statusCodes) { // Unboxing  
            if (code >= 200 && code < 300) { // More unboxing  
                filtered.add(code); // Boxing  
            }  
        }  
        return filtered;  
    }  
}

With thousands of requests, each filtering operation generating boxing/unboxing would degrade performance. Using int[] would solve the issue.

Encryption/Hashing: Data Integrity Validation

For example, a web service calculates and compares SHA-256 hashes of file chunks sent via request to verify integrity (e.g., in a chunked upload).

import java.security.MessageDigest;  
import java.util.ArrayList;  
import java.util.List;  

public class HashValidator {  
    public List<Integer> calculateHashBytes(byte[] chunk) throws Exception {  
        MessageDigest md = MessageDigest.getInstance("SHA-256");  
        byte[] hash = md.digest(chunk);  
        List<Integer> hashValues = new ArrayList<>();  
        for (byte b : hash) {  
            hashValues.add((int) b); // Boxing to Integer  
        }  
        return hashValues; // Returns for comparison  
    }  
}

How could we improve this? Each byte of the hash (32 bytes for SHA-256) is converted into an Integer, creating 32 objects per call. I simulated this with 10,000 1 KB chunks: boxing increased memory usage by 20% and added overhead to the garbage collector, impacting endpoint latency. Alternative? Stick with byte[] or use int[] if conversion is needed.

Takeaways

Prefer primitives: If you don’t need objects, use int, double, etc. Arrays like int[] are your friends in intensive operations.
Avoid boxing in loops: Each iteration with autoboxing means one more object in the heap.
Know your alternatives! Libraries like Trove or Eclipse Collections offer optimized collections for primitives.
Profile your code: Tools like VisualVM or JProfiler reveal where boxing is costing you.

My Conclusion

Boxing and unboxing are handy mechanisms, but their indiscriminate use can severely compromise performance, especially in critical or poorly tested code sections. As developers and engineers, our role goes beyond just making code work. We should aim for solutions that not only solve the problem but are also efficient, resource-sustainable, and resilient to failures.

Test, compare, and optimize—your code, your users, and your career will thank you (lol).

Você sabe avaliar performance de suas aplicações Java?

Anderson Bosa — Thu, 27 Feb 2025 11:19:24 +0000

Recentemente, enquanto conversava com um Expert aqui no MELI (Mercado Livre), perguntei mais sobre as experiências passadas dele, curioso sobre os problemas que ele já atacou. Foi aí que ele compartilhou um cenário particular comigo que me deixou intrigado: o impacto do boxing e unboxing em algoritmos mal implementados. Não vou compartilhar o caso real dele por questões de NDA. Porém, fui atrás de estudar isso esta e, agora, trago o que aprendi nesta publicação para vocês.

Se você trabalha com Java, já lidou com coleções e autoboxing, mas será que está atento ao custo escondido dessas conversões automáticas? Espero que gostem do conteúdo, e todo feedback é bem-vindo, obrigado!

Primeiro, o que são Boxing e Unboxing?

Em Java, boxing é a conversão automática de um tipo primitivo (ex.: int) para seu equivalente wrapper (ex.: Integer). Unboxing é o processo inverso. Isso existe desde o Java 5 com o autoboxing, facilitando a vida ao usar APIs como ArrayList, que só aceitam objetos. Veja um exemplo básico:

int primitivo = 42;
Integer wrapper = primitivo; // Autoboxing
int deVolta = wrapper;       // Autounboxing

Parece simples, mas o problema surge quando essas conversões acontecem em larga escala ou em algoritmos mal planejados.

Alguns nomes que apareceram

A Heap é a área de memória onde o Java aloca objetos e arrays. É uma área de memória global, acessível por diferentes threads da aplicação.

A Stack é uma área de memória usada para guardar variáveis locais (primitivos ou referências a objetos) e informações de execução de métodos (parâmetros, variáveis do escopo, endereço de retorno).

Já o Garbage Collector é o lixeiro automático da JVM. Ele é responsável por achar objetos na Heap que não têm mais referências ativas (ninguém mais aponta para eles). E também de liberar a memória desses objetos para que possa ser reutilizada.

Por que isso afeta a performance?

Tipos primitivos são armazenados na stack e são super leves — um int ocupa 4 bytes. Já um Integer é um objeto na heap, com overhead de metadados (pode chegar a 16 bytes ou mais, dependendo da JVM). Cada boxing cria um novo objeto, aumentando o consumo de memória e o trabalho do garbage collector. Em loops ou operações massivas, esse custo acumula rápido.

Hands-on

Comparando Boxing vs. Primitivos. Vamos testar isso com um código real. O objetivo aqui é somar 10 milhões de números inteiros de duas formas:

usando uma ArrayList (com boxing)
um array int.

Repositório GitHub: https://github.com/andersonbosa/boxing-performance-test/blob/main/src/BoxingPerformanceTest.java
Eu mantive no repositório para melhorar legibilidade.

O resultado no seu computador pode variar um pouco do resultado abaixo (já que o poder computacional de cada máquina varia):

Tempo com array (primitivo): 29 ms
Memória usada pelo array primitivo: 0 MB
----------------------------------------
Tempo com ArrayList (boxing): 171 ms
Memória usada pelo ArrayList: 288 MB

Por quê? No caso da ArrayList, cada int vira um Integer (10 milhões de objetos!), enquanto o array usa apenas memória contígua (TL;DL: acesso rápido, inserção lento) para primitivos. O garbage collector ainda precisa limpar esses objetos depois, aumentando o impacto.

Certo, mas você pode estar pensando que não vai sair por aí somando 10 milhões de números, não é? Então vamos adiante, vou trazer o impacto do boxing/unboxing em algoritmos mal pensados no mundo real.

Spoiler

Experimente usar tamanho = 500_000_000 para ver a consequência!

Cuidado com Algoritmos Mal Implementados

Loops aninhados (loop dentro de loop) manipulando dados de requisições, operações de autenticação ou cálculos de hashing processando grandes volumes de entrada. O que eles tem em comum? O overhead de memória e CPU pode facilmente escalar, transformando um código funcional em um gargalo. Aqui eu trago alguns exemplos práticos que aprendi durante minha pesquisa ao ir atrás dos meus colegas, que tiveram essas experiências em sistemas reais:

Autenticação: Verificação de IDs em Lote

Uma API REST valida IDs de usuários de um JWT contra uma lista autorizada.

import java.util.List;
import java.util.Set;
import java.util.HashSet;

public class AuthService {
    private static final Set<Integer> AUTORIZADOS = new HashSet<>(List.of(1001, 1002, 1003));

    public boolean validarIds(List<Integer> userIds) {
        for (Integer id : userIds) { // unboxing
            if (!AUTORIZADOS.contains(id)) { // mais unboxing
                return false;
            }
        }
        return true;
    }
}

Em uma requisição com milhares de IDs (ex.: validação em lote), cada Integer exige unboxing. A alternativa aqui seria usar int[] e IntHashSet (da biblioteca FastUtil):

Processamento de Requisições: Filtro de Status

Imagine que você tem um endpoint que filtra os de status HTTP (ex.: 200, 404, etc) de logs recebidos.

import java.util.ArrayList;
import java.util.List;

public class LogProcessor {
    public List<Integer> filtrarStatus(List<Integer> statusCodes) {
        List<Integer> filtrados = new ArrayList<>();
        for (Integer code : statusCodes) { // Unboxing
            if (code >= 200 && code < 300) { // Mais unboxing
                filtrados.add(code); // Boxing
            }
        }
        return filtrados;
    }
}

Com milhares de requisições e cada filtragem gerando boxing/unboxing isso causaria degradação da performance. Usar int[] já resolveria o problema.

Criptografia/Hashing: Validação de Integridade de Dados

Por exemplo, você tem um serviço web que calcula e compara hashes SHA256 de partes de um arquivo enviado via requisição para verificar integridade (ex.: em um upload em chunks).

import java.security.MessageDigest;
import java.util.ArrayList;
import java.util.List;

public class HashValidator {
    public List<Integer> calcularHashBytes(byte[] chunk) throws Exception {
        MessageDigest md = MessageDigest.getInstance("SHA-256");
        byte[] hash = md.digest(chunk);
        List<Integer> hashValues = new ArrayList<>();
        for (byte b : hash) {
            hashValues.add((int) b); // Boxing para Integer
        }
        return hashValues; // Retorna para comparação
    }
}

Como poderíamos melhorar aqui? Cada byte do hash (32 bytes para SHA-256) é convertido em um Integer, gerando 32 objetos por chamada. Simulei com 10.000 chunks de 1 KB: o boxing aumentou o uso de memória em 20% e adicionou overhead ao garbage collector, impactando a latência do endpoint. Alternativa? Manter como byte[] ou usar int[] se conversão for necessária

Aprendizados

Prefira primitivos: Se não precisa de objetos, use int, double, etc. Arrays como int[] são seus amigos em operações intensivas.
Evite boxing em loops: Cada iteração com autoboxing é um objeto a mais na heap.
Conheça alternativas! Bibliotecas como Trove ou Eclipse Collections oferecem coleções otimizadas para primitivos.
"Perfilize" seu código: Ferramentas como VisualVM ou JProfiler mostram onde boxing está custando caro.

Minha conclusão

Boxing e unboxing são mecanismos úteis, mas seu uso indiscriminado pode comprometer severamente a performance, especialmente em trechos críticos ou pouco testados. Como desenvolvedores e engenheiros, nosso papel vai além de simplesmente garantir que o código funcione. Devemos buscar soluções que não só resolvam o problema, mas que também sejam eficientes, sustentáveis em termos de uso de recursos e resilientes a falhas.

Teste, compare e otimize — seu código e seus usuários vão agradecer (e sua carreira tbm rsrs).

LGPD para devs

Anderson Bosa — Wed, 06 Mar 2024 00:18:08 +0000

Índice

O que é a LGPD
Qual a importância da LGPD
Você Desenvolvedor, o que precisa saber
Riscos do não cumprimento da LGPD
Onde Aprender Mais sobre a LGPD

O cenário digital no mundo inteiro está em contante evolução, nesse ambiente a proteção de dados torna-se uma prioridade crucial. No Brasil, a Lei Geral de Proteção de Dados (LGPD) surge como um marco legal para para zelar pelas informações pessoais. Neste artigo, eu quero explorar o que é a LGPD, sua importância, o que um desenvolvedor de software precisa saber para alinhar seus projetos com essa legislação essencial, e os riscos associados ao não cumprimento.

O que é a LGPD?

A LGPD, Lei nº 13.709/2018, foi criada para regular o tratamento de dados pessoais por entidades públicas e privadas. Inspirada no Regulamento Geral de Proteção de Dados da União Europeia (GDPR), a LGPD estabelece diretrizes claras sobre a coleta, armazenamento, processamento e compartilhamento de dados pessoais.

A Lei nº 13.709, de 14 de agosto de 2018, foi promulgada com o objetivo de proteger os direitos fundamentais de liberdade e de privacidade e a livre formação da personalidade de cada indivíduo. source

A LGPD fala sobre o tratamento de dados pessoais, dispostos em meio físico ou digital, feito por pessoa física ou jurídica de direito público ou privado, e engloba um amplo conjunto de operações efetuadas em meios manuais ou digitais.

Qual a importância da LGPD?

Proteção da Privacidade: A LGPD busca garantir que os dados pessoais dos cidadãos sejam tratados com respeito, transparência e segurança, protegendo sua privacidade.

Reputação e Confiança: Empresas que aderem à LGPD demonstram compromisso com a integridade e segurança dos dados. Isso fortalece a confiança do cliente e preserva a reputação da organização.

Padrões Internacionais: Alinhando-se a padrões internacionais, a LGPD facilita a troca de dados com empresas e clientes ao redor do mundo, promovendo uma abordagem global de proteção de dados.

Você Desenvolvedor, o que precisa saber?

Mapeamento de Dados: Entenda quais dados pessoais são coletados e processados pelos sistemas que você desenvolve. Realize um mapeamento completo para garantir conformidade com a LGPD.

Privacy by Design e by Default: Adote práticas de privacidade desde o início do desenvolvimento, integrando a proteção de dados nos processos e sistemas, e garantindo que desde o príncipio as configurações favoreçam a privacidade.

Consentimento Transparente: Implemente mecanismos claros de obtenção de consentimento para o tratamento de dados. Certifique-se de que os usuários estejam plenamente informados sobre como suas informações serão utilizadas.

Segurança da Informação: Reforce a segurança em todos os níveis do desenvolvimento. A LGPD exige medidas adequadas para proteger dados pessoais contra acessos não autorizados e vazamentos.

Riscos do não cumprimento da LGPD

O não cumprimento da LGPD pode acarretar em diversos riscos, incluindo:

Perda de Clientes: A reputação da empresa pode ser severamente afetada, levando à perda de confiança e clientes.

Danos à Marca: Violações de dados podem resultar em danos irreparáveis à marca e impactar negativamente a percepção pública.

Multa: As multas podem atingir até 2% do faturamento da empresa, limitadas a R$ 50 milhões por infração.

Processos Legais: A organização pode enfrentar processos legais, desencadeando custos legais significativos.

Onde Aprender Mais sobre a LGPD?

A príncipío a ANPD (Autoridade Nacional de Proteção de Dados) é uma fonte oficial e de referência para consultar informações, dado que é a ANPD a responsável por fiscalizar e regulamentar a LGPD.

Porém, na Internet é possível achar muitos outros recursos como cursos, certificações e webinars/eventos. Aqui é possível consultar na íntegra o texto completo da lei.

A LGPD é uma realidade que todos os desenvolvedores devem incorporar em seus projetos. Ao entender os princípios fundamentais e adotar práticas que priorizam a privacidade, os desenvolvedores contribuem para um ambiente digital mais seguro e em conformidade com as leis de proteção de dados. Então é importante manter-se informado pois a proteção de dados é uma responsabilidade compartilhada por todos nós.

The "Something else" option in Linux installation

Anderson Bosa — Thu, 07 Sep 2023 17:12:27 +0000

I won't be very detailed in this post, it's more of a future reference for my future self in case I need to go through this again. In the "References" section of the post, I will leave some links to content by people who have explained what is being done in more detail. Still, I hope it can help someone else as well.

How it does not happens every day, I always forget how to setup the partitions in Ubuntu (or other OS's) when I need reinstall the system keeping my dual boot in order.

I recommend you format your Linux system (ig Ubuntu) in Windows, and when installing the new one, use the option "alongside". It's more safe and simple.

But we are here to use the "Something else" option. Below is a simple step by step of how use it.

The biggest space (which will be for the operating system) use type ext4. For its mount point put the value /.
Create a "swap" partition with 2048MB (2GB)
Setup the field Device for boot loader installation to your Windows boot manager
And you are ready to "install now"

References

Revolutionizing Git Workflow: My Experience with aicommits

Anderson Bosa — Sun, 05 Mar 2023 00:51:30 +0000

As a developer, optimizing and improving workflow is always a priority. That's why I'm excited to share my experience with aicommits.

This open-source tool uses OpenAPI to analyze code changes and generate descriptive commit messages automatically. Installation is straightforward, using npm install -g aicommits. After installation, aicommits will create commit messages automatically based on the changes made to your repository.

The awesome feature of aicommits is its ability to understand the context of your code changes and create a contextual commit message. This tool helps save time and improve the quality of your codebase by accurately reflecting changes made, making it easier for your team to review and understand the code.

While aicommits is undoubtedly an excellent tool for developers, it's essential to highlight a potential security issue associated with its usage. Since aicommits reads and analyzes the code context, it could potentially expose sensitive information such as API keys, passwords, and other secrets or the intellectual property itself, in this case, the source code.

While aicommits can be an invaluable tool for developers, it's essential to use it with caution and follow best practices to ensure the security of your codebase. By taking the necessary precautions, you can enjoy the benefits of aicommits while keeping your codebase safe and secure.

In conclusion, aicommits is an excellent tool for optimizing your workflow and codebase quality and git log. Its ease of use, powerful NLP (Natural Language Processing) capabilities, and ability to understand the context of your code changes make it an indispensable tool for any developer. Give aicommits a try and simplify your Git workflow while saving time.

Thanks

Special thanks to the creators Nutlope and Hiroki Osame, this project its really awesome!

References

How to use nodemon with VSCode debugger?

Anderson Bosa — Fri, 03 Mar 2023 23:33:11 +0000

Intro
Step by step
Demo

Intro

As a developer, you know that debugging is a crucial aspect of your workflow. It helps you identify and fix issues in your code, and ultimately improve your application's performance. However, the process of debugging can be time-consuming and tedious, especially if you have to manually restart your application every time you make a change. This is where Nodemon and Visual Studio Code Debugger come in handy.

Nodemon is a tool that helps you automate the process of restarting your Node.js application whenever you make changes to your code. It monitors your application for changes and automatically restarts it when it detects any modifications. This saves you a lot of time and effort, as you don't have to manually stop and start your application every time you make changes.

Visual Studio Code Debugger, on the other hand, is an integrated development environment (IDE) that provides a powerful debugging experience for Node.js applications. It allows you to set breakpoints, step through your code, and inspect variables and objects at runtime.

VSCode provides a configuration for nodemon (see image below), but I couldn't use it at first, so I had to update to the package path installed in "node_modules".

This is because the "nodemon" package is installed in the project, not globally.

So how do I do it?

The steps to integrate nodemon in VSCode debugger are:

Install nodemon as development dependency in your repository:

npm install -D nodemon
# or
npm install --save-dev nodemon

Configure the VSCode "launch.json" as follows, updating the value of runtimeExecutable:

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "nodemon",
      "console": "integratedTerminal",
      "internalConsoleOptions": "neverOpen",
      "program": "${workspaceFolder}/app.js",
      "request": "launch",
      "restart": true,
      // "runtimeExecutable": "nodemon", /* ORIGINAL VALUE */
      "runtimeExecutable": "${workspaceFolder}/node_modules/nodemon/bin/nodemon.js",
      "type": "node"
    }
  ]
}

And it done!

For your convenience I created this demo repository: andersonbosa/nodemon-vscode-tutorial

andersonbosa / nodemon-vscode-tutorial

About • Technologies • Contribution • Author • License • Statistics

💬 About

This repository shows how to integrate the nodemon tool with the VSCode Debugger. For more details, see my https://dev.to/t4inha/how-to-use-nodemon-with-vscode-debugger-2bpa

🛠️ Technologies

🚀 Distribution

Here in Github

🤝 Contribution

All kinds of contributions are very welcome and appreciated!

👨‍💻 Author

@andersonbosa

📝 License

This project is under the MIT license.

📊 Statistics

Stargazers

Forkers

| Did you like the repository? Give it a star! 😁

View on GitHub

Do you know how to integrate other languages with the VSCode Debugger? Please share in the comments! All kinds of contributions are very welcome and appreciated.

O poder por trás do terminal Linux

Anderson Bosa — Mon, 15 Mar 2021 15:56:53 +0000

Choose your preferred language:

🇧🇷 Brazilian
🇺🇸 English

🇧🇷 Brazilian

Introdução
Comandos básicos
Comandos que nos ajudam a se ajudar
Tenha seus próprios snippets
Prática!

Introdução

Procurar, diferenciar, analisar, compartilhar, descompactar, criptografar um arquivo, acessar computador na nuvem, converter um vídeo em gif e etc. Essas são algumas das coisas possíveis de se fazer com a linha de comando.

O terminal é uma varinha de condão para interagir com os recursos do computador. Permitindo a interação de maneira prática e flexível, o que a torna uma ferramenta muito poderosa.

Basicamente em todos os sistemas operacionais (e.g., Windows, Android, Mac and etc) a linha de comando é uma interface de texto para se comunicar com o computador (ou dispositivo).

Também conhecida como shell, console, prompt, terminal e entre outros nomes, o terminal pode assustar e deixar confuso em um primeiro contato. Como todo novo conhecimento, no início pode haver mais dificuldades. Porém, conforme vencemos essas barreiras vamos nos deparando com a nossa evolução.

Saber usar o terminal pode ser essencial ao tentar lidar com os problemas que pipocam no dia-a-dia como profissional de TI. Eu li um post outro dia em que o autor disse uma coisa que me coçou:

Se você é um usuário Linux, o Terminal é provavelmente a ferramenta mais poderosa que você já teve. Mas o problema do Terminal é que você precisa aprender a usá-lo se quiser se beneficiar dele. - Mauro Garcia

aí eu: SIMMMMMMMMMM

Isso me coçou a querer compartilhar um pouco do que aprendi por aí com os meus colegas, e então trouxe para cá também. Saber de algumas dessas coisas fazem diferença no meu dia-a-dia como desenvolvedor de software.

Espero que possa ajudá-los a se sentirem um pouco mais confortáveis da próxima vez que precisarem abrir o terminal.

Mas antes de começarmos... uma dica para não-nativos do inglês:

Pensar em inglês ajuda a assimilar os comandos!

Se você for como eu, não-nativo do inglês, acredito que entenderá melhor o que quero dizer. Vamos entender com um exemplo, o comando pwd é para Print Working Directory. O que no meu idioma (braziliano) seria algo como edt (Escrever o Diretório de Trabalho).

Acho que esse exemplo ajuda a deixar claro que pensar sobre o que você quer fazer em inglês ajuda a assimilar o que está sendo feito. Ajudando a internalizar o que você deseja fazer. Tal como acontece com ls (list) oucd (change directory).

Comandos básicos

Aqui alguns comandos práticos a se saber. Utilizei um comando para descrever eles, veremos a frente qual.

mv - mover (renomear) arquivos
cp - copia arquivos e diretórios
rm - remove arquivos ou diretórios
ls - lista o conteúdo do diretório
pwd - imprime o nome do diretório atual / de trabalho
mkdir - cria diretórios, cria um diretório
rmdir - remove diretórios vazios, exclui um diretório
cat - concatena arquivos e imprime na saída padrão
tac - concatena e imprime arquivos ao contrário
more - filtro de leitura de arquivo para visualização de crt
less - oposto de mais
chown - altera o proprietário e o grupo do arquivo, altera a propriedade de um arquivo
chmod - altera bits de modo de arquivo, altera as permissões de um arquivo
chattr - altera atributos de arquivo em um sistema de arquivos Linux
curl - transferir um URL
wget - O downloader de rede não interativo.
tar - um utilitário de arquivamento
gzip - comprime ou expande arquivos, uma espécie de Linux 'WinRar'
ping - envia ICMP ECHO_REQUEST para hosts de rede
sort - classificar linhas de arquivos de texto
filter - interface de filtro de conversão de arquivo do Cups
uniq - relatar ou omitir linhas repetidas
history - Biblioteca de História GNU
top - exibe processos Linux
ps - relata um instantâneo dos processos atuais.
pkill - procura ou sinaliza processos com base no nome e outros atributos
ssh - cliente de login remoto OpenSSH
git - controle de versão distribuído

Todos comandos podem ser concatenados no terminal, é uma questão de saber como fazê-los. O poder de concatenar comandos nos dá um poder incrível com a linha de comando.

Por exemplo, digamos que queremos encontrar quais comandos estão no histórico, mas existem muitas repetições e informações irrelevantes no momento (como os parâmetros)... Poderiamos fazer unificando 4 comandos na seguinte ordem: history | cut --delimiter=" " -f 4 | sort | uniq.

Ou talvez você queira usar uma imagem como ícone... Você poderia:

# 1) baixar a imagem e 2) encodá-la na hora.
curl https://duckduckgo.com/i/bfc48a09.jpg --output - | base64 -
# agora está pronta para utilizar em uma tag HTML 😎

Aqui está uma bruxaria preciosa para a próxima vez que sua memória virtual se esgotar:

xkill - matar um cliente por seu recurso X. Basicamente, quando você proclama este comando, a ponta do seu querido mouse se torna a varinha de Alvo Dumbledore, onde quer que você clique (com o botão esquerdo), aquilo onde você clicou, morre 😱.

Comandos que nos ajudam a se ajudar

whatis - exibir descrições de página de manual de uma linha. Ajuda a identificar a finalidade de qualquer comando em segundos. Foi este o comando que citei acima.
which - localize um comando.
whereis - localize os arquivos binários, de origem e de página de manual para um comando.
man - o manual do programa. Uma interface para os manuais de referência do sistema. This's the way! para qualquer coisa. As informações relevantes sobre o programa estarão no manual.

# Tente no seu terminal
$ whatis whatis which whereis man

Tenha seus próprios snippets

Um snippet é uma função criada para servir a um propósito. Em Bash/shellscript nós temos os famosos "one-liners". Recomendo tê-los por dois motivos:

Medo: eles obviamente assustam. Uma cadeia de comandos interligados para servir a um propósito? Eu acho incrível e aterrorizante. ~~Sempre que me vejo rodando um penso que se quebrar na metade vai deletar meu sistema todo 😅.~~ Com isso você vai ficando cautelo-so com o terminal, pois, até um martelo faz mal se não for utilizado da forma correta.
E novidades: você será exposto a novas soluções e também a novas formas de utilizar o que já conhece.

Vou deixar no roda-pé algumas referências, lugares em que podemos dar uma conferida nesses "one-liners". 😆

Prática!

A melhor forma de aprender e assimilar é fazendo. Então vamos coloca em prática o que vimos até agora por meio de alguns exercícios. Para isso vamos utilizar o Capture The Flag Bandit da OverTheWire.

O Capture The Flag é um estilo de competição que envolve diversas competências para a resolução de desafios relacionados à infosec, com o objetivo de capturar a bandeira (normalmente um código) e pontuar. No Bandit os níveis do CTF acontecem em uma máquina remota, no qual nos conectaremos pelo terminal através da ssh.

O Bandit nos ajudará a colocar em prática e lapidar nossas habilidades com o Terminal. Daqui em diante, é com vocês. Boa sorte!

#Partiu

Feedbacks 💙

Faltou alguma coisa, ou estava errada, ou você tem alguma sugestão? Por favor, me deixe saber suas opiniões!

One-liners

Credits, fonts and articles:

The Power Behind The Linux Terminal

Anderson Bosa — Mon, 15 Mar 2021 15:45:28 +0000

🇧🇷 Brazilian Version

Introduction
Basic commands
Commands that help us help each other
Have your own Snippets
Practice!

Introduction

Search, differentiate, analyze, share, unzip, encrypt a file, access a cloud computer, convert a video to gif, etc. These are some of the possible things to do with the command line.

The terminal is a magic wand to interact with the computer's resources. Allowing interaction practically and flexibly, which makes it a very powerful tool.

Basically on all operating systems (e.g., Windows, Android, Mac and etc.), the command line is a text interface to communicate with the computer (or device).

Also known as shell,console, prompt, and among other names, the terminal can be frightening and confusing at first contact. Like all new knowledge, in the beginning, there may be more difficulties. However, as we overcome these barriers, we are faced with our evolution.

Knowing how to use the terminal can be essential when trying to deal with the problems that pop up daily as an IT professional. I read a post the other day when the author said something that itched me:

If you are a Linux user, Terminal is probably the most powerful tool you have ever had. But the problem with Terminal is that you need to learn how to use it if you want to benefit from it. - Mauro Garcia

me: YYEESSSS

It scratched me to want to share a little of what I learned out there with my colleagues. And then I brought it here too. Knowing some of these things makes a difference in my day-to-day life as a software developer.

I hope I can help you feel a little more comfortable the next time you need to open the terminal.

But before we start ... a tip for non-native speakers of English:

Thinking in English helps to assimilate the commands!

If you are like me, non-native English, I believe you will understand better what I mean.

Let's understand with an example, the command pwd is for Print Working Directory. What in my language (Brazilian*) would be something like edt (Write the Working Directory).

I think this example helps to make it clear that thinking about what you want to do in English helps to assimilate what is being done. Helping to internalize what you want to do. As with ls (list) or cd (change directory).

Basic commands

Here are some practical commands to know. I used a command to describe them, we'll see which one is ahead.

mv - move (rename) files
cp - copy files and directories
rm - remove files or directories
ls - list directory contents
pwd - print name of current/working directory
mkdir - make directories, create a directory
rmdir - remove empty directories, delete a directory
cat - concatenate files and print on the standard output
tac - concatenate and print files in reverse
more - filter for paging through text one screenful at a time
less - opposite of more. allows backward movement in the file as well as forward movement
chown - change file owner and group, change ownership of a file
chmod - change file mode bits, change permissions of a file
chattr - change file attributes on a Linux file system
curl - transfer a URL
wget - The non-interactive network downloader.
tar - an archiving utility
gzip - compress or expand files, sort of Linux 'WinRar'
ping - send ICMP ECHO_REQUEST to network hosts
sort - sort lines of text files
filter - cups file conversion filter interface
uniq - report or omit repeated lines
history - GNU History Library
top - display Linux processes
ps - report a snapshot of the current processes.
pkill - look up or signal processes based on name and other attributes
ssh - OpenSSH remote login client
git - the stupid content tracker

All commands can be concatenated in the terminal, it is a matter of knowing how to do them. The power to concatenate commands gives us incredible power with the command line.

For example, let's say we want to find which commands are in the history, but there are a lot of repetitions and irrelevant information at the moment (like the parameters) ... We could do it by unifying 4 commands in the following order: history | cut --delimiter=" " -f 4 | sort | uniq.

Or maybe you want to use an image as an icon ... You could:

# 1) download the image and 2) encode it on the fly.
curl https://duckduckgo.com/i/bfc48a09.jpg --output - | base64 -
# is now ready to use in an HTML tag 😎

Here is precious witchcraft for the next time your virtual memory runs out:

xkill - kill a client by its X resource. Basically when you proclaim this command the point of your mouse will become Alvo Dumbledore's wand. Wherever you (left) click, the thing where you clicked dies.

Commands that help us help each other

whatis - display one-line manual page descriptions. It helps to identify the purpose of any command in seconds. This was the command I mentioned above.
which - locate a command.
whereis - locate the binary, source, and manual page files for a command.
man - the program manual. An interface to the system reference manuals. This is the way to anything. The relevant information about the program will be in the manual.

# Try on your terminal
$ whatis whatis which whereis man

Have your own Snippets

A snippet is a function designed to serve a purpose. In Bash / shellscript we have the famous "one-liners". I recommend having them for two reasons:

Fear: they obviously scare. A chain of interconnected commands to serve a purpose? I find it incredible and terrifying. ~~ Whenever I find myself running a I think that if it breaks in half it will delete my entire system 😅. ~~ With that you will be cautious with the terminal because even a hammer is bad if it is not used correctly.
And news: you will be exposed to new solutions and also to new ways of using what you already know.

I will leave some references on the wheel, places where we can check out these "one-liners". 😆

Practice!

The best way to learn and assimilate is by doing. So let's put into practice what we've seen so far through some exercises. For this we will use Capture The Flag Bandit from OverTheWire.

Capture The Flag is a style of competition that involves several skills to solve challenges related to infosec, to capture the flag (usually a code), and scoring. In Bandit the CTF levels take place on a remote machine, where we will connect via the terminal via ssh.

Bandit will help us to put into practice and polish our skills with the Terminal. From here on, it's up to you. Good luck!

#Start here!

Feedbacks 💙

Was something missing, or was it wrong, or do you have any suggestions? Please let me know your opinions!

DEV Community: Anderson Bosa

How to Configure Cursor with Java

Objective

Getting started

2. Shenanigans

3. Configure your Runtime ☺️

The Power Of Git Log: You don't know how to use it.

Table of Contents

TL;DR

Why I wrote this

What is git log?

The -G Option: Searching for Changes in Code

The -S Option: Tracking Additions and Removals of Lines

Key Differences Between -G and -S

Conclusion

Subdomain or Subfolder: Which Is Better for Your Site’s SEO?

What’s a Subdomain?

Pros of Using Subdomains

Cons of Using Subdomains

What’s a Subfolder?

Pros of Using Subfolders

Cons of Using Subfolders

Which Works Best for Your Site?

Final Thoughts

References

Do you know how to evaluate performance of your Java applications?

First, What Are Boxing and Unboxing?

Some Terms That Came Up

Why Does This Affect Performance?

Hands-On

Beware of Poorly Implemented Algorithms

Takeaways

My Conclusion

Você sabe avaliar performance de suas aplicações Java?

Primeiro, o que são Boxing e Unboxing?

Alguns nomes que apareceram

Por que isso afeta a performance?

Hands-on

Cuidado com Algoritmos Mal Implementados

Aprendizados

Minha conclusão

LGPD para devs

Índice

O que é a LGPD?

Qual a importância da LGPD?

Você Desenvolvedor, o que precisa saber?

Riscos do não cumprimento da LGPD

Onde Aprender Mais sobre a LGPD?

The "Something else" option in Linux installation

References

Revolutionizing Git Workflow: My Experience with aicommits

Thanks

References

How to use nodemon with VSCode debugger?

Table Of Contents

Intro

So how do I do it?

And it done!

andersonbosa / nodemon-vscode-tutorial

💬 About

🛠️ Technologies

🚀 Distribution

🤝 Contribution

👨‍💻 Author

📝 License

📊 Statistics

Stargazers

Forkers

| Did you like the repository? Give it a star! 😁

O poder por trás do terminal Linux

Choose your preferred language:

🇧🇷 Brazilian

Table of contents

Introdução

Mas antes de começarmos... uma dica para não-nativos do inglês:

Comandos básicos

Aqui está uma bruxaria preciosa para a próxima vez que sua memória virtual se esgotar:

Comandos que nos ajudam a se ajudar

Tenha seus próprios snippets

Prática!

The `-G` Option: Searching for Changes in Code

The `-S` Option: Tracking Additions and Removals of Lines

Key Differences Between `-G` and `-S`