3 dicas essenciais para fazer entregas mais previsíveis

A previsibilidade nas entregas é um fator crucial que separa um desenvolvedor júnior de um sênior, e um dev que apenas programa de um profissional que gera confiança na gestão. Se você é um dev que cumpre o que promete, você demonstra comprometimento e maturidade profissional, qualidades que o colocam em posição de subir de nível na carreira.

Mas o que é uma entrega previsível?

Uma entrega previsível é aquela que gera previsibilidade para a gestão, permitindo que eles façam um planejamento baseado naquilo que você informa.

Um dev que não tem essa noção de previsibilidade atrapalha o planejamento da equipe e o andamento do todo, o que é um sinal de imaturidade profissional. Para evitar isso e se tornar um profissional mais confiável, siga estas três dicas fundamentais:

1. Aprenda a planejar o seu trabalho

O planejamento é a base de tudo. Muitos devs, especialmente os iniciantes e plenos, cometem o erro de negligenciar essa etapa, muitas vezes por uma interpretação equivocada de metodologias ágeis.

Planejar não é burocracia inútil é uma etapa essencial (o próprio Scrum tem a reunião de Planning). Sem planejamento, tudo o que você faz é baseado em um eu acho ou em um sentimento (feeling).

Riscos da falta de planejamento

Esquecimento: Você foca em um ponto e esquece de outras coisas importantes que estavam "só na sua cabeça".

Acúmulo de trabalho: O trabalho que faltou se acumula para o final do prazo, resultando em trabalho mal feito ou gambiarra.

Como planejar de forma eficaz

Um planejamento bem feito permite que você entenda o tamanho das encrencas e tenha uma visão geral do que precisa ser feito.

1. Defina um tempo fixo (time box):

Estabeleça um limite de tempo (ex: um dia) para o planejamento. Isso é crucial para evitar que você se afogue em planejamento e esqueça de trabalhar.

2. Entenda o problema e o requisito:

Antes de escrever código, pare para entender o porquê da alteração e a necessidade do usuário. Entender o problema é o primeiro passo antes de discutir esforço ou tempo.

3. Divida o problema em etapas:

Toda solução pode ser dividida em partes menores. Essa divisão ajuda a enxergar o trabalho, identificar o que pode ser feito em paralelo e o que é pré-requisito.

4. Crie uma lista de tarefas:

Transforme as etapas divididas em pequenas tarefas de desenvolvimento (ex: falar com o arquiteto, alterar sistema de cadastro, fazer cálculo no relatório).

Ter uma lista de tarefas é essencial; sem ela, você vai esquecer alguma coisa e terá retrabalho no final.

2. Aprenda a orçar o esforço

O orçamento de esforço é uma cobrança que acompanhará o dev por toda a carreira. A empresa precisa dessa previsibilidade para Time to Marketing (não perder o bonde da venda), questões regulatórias e para o gestor administrar o budget (gerenciar o pagamento da equipe).

Orçamento é palpite, não premonição

É fundamental entender que o orçamento sempre será um palpite (chute), independentemente da metodologia (pontos, Fibonacci, etc.).

Previsão é diferente de premonição. Você não está adivinhando o futuro, mas sim dando uma expectativa baseada nas informações que possui.

Orçar é uma habilidade que exige treino e prática constante, como chutar no futebol.

Como orçar com mais precisão

1. Tenha um planejamento:

Não existe orçamento sem planejamento e sem uma lista de tarefas. Tentar orçar uma "coisona" (tarefa gigante) é como chutar em um gol pequeno, a chance de erro é altíssima.

2. Garanta a granularidade:

Quanto mais detalhe e mais granular forem as tarefas, maior será a chance de acertar e, geralmente, maior será o orçamento (podendo ser 2x ou mais que o chute inicial).

3. Orce em grupo (sempre que possível):

Fazer orçamentos em grupo (como na Planning do Scrum) é muito mais eficiente do que fazer sozinho, pois permite um duplo check e a comparação de diferentes pontos de vista.

4. Conheça sua capacidade atual:

O autoconhecimento é vital. Se você não tem noção do quanto consegue produzir, você sempre errará o orçamento, superestimando ou subestimando o esforço necessário.

3. Comunique o status sempre que puder

Este é um erro comum de iniciantes: o medo de incomodar o gestor ou de dar a má notícia de um atraso.

O verdadeiro problema não é o atraso em si (a empresa tem tolerância), mas sim não avisar sobre o atraso com antecedência.

Se você avisa com dias ou semanas de antecedência, o gestor consegue negociar e tomar uma atitude. Se você avisa na véspera, não há mais tempo para nada.

A maior força de um profissional é conseguir assumir os seus erros e enxergar onde errou. Esconder a informação é agir como criança, não como adulto.

Comunicação em tarefas críticas

Quanto mais crítico é o que você faz, maior é a pressão e mais necessária se torna a sua comunicação. Sumir com uma tarefa crítica pode levar à sua substituição ou demissão. Se você não sabe se algo é crítico, pergunte; é sua obrigação buscar essa informação.

Estrutura da comunicação de status

Crie um ritual de comunicação, seja uma daily de 10-15 minutos ou um e-mail/mensagem diário, para manter o alinhamento e evitar surpresas.

A pauta da sua comunicação deve incluir:

• Visão Geral do andamento do trabalho.
• Progresso da atividade (o que avançou ou não).
• Possíveis atrasos (comunique com antecedência).
• Previsões novas (quanto tempo mais você precisa?).
• Bloqueios/Impedimentos (coisas que estão impedindo seu trabalho, como falta de acesso ou resposta), o gestor pode ajudar a resolver.

Considerações finais

Para colocar tudo isso em prática, comece a planejar e orçar suas atividades hoje, mesmo que a empresa não exija. Isso é um conhecimento que melhora sua empregabilidade e afeta diretamente sua carreira.

Além disso, facilite a vida do seu chefe ao invés de levar apenas um problema, leve o problema junto com uma solução proposta. Isso demonstra maturidade e comprometimento.

Todas essas habilidades de previsibilidade estão ligadas à Análise de Requisitos, que é tão fundamental para o dev quanto programar ou fazer testes unitários. Ao juntar a análise com a programação na sequência correta, você se torna um dev imparável que entrega qualidade e cumpre prazos na maioria das vezes.

Feito!

Workflow de branches em projetos ágeis: Boas práticas com Git Flow

Gerenciar branches de forma organizada é uma das práticas mais importantes em qualquer equipe de desenvolvimento. Um bom fluxo de versionamento garante rastreabilidade, previsibilidade nas entregas e reduz conflitos durante o ciclo de vida de cada Sprint.

Baseado no modelo Git Flow, o workflow que apresento aqui é uma adaptação moderna e prática, utilizada amplamente no mercado em equipes que trabalham com metodologias ágeis e ferramentas como Redmine, Jira, Trello ou GitHub/GitLab Issues.

1. Estrutura principal do repositório

O repositório segue duas principais linhas de desenvolvimento:

• master ou main:

contém o código estável e homologado, pronto para produção.

• develop:

linha de integração onde as novas funcionalidades e correções de Sprint são validadas antes da liberação.

A partir dessas duas branches centrais, todo o ciclo de desenvolvimento é organizado.

2. Criando branches de task (feature)

Cada nova task atribuída no sistema de gestão deve originar uma branch seguindo um padrão de nomenclatura padronizado. Isso facilita a rastreabilidade da entrega, especialmente quando o time é grande ou o projeto possui várias sprints paralelas.

O padrão recomendado é:

feature/sprintX/RTCY/TituloDaTask

Essa branch deve sempre ser criada a partir da branch develop atualizada, garantindo que a task comece sobre a base mais recente do projeto:

git checkout develop
git pull origin develop
git checkout -b feature/sprint5/RTC102/ImplementarAutenticacaoOAuth

Isso cria a branch da task a partir da develop atualizada.

3. Commits e Pull Request (PR)

Durante o desenvolvimento da task, os commits devem ser claros e objetivos, refletindo o progresso da implementação e dos testes unitários.

Ao concluir a task, realize o commit e o push final:

git add .
git commit -m "Finaliza implementação e testes unitários da autenticação OAuth"
git push origin feature/sprint5/RTC102/ImplementarAutenticacaoOAuth

Em seguida, abra um Pull Request (PR) para a branch develop e utilize o seguinte padrão de comentário:

[SPRINT5][RTC102][ImplementarAutenticacaoOAuth][feature]

Isso ajuda o time de revisão e o QA a identificar rapidamente o contexto da entrega.

4. Correção de bugs encontrados pelo QA

Caso o QA identifique algum bug durante os testes da Sprint, o desenvolvedor deve corrigir o problema na mesma branch da feature, mantendo o histórico da entrega.

Ao abrir um novo Pull Request ou atualizar o existente, utilize o seguinte padrão de comentário:

[SPRINT5][RTC102][ImplementarAutenticacaoOAuth][bug] Correção na validação do token

Esse formato indica que a PR refere-se a uma correção derivada da mesma task principal, mantendo o controle e a rastreabilidade no fluxo da Sprint.

5. Correções de bugs em produção

Para bugs que ocorrem em produção, a abordagem é diferente.

Essas correções devem ser baseadas diretamente na branch master ou main, garantindo que a correção seja aplicada sobre o código em execução.

A nomenclatura segue o padrão:

feature/bugfix/RTCX

Por exemplo:

feature/bugfix/RTC240

Crie a branch, aplique a correção, teste e envie o Pull Request de volta para a branch principal (master ou main).

Após aprovação e merge, é possível gerar uma tag de hotfix, caso necessário.

6. Encerramento da Sprint e versionamento

Ao final de cada Sprint, com todas as tasks revisadas e integradas à develop, é hora de gerar uma tag de versão.

A tag identifica o encerramento formal da Sprint e serve como ponto de referência no histórico do repositório.

O padrão sugerido é:

git tag -a v1.5 -m "Sprint 5 concluída"
git push origin v1.5

Esse versionamento facilita auditorias, rollback e acompanhamento de evolução entre as versões.

7. Benefícios desse workflow

Seguir esse modelo de workflow traz diversas vantagens:

• Clareza e rastreabilidade das entregas por Sprint.
• Redução de conflitos de merge.
• Facilidade na revisão de Pull Requests.
• Histórico limpo e versionamento controlado.
• Organização entre desenvolvimento, QA e deploy.

Considerações finais

Um bom gerenciamento de branches é mais do que uma convenção, é parte essencial da cultura de engenharia de software madura.

Trabalhar com um workflow bem definido baseado no Git Flow permite que o time mantenha consistência, colabore com eficiência e entregue software de qualidade em ciclos ágeis.

Ao aplicar esse processo com disciplina, cada Sprint se torna mais previsível, e o código entregue ganha estabilidade e confiabilidade, o que é o verdadeiro objetivo de um ciclo de desenvolvimento profissional.

Feito!

Sincronizando o seu projeto backend Java (Spring/Quarkus) com JUnit e Mockito no SonarQube

Manter a qualidade de código e medir a cobertura de testes é uma prática essencial em projetos backend modernos. O SonarQube é uma ferramenta robusta para essa finalidade, oferecendo relatórios de bugs, vulnerabilidades, code smells e cobertura de testes unitários.

No presente artigo, vamos configurar o SonarQube para um projeto Java (Spring ou Quarkus) que utiliza JUnit e Mockito, e entender como ignorar pacotes que não envolvem regras de negócio, como Entity, Dto e Repository.

A premissa é ter o Docker e Docker-Compose instalados, caso ainda não tenha, verifique Instalando Docker e Docker Compose no Linux (qualquer distro) ou Instalando Docker no Windows 10

1. Subindo o SonarQube com Docker

O primeiro passo é subir o SonarQube localmente com o container oficial:

docker run -d --name sonarqube-backend -p 9000:9000 sonarqube:latest

Após iniciar, acesse o painel em: http://localhost:9000

O login padrão é admin / admin.

Altere a senha e gere um token de autenticação em:

My Account → Security → Generate Tokens

Copie e guarde o token, pois ele será utilizado na integração do projeto.

2. Configurando o projeto backend

   O projeto backend pode ser utilizando o framework Spring Boot ou Quarkus, ambos utilizando Maven como ferramenta de build.

   Certifique-se de que o projeto possui testes unitários configurados com JUnit 5 e Mockito, caso ainda não implementou os testes unitários utilizando JUnit e Mockito (InjectMocks e Mock), implemente para poder continuar com os demais procedimentos a seguir.

3. Configuração no application.properties

Para que o SonarQube consiga autenticar e se comunicar com o projeto, adicione as propriedades de configuração no application.properties:

sonar.host.url=http://localhost:9000 sonar.login=TOKEN_AQUI

Essas configurações permitem que o Maven utilize o token de autenticação diretamente.

4. Arquivo sonar-project.properties

Crie o arquivo sonar-project.properties na raiz do projeto com o seguinte conteúdo:

sonar.projectKey=Projeto-Backend
sonar.projectName=Projeto-Backend
sonar.projectVersion=1.0
sonar.sources=src/main/java
sonar.tests=src/test/java
sonar.language=java
sonar.sourceEncoding=UTF-8
sonar.host.url=http://localhost:9000
sonar.login=TOKEN_AQUI
sonar.branch.name=develop

# Caminho do relatório de cobertura
sonar.junit.reportPaths=target/surefire-reports
sonar.jacoco.reportPaths=target/jacoco.exec
sonar.java.binaries=target/classes

# Ignorar pacotes que não envolvem regra de negócio
sonar.exclusions=**/entity/**,**/model/**,**/dto/**,**/repository/**

A propriedade sonar.exclusions é fundamental para manter o foco da análise nos pacotes de serviços, regras de negócio e controladores, evitando que o SonarQube penalize a cobertura de testes em classes de domínio simples.

5. Configurando o plugin Sonar no Maven

Adicione o plugin SonarQube no arquivo pom.xml caso ainda não esteja presente:

<build>
  <plugins>
    <plugin>
      <groupId>org.sonarsource.scanner.maven</groupId>
      <artifactId>sonar-maven-plugin</artifactId>
      <version>3.10.0.2594</version>
    </plugin>
  </plugins>
</build>

6. Executando os testes e análise

Com tudo configurado, o fluxo para rodar os testes e enviar os resultados ao SonarQube é simples:

Execute os testes unitários:

mvn clean test

Se todos os testes passarem, execute a análise do Sonar:

mvn sonar:sonar

O Maven irá coletar os resultados de cobertura gerados pelo JUnit/Mockito e enviar para o servidor SonarQube, usando o token informado.

7. Visualizando os resultados

Acesse novamente o painel do SonarQube (http://localhost:9000) e verifique seu projeto.

Você verá:

Cobertura de testes unitários (Jacoco)

Code smells e bugs

Duplicações

Segurança e manutenibilidade do código

Os pacotes Entity, Dto e Repository estarão excluídos da cobertura, mantendo o foco nas classes com lógica de negócio.

Considerações finais

Integrar o JUnit + Mockito com o SonarQube é uma das práticas mais eficazes para manter um backend saudável e bem testado.

Ao utilizar o SonarQube em container Docker, a análise fica portátil e fácil de reproduzir em qualquer ambiente.

Essa configuração também é compatível com pipelines CI/CD, permitindo que a análise de qualidade seja automatizada em cada push, garantindo métricas consistentes e rastreabilidade da evolução do código.

Feito!

Sincronizando seu projeto frontend (Angular) com testes unitários (Jest) no SonarQube

Em ambientes corporativos, a análise de qualidade de código e cobertura de testes é essencial para garantir a confiabilidade das aplicações. O SonarQube é uma das ferramentas mais usadas para isso, e pode ser facilmente integrado a projetos Angular com Jest.

No presente artigo, vamos ver o passo a passo para configurar essa integração, incluindo o uso do SonarQube em container Docker, a execução dos testes unitários e a geração de relatórios de cobertura.

A premissa é ter o Docker e Docker-Compose instalados, caso ainda não tenha, verifique Instalando Docker e Docker Compose no Linux (qualquer distro) ou Instalando Docker no Windows 10

1. Subindo o SonarQube com Docker

Primeiro, vamos utilizar a imagem oficial do SonarQube. Execute o comando abaixo:

docker run -d --name sonarqube-frontend -p 9000:9000 sonarqube:latest

O SonarQube estará acessível em http://localhost:9000.

No primeiro acesso, o login padrão é admin / admin.

Após logar, altere a senha e gere um token de autenticação no menu:

My Account → Security → Generate Tokens

Guarde esse token, pois ele será utilizado no arquivo de configuração do scanner.

2. Instalando o Jest e o Sonar Scanner

No seu projeto Angular, instale o Jest e o Sonar Scanner globalmente e localmente para garantir compatibilidade:

Instalar o sonar-scanner globalmente

npm install -g sonar-scanner

Instalar o sonar-scanner como dependência de desenvolvimento

npm install --save-dev sonar-scanner

Se o Jest ainda não estiver configurado no projeto Angular:

npm install --save-dev jest @types/jest jest-preset-angular

Em seguida, adicione o script de testes no package.json:

"scripts": {
  "test": "jest --silent",
  "test:coverage": "jest --coverage",
  "sonar": "sonar-scanner"
}

3. Configurando o arquivo sonar-project.properties

   Crie o arquivo sonar-project.properties na raiz do projeto Angular com o seguinte conteúdo:

   
   sonar.projectKey=Nome-Projeto-Frontend
   sonar.projectName=Nome-Projeto-Frontend
   sonar.projectVersion=1.0
   sonar.sources=src
   sonar.language=ts
   sonar.sourceEncoding=UTF-8
   sonar.host.url=http://localhost:9000
   sonar.login=TOKEN_AQUI
   sonar.branch.name=develop
   
   # Diretório de relatórios do Jest
   sonar.javascript.lcov.reportPaths=coverage/lcov.info
   
   

   O campo sonar.javascript.lcov.reportPaths é essencial para que o SonarQube consiga ler a cobertura de testes gerada pelo Jest.

4. Executando os testes e enviando o relatório

Antes de executar o SonarQube, é necessário garantir que os testes unitários estão passando e que o relatório de cobertura foi gerado corretamente.

Execute os testes normalmente:

npx jest --silent

Se todos os testes passarem, gere o relatório de cobertura:

Isso criará uma pasta coverage na raiz do projeto com o arquivo lcov.info dentro de coverage/lcov-report.

5. Enviando os resultados ao SonarQube

Com os testes e cobertura prontos, execute o comando abaixo:

npm run sonar

O sonar-scanner lerá as configurações do arquivo sonar-project.properties e enviará o relatório para o servidor do SonarQube.

Ao finalizar, acesse o painel do SonarQube e verifique as métricas do seu projeto, incluindo:

Qualidade do código TypeScript

Cobertura de testes Jest

Bugs, vulnerabilidades e code smells

Dica: executando no Git Bash (Windows)

Se você estiver no Windows, use o Git Bash para simular um ambiente Linux.

O comando sonar-scanner funciona normalmente nesse terminal, o que facilita a integração em ambientes de desenvolvimento heterogêneos.

Considerações finais

Integrar o Jest com o SonarQube é uma prática que eleva o nível de qualidade do seu projeto Angular.

Essa integração permite visualizar métricas detalhadas, acompanhar a evolução da cobertura de testes e identificar pontos críticos no código.

Com essa configuração, seu pipeline local ou CI/CD estará preparado para medir qualidade de forma contínua, garantindo um código mais limpo, seguro e sustentável.

Feito!

Configurando o Personal Access Token (PAT) no Azure DevOps e GitHub

Quando você trabalha com integrações seguras entre pipelines, repositórios e automações, é comum precisar autenticar via Personal Access Token (PAT), uma chave de acesso pessoal que substitui a senha de login, garantindo mais segurança e controle sobre as permissões.

No presente artigo, você vai aprender como gerar, converter e configurar um PAT no Azure DevOps e também como usar o mesmo conceito no GitHub.

Gerando o Personal Access Token (PAT) no Azure DevOps

1. Acesse o portal do Azure DevOps https://azure.microsoft.com
2. Faça login com sua conta.
3. No canto superior direito, clique na sua foto de perfil e selecione Security (ou “Segurança”).
4. No menu lateral, escolha Personal Access Tokens.
5. Clique em New Token.
6. Dê um nome para identificar o token (ex: Token-Pipeline ou Token-Pessoal
7. Defina a data de expiração — prefira um período longo (como 1 ano) se for um uso contínuo.
8. Selecione os escopos (permissões) necessários, como:

Code (Read & Write) para acesso a repositórios;

Build (Read & Execute) para pipelines;

Packaging (Read) para artefatos.

9. Clique em Create.

Importante: copie o token gerado imediatamente, ele será exibido apenas uma vez.

Convertendo o PAT em Base64

Após gerar o token, será necessário convertê-lo para o formato Base64, que é o padrão usado em autenticação HTTP Basic.

Você precisará do seu login (e-mail ou nome de usuário) e do PAT gerado.

No PowerShell:

[Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes("LOGIN:PAT"))

Ou no Git Bash:

echo -n "LOGIN:PAT" | base64

Substituir o LOGIN e PAT, pelo seu login e token gerado, respectivamente.

Configurando o PAT no arquivo .gitconfig

Após obter o resultado em Base64, você pode configurar seu Git local para utilizar o token automaticamente nas conexões com o Azure DevOps.

Abra o arquivo de configuração global do Git: ~/.gitconfig

Adicione a seguinte linha dentro da seção [http]:

[http "https://dev.azure.com/"] extraHeader = Authorization: Basic PAT_BASE64

Substitua PAT_BASE64 pelo valor obtido na conversão em Base64.

E no GitHub?

O GitHub também utiliza Personal Access Tokens como método de autenticação em vez de senhas.

O processo é semelhante:

1. Acesse https://github.com/settings/tokens
2. Clique em Generate new token
3. Escolha o escopo (geralmente repo e workflow são os mais usados).
4. Copie o token gerado.
5. Converta-o da mesma forma:
echo -n "LOGIN:PAT" | base64
6. Adicione ao .gitconfig (substituindo o domínio pelo do GitHub):
[http "https://github.com/"] extraHeader = Authorization: Basic PAT_BASE64

Considerações finais

O uso do Personal Access Token (PAT) é uma prática recomendada para garantir segurança e controle de acesso em ambientes de integração contínua e repositórios Git.

Com ele, você:

Evita expor senhas reais;

Controla permissões específicas;

Automatiza autenticações em pipelines e scripts;

Pode revogar acessos rapidamente se necessário.

Manter o PAT seguro e criptografado é fundamental, trate-o como uma senha sensível e nunca o compartilhe em código público.

Feito!

Como adicionar o certificado de uma API de terceiros para testar localmente usando o Keytool

Ao integrar uma API de terceiros em um projeto Java, especialmente durante o desenvolvimento local, é comum encontrar erros relacionados a SSL, como:

javax.net.ssl.SSLHandshakeException: sun.security.validator.ValidatorException:
PKIX path building failed: unable to find valid certification path to requested target

Esse erro ocorre quando o certificado da API não é reconhecido pela JVM, geralmente porque é um certificado autoassinado ou emitido por uma autoridade que ainda não está no truststore padrão do Java.

Para resolver isso, é necessário importar o certificado no keystore de confiança da JVM, usando a ferramenta keytool.

O que é o Keytool

O keytool é uma ferramenta de linha de comando que faz parte do JDK.

Ele permite gerenciar keystores (repositórios de certificados e chaves) utilizados pela JVM para autenticação SSL/TLS.

Importante:

O keytool já está disponível nativamente tanto no Linux quanto no Git Bash no Windows (desde que o JDK esteja corretamente instalado e configurado no PATH).

Etapas para importar o certificado no ambiente local

1. Obtenha o certificado da API de terceiros

Você pode exportar o certificado diretamente pelo navegador.

No Google Chrome, por exemplo:

1. Acesse a URL da API (por exemplo: https://api.dominio.com)

2. Clique no cadeado ao lado da barra de endereço

3. Selecione "Detalhes do certificado"

4. Escolha um local para salvar com nome "nome-api-cert.cert" e no tipo selecionar "binário codificado por DER, certificado único" e clica no botão Exportar

2. Localize o cacerts da JVM

O arquivo cacerts é o truststore padrão do Java e fica dentro da pasta lib/security da sua instalação do JDK.

Windows com Git Bash: /c/Program Files/Java/jdk-17/lib/security/cacerts

Linux: /usr/lib/jvm/java-17-openjdk/lib/security/cacerts

Dica: se estiver usando o Git Bash, pode navegar até o diretório do JDK usando comandos Linux normalmente.

3. Execute o comando do Keytool para importar

No terminal (Git Bash ou Linux), rode o seguinte comando:

keytool -importcert -trustcacerts -alias api-terceiro -file /caminho/onde/salvou/nome-api-cert.cert -keystore "$JAVA_HOME/lib/security/cacerts" -storepass changeit

Explicando os parâmetros:

Parâmetro	Descrição
-importcert	Indica que você quer importar um certificado
-trustcacerts	Confirma que é um certificado confiável
-alias	Nome de identificação do certificado dentro do keystore
-file	Caminho do arquivo .cer que será importado
-keystore	Caminho do keystore onde será armazenado (geralmente cacerts)
-storepass	Senha do keystore (padrão do Java é changeit)

Ao ser questionado se deseja confiar no certificado, digite yes e pressione Enter.

3. Validar se o certificado foi importado corretamente

Após a importação, verifique se o certificado está presente no keystore com:

keytool -list -keystore "$JAVA_HOME/lib/security/cacerts" -alias api-terceiro -storepass changeit

Se aparecer o nome do certificado e o emissor (issuer), significa que a importação foi bem-sucedida.

4. Reinicie a aplicação

Depois de importar o certificado, reinicie a aplicação Java ou o servidor (por exemplo, Spring Boot, Quarkus ou Tomcat) para que as alterações entrem em vigor.

Boas práticas

Evite editar diretamente o cacerts da JVM de produção.

O ideal é criar um keystore separado, como custom-truststore.jks, e apontar para ele via propriedades de sistema:

-Djavax.net.ssl.trustStore=/caminho/custom-truststore.jks
-Djavax.net.ssl.trustStorePassword=changeit

Controle de versão:

Nunca coloque certificados ou arquivos .jks diretamente no repositório Git.

Guarde-os em local seguro e documente o procedimento de importação.

Ambiente limpo:

Caso use múltiplas versões do Java, verifique sempre o $JAVA_HOME correto antes de importar o certificado.

Considerações finais

Adicionar o certificado de uma API de terceiros no ambiente local é uma prática comum e necessária quando o SSL não é reconhecido pela JVM.

Usando o keytool, você pode facilmente importar o certificado e eliminar erros de handshake durante o desenvolvimento.

O Git Bash no Windows funciona exatamente como um terminal Linux, e como o keytool é nativo do JDK, o procedimento é o mesmo nos dois sistemas.

Com isso, você garante que sua aplicação consiga se comunicar com segurança com APIs externas, mesmo em ambiente de testes.

Feito!

Conectando ao MS SQL Server com autenticação do usuário do Windows (Windows Authentication) em Java

Ao trabalhar com sistemas corporativos que utilizam o Microsoft SQL Server, é comum encontrar ambientes configurados para autenticação integrada do Windows. Isso significa que o acesso ao banco de dados é feito com base nas credenciais do usuário logado no sistema operacional, dispensando o uso de nome de usuário e senha definidos diretamente no banco.

Quando desenvolvemos aplicações Java que precisam se conectar ao SQL Server usando esse tipo de autenticação, é necessário realizar uma configuração específica no driver JDBC. Caso contrário, a aplicação não conseguirá autenticar corretamente o usuário e a conexão falhará.

Por que é necessário o arquivo msql-jdbc_auth.dll?

O driver oficial do SQL Server para Java, conhecido como Microsoft JDBC Driver for MS QL Server, oferece suporte à autenticação integrada do Windows através de uma biblioteca nativa chamada msql-jdbc_auth.dll.

Essa DLL atua como uma ponte entre o Java e as APIs do Windows responsáveis pela autenticação. Sem ela, o Java não teria acesso ao contexto de segurança do sistema operacional, e a tentativa de conexão com autenticação integrada resultaria em erro.

Em resumo, o Java precisa desse componente nativo para poder "herdar" as credenciais do usuário logado e repassá-las ao SQL Server de forma segura.

Passo a passo para configurar

1. Download o driver JDBC oficial

Acesse o site oficial da Microsoft e baixe o driver JDBC mais recente.

No momento da escrita deste artigo, a versão disponível é a 12.8.1, e o link direto de download é: https://go.microsoft.com/fwlink?linkid=2283744

2. Descompactar o pacote

Após o download, descompacte o arquivo. Dentro da pasta extraída você encontrará o driver mssql-jdbc-12.8.1.jar (ou .jre11, .jre17, conforme sua versão do Java) e também a biblioteca nativa msql-jdbc_auth-12.8.1.x64.dll.

3. Copiar a DLL para o diretório correto

Copie o arquivo msql-jdbc_auth-12.8.1.x64.dll para o diretório bin da instalação do Java.

Exemplo de caminho no Windows:

C:\Program Files\Java\jdk-17\bin

Esse diretório faz parte do java.library.path, o que garante que a JVM consiga localizar a DLL durante a execução.

4. Configurar a string de conexão

A string de conexão deve informar que será usada a autenticação integrada.

Exemplo:

String connectionUrl = "jdbc:sqlserver://localhost:1433;"
+ "databaseName=MinhaBase;"
+ "integratedSecurity=true;";
Connection conn = DriverManager.getConnection(connectionUrl);

Para projetos Spring Boot, configure no arquivo application.properties:

spring.datasource.url=jdbc:sqlserver://IPSERVIDORDBMSSQLSERVER:1433;databaseName=MinhaBase;integratedSecurity=true;
spring.datasource.driver-class-name=com.microsoft.sqlserver.jdbc.SQLServerDriver

Caso use Quarkus, a configuração fica assim:

quarkus.datasource.jdbc.url=jdbc:sqlserver://IPSERVIDORDBMSSQLSERVER:1433;databaseName=MinhaBase;integratedSecurity=true;
quarkus.datasource.jdbc.driver=com.microsoft.sqlserver.jdbc.SQLServerDriver

Observe o parâmetro integratedSecurity=true, que é o que ativa o uso da DLL para autenticação.

5. Executar a aplicação

Com a DLL no diretório correto e o driver JDBC configurado no classpath, sua aplicação Java será capaz de se conectar ao SQL Server utilizando as credenciais do usuário do Windows atual.

Configuração para Linux com Windows Authentication

Em sistemas Linux, a autenticação integrada não funciona nativamente com a DLL, pois ela é específica do Windows.

Nesse caso, o método recomendado é usar Kerberos, o mesmo protocolo que o Active Directory utiliza para autenticação entre domínios.

Passos para configurar no Linux

1. Instale os pacotes necessários

Em distribuições baseadas em Debian/Ubuntu:

sudo apt install krb5-user libsasl2-modules-gssapi-mit

No Fedora:

sudo dnf install krb5-workstation
2. Configure o arquivo /etc/krb5.conf

Adicione o domínio e o servidor KDC da sua rede corporativa.

Exemplo:

[libdefaults]
    default_realm = MINHAEMPRESA.LOCAL
    dns_lookup_kdc = true
    dns_lookup_realm = true

[realms]
    MINHAEMPRESA.LOCAL = {
        kdc = dc1.minhaempresa.local
    }

3. Obtenha um ticket Kerberos com seu usuário do domínio
kinit usuario@MINHAEMPRESA.LOCAL

Após autenticar, você pode confirmar o ticket com:

klist
4. Configure a conexão JDBC

No application.properties (Spring Boot ou Quarkus), a URL deve indicar o uso do principal Kerberos:

Spring

spring.datasource.url=jdbc:sqlserver://IPSERVIDORDBMSSQLSERVER:1433;databaseName=MinhaBase;authenticationScheme=JavaKerberos;
spring.datasource.driver-class-name=com.microsoft.sqlserver.jdbc.SQLServerDriver

Quarkus

quarkus.datasource.jdbc.url=jdbc:sqlserver://IPSERVIDORDBMSSQLSERVER:1433;databaseName=MinhaBase;authenticationScheme=JavaKerberos;
quarkus.datasource.jdbc.driver=com.microsoft.sqlserver.jdbc.SQLServerDriver

A opção authenticationScheme=JavaKerberos instrui o driver JDBC a usar o ticket obtido via kinit.

Considerações finais

Essa configuração é especialmente útil em ambientes corporativos onde a política de segurança exige Single Sign-On (SSO) e o gerenciamento centralizado de permissões. Além disso, evita o armazenamento de senhas no código-fonte ou em arquivos de configuração, o que aumenta a segurança da aplicação.

Vale lembrar que a autenticação integrada funciona apenas quando a aplicação Java está sendo executada em um ambiente Windows. Para servidores Linux, é necessário configurar o Kerberos e utilizar parâmetros adicionais no driver.

Em resumo, a presença da DLL msql-jdbc_auth é fundamental para que o Java consiga usar a autenticação nativa do Windows ao se conectar ao MS SQL Server. Com ela corretamente posicionada e o driver JDBC configurado, o processo de autenticação se torna transparente e seguro, aproveitando os recursos já disponíveis no sistema operacional.

Feito!

Como resolver o erro "boot failed to start gdm.service" no Ubuntu

Se ao iniciar o Ubuntu você se deparou com a mensagem "boot failed to start gdm.service", é bem provável que o problema esteja relacionado à partição raiz (/) cheia. Quando o sistema atinge 100% de uso da partição principal, diversos serviços deixam de funcionar corretamente — entre eles, o GDM, responsável pela tela de login gráfico.

A seguir, veja como corrigir esse problema de forma segura e eficiente.

1. Acesse o terminal virtual (TTY)

Como o ambiente gráfico não está inicializando, é necessário usar o terminal virtual.

Pressione Ctrl + Alt + F2 (ou F3, F4...) para abrir o TTY.

Em seguida, faça o login com seu nome de usuário e senha.

2. Verifique o uso da partição raiz

Depois de acessar o terminal, digite:

df -h

Esse comando mostra o uso de cada partição. Verifique se a partição / (raiz) está com 100% de utilização. Se estiver, é hora de liberar espaço.

3. Limpe o cache de pacotes APT

O cache do APT pode ocupar bastante espaço, especialmente se você realiza muitas atualizações. Execute:

sudo apt clean
sudo apt autoremove

Esses comandos removem pacotes e dependências que não são mais necessários.

4. Remova versões antigas do kernel

Versões antigas do kernel podem consumir vários gigabytes. Para removê-las, execute:

sudo apt autoremove --purge

Isso limpa completamente pacotes antigos e libera espaço de forma significativa.

5. Limpe arquivos de log antigos

Os logs do sistema também podem crescer rapidamente. Para mantê-los sob controle, use:

sudo journalctl --vacuum-size=50M

Esse comando limita o tamanho dos logs a 50 MB, descartando os mais antigos.

6. Confirme se o espaço foi liberado

Execute novamente:

df -h

Se o uso da partição diminuiu, ótimo, o problema provavelmente foi resolvido. Caso ainda esteja cheia, siga para as próximas etapas.

7. Reinstale o ambiente gráfico (se necessário)

Se mesmo após liberar espaço o erro persistir, talvez o GDM ou o pacote do ambiente gráfico tenha sido corrompido. Nesse caso, reinstale-os:

sudo apt install --reinstall ubuntu-desktop
sudo apt purge gdm3
sudo apt install gdm3

Isso garante que todos os componentes necessários para o login gráfico estejam restaurados.

8. Reinicie o sistema

Por fim, reinicie o computador:

sudo reboot

Após o reinício,o erro "boot failed to start gdm.service" desaparecerá e o sistema deve carregar o ambiente gráfico normalmente.

Dica final: mantenha sempre um controle do uso de espaço em disco. Você pode usar ferramentas como o Baobab (Analisador de uso de disco) para identificar rapidamente o que está ocupando espaço e evitar que o problema volte a ocorrer.

Feito!

Cliente open source da AWS para containers

O desenvolvimento de containers está no coração da computação moderna, e a AWS deu um passo ousado ao lançar o Finch—um cliente de linha de comando open source que facilita a criação, execução e publicação de containers Linux em ambientes locais.

O que é o Finch?

Finch é uma ferramenta leve e extensível que combina componentes open source como:

• Lima: para virtualização em macOS
• nerdctl: uma alternativa ao Docker CLI
• containerd: runtime de containers
• BuildKit: para construção eficiente de imagens

Inicialmente lançado para macOS, o Finch agora oferece suporte completo para Windows e Linux, tornando-se uma solução multiplataforma para desenvolvedores que desejam trabalhar com containers de forma local e integrada.

Funcionalidades principais

• Construção de imagens com Dockerfiles
• Execução de containers localmente
• Push/pull de imagens para registries
• Gerenciamento de redes e volumes
• Suporte a aplicações multi-container via finch compose

No Linux, o Finch interage diretamente com o kernel usando namespaces e cgroups, sem necessidade de camadas de virtualização. Já no Windows e macOS, ele utiliza WSL2 e Virtualization Framework, respectivamente.

Instalação

No Debian e derivados, segue:

1.Importe a chave GPG:

curl -fsSL https://artifact.runfinch.com/deb/GPG_KEY.pub | sudo gpg --dearmor -o /usr/share/keyrings/runfinch-finch-archive-keyring.gpg

2.Adicione o repositório APT:

Para sistemas AMD64:

echo "deb [signed-by=/usr/share/keyrings/runfinch-finch-archive-keyring.gpg arch=amd64] https://artifact.runfinch.com/deb noble main" | sudo tee /etc/apt/sources.list.d/runfinch-finch.list

3.Atualize os pacotes e instale o Finch:

sudo apt update
sudo apt install runfinch-finch

Por que a AWS criou o Finch?

Segundo a equipe da AWS, a ideia surgiu da necessidade de uma ferramenta simples e padronizada para desenvolvimento de containers em ambientes locais. Em vez de depender de soluções comerciais ou montar ferramentas fragmentadas, o Finch oferece uma experiência coesa e baseada em padrões da indústria.

Comunidade e contribuições

O Finch é licenciado sob Apache 2.0 e está aberto a contribuições. A AWS incentiva desenvolvedores a participar no repositório oficial .

Finch representa uma abordagem moderna e colaborativa para o desenvolvimento de containers. Se você busca uma alternativa leve, open source e integrada ao ecossistema da AWS, vale a pena experimentar.

Feito!

14 anos de blog

O blog está completando hoje, 21 de Agosto de 2025, 14 anos!

Gostaria de agradecer a todos pelo prestígio e a paciência de ler os posts que são publicados. Espero continuar compartilhando conhecimentos no blog para nossos leitores. Continuem prestigiando e divulgando o blog Mundo da Computação Integral, assim aumentamos nossa comunidade.

Manipulando arquivos gigantes com Python

Quando trabalhamos com Python no dia a dia, é comum lidarmos com arquivos CSV ou Excel relativamente pequenos. Porém, em cenários de Data Science e Big Data, não é raro recebermos um arquivo que ultrapassa a casa dos gigabytes. E aí surge o problema: carregar tudo na memória de uma só vez pode simplesmente derrubar a sua máquina.

A boa notícia é que o Python tem ferramentas que permitem processar esses arquivos de forma inteligente e incremental. Hoje, vamos falar sobre o conceito de chunks.

O que são chunks?

De forma simples, um chunk é um pedaço do arquivo.

Ao invés de ler um CSV inteiro com pandas.read_csv(), podemos instruir o Pandas a carregar n linhas por vez, processar, salvar o resultado parcial e liberar memória. Assim, conseguimos trabalhar com arquivos gigantes sem precisar de um supercomputador.

Exemplo prático

Imagine que temos um arquivo transacoes.csv com 100 milhões de linhas. Queremos somar o valor total de uma coluna chamada valor.

Solução tradicional (não funciona bem em arquivos grandes):

import pandas as pd
# Isso pode travar o computador!
df = pd.read_csv("transacoes.csv")
print("Total:", df["valor"].sum())

Se o arquivo for grande demais, sua memória RAM não vai aguentar.

Solução com chunks:

import pandas as pd
total = 0
# Lendo o arquivo em blocos de 1 milhão de linhas
for chunk in pd.read_csv("transacoes.csv", chunksize=10**6):
    total += chunk["valor"].sum()

print("Total:", total)

Nesse caso:

chunksize=10**6 significa que o Pandas vai ler 1 milhão de linhas por vez.

Cada pedaço é processado, somado e descartado da memória.

Ao final, temos o total consolidado sem sobrecarregar o sistema.

Vantagens do processamento em chunks

• Trabalhar com arquivos enormes sem precisar expandir a RAM.
• Possibilidade de processamento incremental (ex: salvar resultados parciais).
• Aplicável a diversas operações: filtros, agregações, limpeza de dados, exportação em lotes.

Onde isso aparece na prática?

• Relatórios financeiros de grandes empresas.
• Logs de servidores com milhões de registros.
• Bases públicas gigantes, como dados do IBGE ou Kaggle.

Considerações finais

Trabalhar com chunks é quase um rito de passagem para quem está saindo do Python intermediário e entrando em projetos de nível avançado, onde eficiência importa tanto quanto clareza do código.

Feito!

Automação de tarefas com Python e Pandas

Imagine o seguinte cenário: toda semana você recebe relatórios de vendas em formato CSV e precisa consolidá-los em uma única planilha para gerar um resumo.

Fazer isso manualmente pode levar horas. Mas com o Pandas, é questão de segundos.

O Pandas é uma das bibliotecas mais poderosas do ecossistema Python para análise, transformação e automação de dados.

Se você já lidou com planilhas no Excel, vai se sentir em casa, mas aqui, com muito mais poder e automação.

Preparando o ambiente

Como sempre, vamos manter nosso projeto isolado em um ambiente virtual.

python3 -m venv .venv

No Linux/macOS source .venv/bin/activate

No Windows source .venv\Scripts\activate

Instalando o Pandas

Abre o terminal:

pip install pandas openpyxl

pandas: biblioteca principal para análise de dados.

openpyxl: permite exportar para Excel (.xlsx).

Lendo um arquivo CSV

Vamos começar simples: carregar um relatório em CSV e inspecionar os dados.

relatorio-vendas.py

import pandas as pd

# Carregar o arquivo CSV
df = pd.read_csv("vendas.csv")

# Exibir as primeiras linhas
print(df.head())

Se o arquivo vendas.csv contiver algo como:

data,produto,quantidade,valor
01/08/2025,Notebook,3,3500
01/08/2025,Mouse,10,80
01/08/2025,Teclado,5,150

A saída será uma tabela organizada, semelhante a uma planilha.

python3 relatorio-vendas.py

         data   produto  quantidade  valor
0  01/08/2025  Notebook           3   3500
1  01/08/2025     Mouse          10     80
2  01/08/2025   Teclado           5    150

Filtrando e transformando dados

Agora vamos selecionar apenas vendas acima de R$ 1000.

filtro = df[df["valor"] > 1000]
print(filtro)

Resultado:

         data        produto   quantidade  valor
0        01/08/2025  Notebook     3        3500

Exportando para Excel

filtro = df
filtro.to_excel("vendas_filtradas.xlsx", index=False)
print("Relatório exportado para vendas_filtradas.xlsx")

Com isso, temos um arquivo pronto para ser compartilhado, sem precisar abrir o Excel manualmente.

Mini-projeto: Consolidando múltiplos relatórios

Imagine que você recebe vários arquivos CSV (vendas_jan.csv, vendas_fev.csv, etc.).

Podemos juntá-los em um único relatório com poucas linhas de código:

import pandas as pd
import glob

# Carregar todos os arquivos CSV
arquivos = glob.glob("vendas_*.csv")

# Concatenar em um único DataFrame
dfs = [pd.read_csv(arq) for arq in arquivos]
df_final = pd.concat(dfs, ignore_index=True)

# Salvar no Excel
df_final.to_excel("vendas_consolidadas.xlsx", index=False)
print("Relatório consolidado gerado com sucesso!")

Agora, em vez de copiar e colar manualmente dezenas de planilhas, você automatiza tudo em segundos.

Quando usar Pandas para automação

O Pandas é ideal para:

• Processar grandes volumes de dados de forma rápida.
• Automatizar tarefas repetitivas de ETL (Extract, Transform, Load).
• Transformar relatórios em insights prontos para análise.

Considerações finais

Com o Pandas, você elimina horas de trabalho repetitivo e ganha produtividade, transformando relatórios manuais em processos automáticos e confiáveis.

Feito!

Criando APIs REST com Python

Imagine que você precisa criar um serviço que permita que outros sistemas ou aplicações acessem seus dados de forma segura e padronizada. É aí que entram as APIs REST, uma das formas mais comuns de comunicação entre aplicações na web.

E, quando falamos de Python,um dos frameworks leve e eficientes para construir APIs é o FastAPI.

O que é o FastAPI?

O FastAPI é um framework web para Python, projetado para criar APIs de forma:

• Rápida:

otimizado para alta performance usando programação assíncrona.

• Segura:

valida automaticamente os dados recebidos.

• Produtiva:

gera documentação interativa automaticamente.

Ele é tão eficiente que já é usado em produção por empresas como Microsoft e Uber.

Por que usar o FastAPI?

Velocidade de desenvolvimento: você escreve menos código para fazer mais.

Validação automática: parâmetros e dados recebidos são verificados automaticamente.

Documentação integrada: acesso imediato à documentação interativa via Swagger UI e ReDoc.

Desempenho: comparável a frameworks rápidos como Node.js e Go.

Preparando o ambiente

Como nas postagens anteriores, vamos criar um ambiente virtual para manter as dependências isoladas.

python3 -m venv .venv

No Linux/macOS source .venv/bin/activate

No Windows source .venv\Scripts\activate

Instalando o FastAPI e o servidor Uvicorn

pip install fastapi uvicorn

fastapi: framework para criar a API.

uvicorn: servidor leve e rápido para rodar a aplicação.

Criando sua primeira API

Crie um arquivo chamado main.py

Executando a aplicação

No terminal:

uvicorn main:app --reload

main:app main é o nome do arquivo, app é a instância do FastAPI.

--reload reinicia automaticamente o servidor ao modificar o código.

Acesse no browser:

http://127.0.0.1:8000/api

Rota inicial.

http://127.0.0.1:8000/docs Documentação interativa (Swagger UI).

http://127.0.0.1:8000/redoc Documentação alternativa (ReDoc).

Desafio: API de To-Do List

Você pode ampliar este exemplo para criar um CRUD (Create, Read, Update, Delete) de tarefas:

POST /tarefas cria tarefa.

GET /tarefas lista tarefas.

PUT /tarefas/{id} atualiza tarefa.

DELETE /tarefas/{id} remove tarefa.

Essa base será extremamente útil para aplicações reais.

Considerações finais

O FastAPI combina velocidade, praticidade e robustez, sendo ideal para desenvolvedores que querem criar APIs modernas sem complicação.

Referências

https://fastapi.tiangolo.com

Feito!

Programação assíncrona no Python

No mundo real, um restaurante com apenas um cozinheiro pode atender vários clientes ao mesmo tempo: enquanto um prato assa no forno, o cozinheiro prepara outro. Isso é trabalho assíncrono.

No Python, a programação assíncrona nos permite executar múltiplas tarefas em paralelo (ou melhor, quase paralelo) sem precisar esperar que cada uma termine para começar a próxima — ideal para chamadas de API, consultas a banco de dados e processamento de arquivos.

O que é programação assíncrona?

Em um programa tradicional (síncrono), cada instrução só começa depois que a anterior termina.

Na programação assíncrona:

Algumas operações podem “esperar” (ex.: aguardar resposta de uma API).

Enquanto esperam, o Python pode executar outras tarefas.

Isso reduz tempo ocioso e aumenta a eficiência, principalmente em aplicações que fazem muitas operações de I/O.

O módulo asyncio

O asyncio é a biblioteca nativa do Python para lidar com programação assíncrona.

Com ele, você:

Declara funções assíncronas usando async def.

Aguarda resultados com await.

Executa múltiplas funções com asyncio.gather().

Criando um projeto prático

Neste exemplo, vamos simular o download de páginas web usando aiohttp para trabalhar de forma assíncrona.

Criar e ativar o ambiente virtual

python3 -m venv .venv

No Linux/macOS: source .venv/bin/activate

No Windows: .venv\Scripts\activate

Instalar dependências

pip install aiohttp

Código exemplo: Download assíncrono

Entendendo o código

async def : cria uma função assíncrona.

await : pausa a função até que o resultado esteja pronto, sem travar o resto do programa.

asyncio.gather() : executa várias tarefas ao mesmo tempo.

aiohttp : biblioteca otimizada para requisições HTTP assíncronas.

Comparando com o código síncrono

Se fizéssemos as requisições uma de cada vez, o tempo total seria a soma de todos os tempos individuais.

No modo assíncrono, todas começam juntas, reduzindo drasticamente o tempo de espera.

Quando usar programação assíncrona?

A programação assíncrona é especialmente útil quando seu código precisa:

• Fazer várias requisições HTTP.
• Ler ou gravar muitos arquivos.
• Processar grandes volumes de dados que dependem de I/O.

Para cálculos pesados (CPU-bound), a programação assíncrona não é a melhor opção — nesse caso, usar múltiplos processos (multiprocessing) ou threads pode ser mais eficiente.

Considerações finais

Com o asyncio, conseguimos transformar tarefas demoradas em operações rápidas e eficientes, aproveitando melhor o tempo de execução do programa.

Feito!

Criando e gerenciando ambientes virtuais com venv e pip-tools no Python

Imagine que você está desenvolvendo dois projetos diferentes em Python:

Um utiliza a biblioteca Django na versão 3.2.

Outro exige Django na versão 5.0.

Se você instalar ambas as versões diretamente no seu sistema, haverá conflitos e um dos projetos inevitavelmente deixará de funcionar. É aqui que entra o conceito de ambiente virtual.

O que é um ambiente virtual e por que usá-lo?

Um ambiente virtual no Python é como um “espaço isolado” onde você instala bibliotecas apenas para um determinado projeto, sem interferir no restante do sistema ou em outros projetos.

Essa prática traz benefícios claros:

• Isolamento:

cada projeto tem suas próprias dependências e versões.

• Reprodutibilidade:

você consegue recriar exatamente o mesmo ambiente em outra máquina.

• Organização:

evita instalar bibliotecas desnecessárias no Python global.

Em poucas palavras: o venv protege seu projeto de conflitos e garante consistência no desenvolvimento.

Criando um ambiente virtual com venv

O Python já vem com o módulo venv embutido, então você não precisa instalar nada para começar.

1. Abra o terminal no diretório do seu projeto.

2. Execute: python3 -m venv .venv

Aqui:

python3 -m venv Cria o ambiente virtual.

.venv é o nome da pasta que conterá o ambiente (você pode escolher outro nome).

Ativando o ambiente virtual

A ativação muda o terminal para usar o Python e as bibliotecas daquele ambiente.

Linux / macOS:

source .venv/bin/activate

Windows:

.venv\Scripts\activate

Ao ativar, você verá algo assim no terminal:

(.venv) $

Isso indica que o ambiente virtual está ativo.

Instalando pacotes

Com o ambiente ativo, instale pacotes normalmente:

pip install requests

Esses pacotes ficam armazenados dentro da pasta .venv, sem afetar o restante do sistema.

Gerenciando dependências com pip-tools

O pip-tools ajuda a manter um controle organizado das bibliotecas que seu projeto usa. Ele separa:

O que você pediu para instalar.

As dependências que foram instaladas automaticamente.

1. Instale o pip-tools:

pip install pip-tools

2. Crie um arquivo requirements.in:

requests
pandas

3. Compile para requirem ents.txt:

pip-compile

O requirements.txt gerado terá as versões exatas:

pandas==2.1.0
requests==2.31.0

4. Instale exatamente essas versões:

pip install -r requirements.txt

Para sair do ambiente virtual venv, execute: deactivate

Exportando dependências

Se quiser compartilhar seu projeto, basta enviar:

O código-fonte e o arquivo requirements.txt ou melhor o link do repositório do projeto de alguma das plataformas GitHub, Bitbucket, GitLab ou Azure DevOps

Em outra máquina, basta:

python3 -m venv .venv source .venv/bin/activate

OU no Windows

.venv\Scripts\activate

pip install -r requirements.txt

Pronto: ambiente recriado exatamente como no seu computador.

Considerações finais:

O uso de ambientes virtuais não é apenas uma boa prática: é fundamental para qualquer desenvolvedor Python que queira evitar problemas e manter seus projetos organizados.

O venv garante isolamento e o pip-tools ajuda a manter suas dependências claras e previsíveis.

Feito!

Por que Python está dominando o mercado de dados?

Você já se perguntou por que alguém escolheria analisar dados em Python, uma linguagem de programação, em vez de ferramentas familiares como Excel ou Power BI? É uma dúvida comum, especialmente quando se pensa na rapidez para criar um dashboard no Power BI. Muitos comentários que refletem essa incredulidade: É mais trabalhoso construir dashboards em Python do que no Power BI ou Excel? Sim, definitivamente.

No entanto, a questão vai muito além dos dashboards. Eles são apenas a ponta de um iceberg gigantesco no processo de análise de dados. Ferramentas gráficas podem te limitar mais cedo ou mais tarde, especialmente se você leva a análise de dados a sério.

O mercado já decidiu: Python lidera

A ideia de que o mundo dos dados está migrando em massa para Python não é apenas uma teoria. Um projeto sólido de Luke Barrow, um renomado analista de dados nos EUA, analisou mais de 3 milhões de vagas preenchidas no mundo dos dados (engenheiros, cientistas, analistas de dados, etc.). O resultado é claro:

Python aparece em primeiro lugar como a ferramenta mais usada globalmente, presente em mais de 55% das vagas. Enquanto isso, Excel e Power BI ficam abaixo de 17%. Essa migração massiva já aconteceu, e os números de vagas confirmam isso.

Os 7 Pilares Que Tornam Python Indispensável

A dominância do Python se baseia em sete elementos cruciais que uma ferramenta de análise de dados "perfeita" deve ter:

1. Ampla variedade de formatos de dados aceitos:

Ferramentas gráficas te limitam aos tipos de dados que seus desenvolvedores predefiniram. Embora lidem bem com planilhas, bancos de dados SQL e JSON, elas falham com APIs mais complexas e, crucialmente, com dados não estruturados, que representam 99% dos dados do mundo (textos, imagens, vídeos, áudios). Python oferece a flexibilidade necessária para trabalhar com qualquer tipo de dado, estruturado ou não.

2. Capacidade de automatizar a captura de dados:

Você precisa de uma ferramenta que possa criar processos de atualização automática de dados. Python permite desenvolver scripts que contornam bloqueios de API e mantêm seus dados sempre atualizados, algo que as ferramentas gráficas não oferecem com a mesma robustez.

3. Performance com Big Data:

Ferramentas como Excel e Power BI travam e sofrem com grandes conjuntos de dados. Python, com bibliotecas como Pandas, Dask e Spark, consegue carregar e manipular milhões de linhas (como um arquivo de 1GB com 10 milhões de linhas de dados de aviação) em segundos, com uma velocidade impressionante.

4. Versatilidade nas Análises:

Em Excel e Power BI, você está restrito às funcionalidades e "botões" que os desenvolvedores da ferramenta forneceram. Python, por outro lado, oferece total liberdade para realizar qualquer tipo de análise, desde Machine Learning (regressões logísticas, modelos de clusterização), testes estatísticos robustos, análises de séries temporais, até a criação de modelos de previsão de vendas e análises personalizadas com Visão Computacional.

5. Controle dos recursos computacionais:

Em ferramentas gráficas, o processamento de dados é uma "caixa preta", você não sabe como os cálculos são feitos ou se estão sendo eficientes. Com Python, você tem controle total. É possível paralelizar cálculos usando bibliotecas como Dask e Joblib, distribuindo o processamento por múltiplos núcleos do processador, ou até mesmo descarregar cálculos para a GPU com QPI e Rapids. Isso pode resultar em ganhos de performance de 10.000 vezes, transformando análises de horas em segundos.

6. Personalização ilimitada na apresentação de dados:

Além de dashboards, Python permite gerar relatórios PDF totalmente personalizados, enviar informações automaticamente por e-mail, WhatsApp ou Telegram, e até criar APIs para que outros sistemas consumam seus dados. A liberdade de saída é ilimitada, permitindo que você construa suas próprias ferramentas e gráficos que ainda não existem.

7. Custo e propriedade:

Excel e Power BI são produtos da Microsoft, pagos e sujeitos às decisões da empresa (preços, descontinuação, remoção de funcionalidades) . Python é uma linguagem gratuita e de código aberto, desenvolvida por uma comunidade global. Isso significa que a ferramenta é sua, o poder é seu, e você não está refém de uma única empresa ou de suas atualizações.

A Curva de aprendizagem e o futuro com a IA

É verdade que aprender Python exige mais dedicação do que simplesmente "arrastar e soltar" em ferramentas gráficas. Um iniciante pode levar cerca de 3 meses para começar a produzir bons resultados. No entanto, o domínio de Python abre portas para posições que pagam muito mais, com diferenças salariais que podem ser de duas a três vezes maiores, inclusive em vagas internacionais de engenharia e ciência de dados.

Além disso, a ascensão da programação assistida por IA (como ChatGPT, Gemini, Copilot, Claude.AI, etc) está revolucionando o aprendizado. A IA pode programar para você, e sua função será supervisionar e corrigir. Isso gera um enorme ganho de produtividade. O mais curioso é que, para aproveitar ao máximo essas ferramentas, é fundamental saber programar, pois você precisa saber o que pedir e como corrigir os erros da IA.

Roteiro para dominar Python na análise de dados

Para aqueles que desejam trilhar o caminho da análise de dados com Python, aqui está um roteiro básico para começar:

• Fundamentos da Programação em Python:

Comece com a lógica de programação, manipulação de dados básicos, estruturas de controle de fluxo, loops, funções e programação orientada a objetos.

• Análise de dados básica e visualização:

Domine bibliotecas como Pandas (considerado um "Excel com esteroides" em Python), Matplotlib e Seaborn para transformar e visualizar dados.

• Trabalho com APIs e Bancos de Dados:

Aprenda a consumir informações de APIs e bancos de dados e a inseri-las em suas análises.

• Construção de Dashboards:

Utilize bibliotecas poderosas como Plotly e Seaborn para transformar suas análises em algo visualizável para sua equipe.

• Automação de Processos:

Entenda como automatizar todo o processo para garantir atualizações em tempo real dos dashboards e a estabilidade do sistema, permitindo que novos usuários acessem os dados sem quebrar o fluxo.

Este é um roteiro fundamental para um analista de dados, que pode ser seguido de forma autônoma, embora o processo possa ser mais desafiador sem uma estrutura clara e mentoria.

Considerações finais

A migração do mercado de dados para Python não é uma moda passageira, mas uma resposta às crescentes demandas por flexibilidade, performance e controle. As ferramentas gráficas, por mais acessíveis que sejam, impõem limitações que se tornam barreiras para quem busca levar a análise de dados a um nível profissional.

Você está pronto para dominar a ferramenta que o mercado exige e desbloquear todo o seu potencial na análise de dados?

Feito!

5 habilidades que a IA jamais irá substituir

Em um mundo onde a Inteligência Artificial (IA) avança a passos largos, é comum ouvirmos que ela pode substituir programadores e diversas outras profissões. Mas será que é bem assim? É crucial refletirmos sobre as características que nos tornam únicos e diferentes da IA. A verdade é que existem cinco habilidades intrinsecamente humanas que a IA dificilmente conseguirá replicar, elevando nosso papel no futuro da tecnologia.

1. Pensamento criativo e inovação genuína

A inteligência artificial é excelente em otimizar e gerar código com base em padrões existentes. No entanto, a capacidade de pensar "fora da caixa", de conceber soluções disruptivas para problemas ainda não resolvidos ou de criar conceitos totalmente novos, continua sendo uma prerrogativa humana. A verdadeira inovação e a visão para o futuro da tecnologia dependem da nossa criatividade e intuição.

2. Compreensão profunda do contexto humano e de negócios

Programar vai muito além de escrever código; trata-se de resolver problemas para pessoas e empresas. Isso exige uma compreensão das nuances das necessidades humanas, das complexidades dos modelos de negócios, das expectativas dos usuários e das implicações éticas e sociais de uma tecnologia. A IA, por sua natureza, tem dificuldade em contextualizar essas subjetividades, tornando a interpretação humana insubstituível .

3. Habilidades de comunicação, colaboração e liderança

O desenvolvimento de software é um esporte de equipe. Nossa capacidade de comunicar ideias complexas (mesmo as não-técnicas), colaborar em equipes multidisciplinares, negociar requisitos, resolver conflitos interpessoais e inspirar e liderar outros seres humanos são qualidades intrinsecamente humanas. Embora a IA possa facilitar a comunicação, ela não pode substituir a profundidade da construção de relacionamentos interpessoais ou a motivação que um líder humano oferece.

4. Resolução de problemas não estruturados e pensamento crítico

A IA é brilhante em solucionar problemas claramente definidos. Contudo, quando nos deparamos com problemas ambíguos, informações incompletas ou contraditórias, ou cenários completamente novos sem dados preexistentes, o pensamento crítico humano é insubstituível. A habilidade de fazer as perguntas certas, adaptar-se rapidamente a requisitos em constante mudança e discernir a verdade em situações caóticas parece ser uma característica exclusivamente humana.

5. Adaptabilidade emocional e resiliência

O mundo da tecnologia está em constante mudança, com prazos apertados, bugs frustrantes e falhas inesperadas. A adaptabilidade emocional, a capacidade de gerenciar o estresse, aprender com os erros, manter a resiliência diante da adversidade e reinventar-se profissionalmente, são habilidades ligadas à inteligência emocional e à experiência de vida. A IA não experimenta emoções nem lida com a frustração da mesma forma que um ser humano.

Essas habilidades não apenas garantem a relevância dos profissionais, mas também os elevam a um papel mais estratégico e impactante no futuro da tecnologia . Embora seja difícil prever o futuro da IA, essas características humanas nos mantêm no centro da inovação e da solução de problemas.

Considerações finais

Em meio a tantas discussões sobre o futuro da inteligência artificial, é fundamental lembrarmos que a tecnologia é uma ferramenta poderosa, mas o elemento humano continua sendo insubstituível em sua essência. As habilidades que nos tornam criativos, empáticos, colaborativos e resilientes são as que verdadeiramente impulsionarão a inovação e a resolução de problemas complexos no futuro. A IA pode otimizar processos e gerar soluções baseadas em dados existentes, mas a capacidade de sonhar, de sentir e de se adaptar a um mundo em constante mudança é intrínseca à nossa humanidade.

E você, quais outras habilidades você acredita que a IA nunca conseguirá substituir?

Feito!

PHP 8.5: Todas as novidades e recursos explicados com exemplos

O PHP 8.5 chegou trazendo recursos que tornam o código mais limpo, seguro e performático. Como desenvolvedor sênior em PHP, vejo essa versão como um passo importante na modernização da linguagem, com novidades que vão facilitar o dia a dia tanto de quem trabalha com back-end puro quanto em frameworks como Laravel, Symfony ou APIs REST.

A seguir, você confere um resumo das principais novidades do PHP 8.5, explicadas de forma prática, com exemplos e insights de como aplicar cada recurso no mundo real.

1. Pipe Operator (|>): Código mais limpo e funcional

Agora podemos encadear chamadas de funções de forma mais legível:

$result = "hello"
    |> strtoupper(...)
    |> trim(...)
    |> ucfirst(...);

Por que é útil?

Evita variáveis temporárias e deixa pipelines de dados (ex.: sanitização de input ou processamento em APIs) muito mais fáceis de entender.

2. First-Class Callables em constantes

class Utils {
  public static function log($msg) { /*...*/ }
}
const LOGGER = Utils::log(...);
LOGGER("teste");

Por que é útil?

Permite definir callbacks reutilizáveis sem precisar de funções auxiliares, ótimo para roteadores de frameworks, middlewares ou eventos.

3. Closures em expressões constantes

const FILTER = static fn($v) => is_string($v);

Por que é útil?

Melhora a expressividade em configurações dinâmicas, atributos e metaprogramação.

4. Funções de Array: array_first() e array_last()

 
$array = [10, 20, 30];
echo array_first($array); // 10
echo array_last($array);  // 30

Por que é útil?

Substitui reset() e end() com uma sintaxe muito mais intuitiva.

5. Visibilidade Assimétrica para static

class Settings {
  public private(set) static string $mode = 'live';
}

Por que é útil?

Permite leitura pública, mas escrita apenas dentro da classe, reforçando encapsulamento.

6. Atributos em constantes

#[Deprecated("use NEW_CONST")]
const OLD_CONST = 123;

Por que é útil?

Facilita a gestão de código legado, mostrando depreciações de forma clara.

7. 7. #[\NoDiscard]: Não ignore o retorno

#[\NoDiscard]
function calc(): int { return 42; }

Por que é útil?

Gera aviso se o retorno for ignorado, evitando bugs sutis.

8. Melhorias no debug de erros fatais

Agora temos backtraces completos para erros fatais, tornando diagnósticos muito mais rápidos.

9. Novas Funções para Handlers

get_error_handler()

get_exception_handler()

Por que é útil?

Facilita a manipulação de handlers dinâmicos em frameworks e middlewares.

10. PHP_BUILD_DATE: Data de compilação

echo PHP_BUILD_DATE;

Por que é útil?

Ajuda em auditorias e ambientes complexos de CI/CD.

11. Novidades no cURL

curl_multi_get_handles() lista todas as conexões em uso.

curl_share_init_persistent() permite conexões persistentes com cache.

Por que é útil?

Excelente para aplicações que fazem muitas requisições paralelas a APIs externas.

12. Localização: locale_is_right_to_left()

$isRTL = locale_is_right_to_left("fa_IR"); // true

Por que é útil?

Facilita adaptação de layouts para idiomas RTL como árabe ou hebraico.

13. IntlListFormatter: Listas Localizadas

$fmt = new IntlListFormatter("en", TYPE_CONJUNCTION, STYLE_LONG);
echo $fmt->format(["maçã","banana","cereja"]);

Por que é útil?

Melhora a experiência do usuário em aplicações multilíngues.

14. CLI: php --ini=diff>/li>

    Mostra apenas as configurações modificadas no php.ini.

    Por que é útil?

    Ideal para debug de ambiente e deploys.

Considerações finais:

O PHP 8.5 prova que a linguagem está mais moderna e voltada para produtividade. Recursos como pipe operator, callables em constantes e melhorias no debug são game changers para qualquer projeto.

Se você ainda está no PHP 5.6,7.x ou 8.0, já é hora de planejar a migração para aproveitar não só os recursos, mas também as otimizações de performance e segurança.

Referências

https://php.watch/versions/8.5

Feito!

Depuração de sistemas de forma eficiente

Quando um paciente chega ao consultório com uma dor ou um cliente leva o carro à oficina com um barulho estranho, o médico ou o mecânico não começa a "consertar" imediatamente. Eles ouvem, perguntam, investigam, fazem testes e somente depois aplicam uma solução.

Curiosamente, esse processo é exatamente o que deveria acontecer ao depurar sistemas em produção ou desenvolvimento. No entanto, muitos desenvolvedores, até os mais experientes, pulam etapas cruciais da investigação, o que leva a correções incompletas ou efeitos colaterais indesejados.

No presente artigo, exploramos como aplicar a mentalidade investigativa de médicos e mecânicos no contexto da depuração de software, com exemplos práticos e boas práticas.

Analogia: Médico, Mecânico e Engenheiro de Software

O Médico

Sintoma: "Estou com dor no estômago."

Processo: O médico coleta informações, localização da dor, histórico clínico, alimentação recente, realiza exames.

Diagnóstico: Pode ser gastrite, apendicite ou intoxicação.

Tratamento: Cada causa exige um tratamento diferente. Errar o diagnóstico pode ser fatal.

O Mecânico

Sintoma: "Meu carro está fazendo um barulho ao frear."

Processo: O mecânico verifica os freios, discos, pastilhas, e até a suspensão, se necessário. Pode testar o carro.

Diagnóstico: Pastilhas gastas? Disco empenado? Braço da suspensão solto?

Solução: Substituição de peças específicas.

O Engenheiro de Software

Sintoma: "O relatório financeiro está com valores incorretos."

Processo: O engenheiro de software coleta logs, analisa dados de entrada, reproduz o bug, inspeciona código e dependências.

Diagnóstico: Erro de arredondamento? Consulta SQL mal construída? Falha na atualização de cache?

Correção: Refatoração pontual ou ajuste nos dados.

Etapas da depuração: O processo diagnóstico

A seguir, adaptamos o processo de investigação médica/mecânica para o contexto de sistemas:

1. Coleta de sintomas (relato do bug)

Escute com atenção o relato do usuário.

Pergunte: Quando começou? Ocorre sempre? Com que frequência? Em qual ambiente (produção, homologação)?

Exemplo: Um cliente relata que ao gerar relatório no dia 1º de cada mês, ele mostra dados duplicados.

2. Reprodução controlada

Tente reproduzir o erro em ambiente de teste, com os mesmos dados e condições.

Se o bug não for reproduzível, pode haver uma condição de corrida ou dependência externa.

3. Inspeção de logs e métricas

Logs são o raio-X do software.

Ferramentas como ELK Stack, Grafana, ou até um simples tail -f ajudam a visualizar eventos relevantes.

Exemplo: Ao verificar os logs, percebe-se que o sistema gera o relatório duas vezes quando o agendamento cron executa com atraso.

4. Hipóteses e testes

   strong>Elabore hipóteses: "E se o problema estiver no agendador?" "E se os dados vierem duplicados do banco?"

   Valide cada hipótese isoladamente, como um médico pede exames complementares.

5. Diagnóstico

Identifique a causa-raiz, e não apenas o efeito.

Ferramentas úteis: Debuggers, breakpoints, análise estática, cobertura de testes, git blame.

6. Correção e prevenção

Corrija o problema de forma específica e escreva testes automatizados para cobrir o caso.

Se possível, implemente alertas ou logs adicionais para prevenir regressões.

O que evitar

• "Corrigir" o bug sem entender a causa (ex: esconder o erro com um try/catch vazio).
• Alterar o código em produção com base em achismos.
• Ignorar os logs e os testes, é como um médico ignorar exames de sangue.

Boas práticas para depuração

• Mantenha os logs claros e contextuais.
• Use feature flags para testar correções.
• Documente o erro e a solução (como um prontuário médico).
• Utilize versionamento no banco de dados e código-fonte.
• Tenha testes automatizados de regressão.

Considerações finais

Depurar sistemas não é apenas consertar bugs, é investigar com método, cuidado e lógica. Da mesma forma que um médico salva vidas com um diagnóstico preciso, e um mecânico evita acidentes ao revisar corretamente um freio, o engenheiro de software protege a confiabilidade do sistema ao aplicar a depuração com rigor técnico.

Depurar é diagnosticar. Corrigir é tratar. Testar é prevenir.

Se gostou dessa analogia, compartilhe com sua equipe e comente como você conduz o processo de depuração no seu dia a dia!

Feito!

Entenda o conceito que está revolucionando o desenvolvimento de software

A área de tecnologia está em constante transformação, e um dos conceitos mais importantes da atualidade é o DevOps. Mais do que uma simples combinação entre "Desenvolvimento" e "Operações", o DevOps representa uma mudança cultural e técnica que tem ajudado empresas a entregar software de forma mais rápida, segura e eficiente.

No presente artigo, vamos explorar o que é DevOps, por que ele surgiu, quais são seus principais benefícios e como essa prática tem mudado a forma como times de tecnologia trabalham em conjunto.

Por que surgiu o DevOps?

Durante muito tempo, as áreas de desenvolvimento e infraestrutura (operações) trabalhavam de forma isolada. O time de desenvolvimento era responsável por escrever o código, enquanto o time de operações cuidava da infraestrutura e da publicação do sistema. Essa separação gerava atrasos, conflitos e até falhas em produção, principalmente quando havia mudanças frequentes.

Foi nesse contexto que surgiu o DevOps, como uma resposta à necessidade de melhorar a comunicação entre os times, automatizar processos e garantir entregas mais confiáveis. O termo começou a ganhar força por volta de 2009, a partir de comunidades de tecnologia que buscavam uma cultura mais colaborativa.

O que é DevOps, afinal?

DevOps é um conjunto de práticas, ferramentas e uma cultura organizacional que visa integrar os times de desenvolvimento (Dev) e operações (Ops), promovendo colaboração contínua ao longo de todo o ciclo de vida do software, desde o planejamento e desenvolvimento até a entrega e manutenção em produção.

O foco do DevOps é criar um ambiente onde as equipes possam trabalhar de forma conjunta, entregando valor de forma contínua, ágil e com qualidade.

Quais são os pilares do DevOps?

Para funcionar bem, o DevOps se apoia em alguns pilares fundamentais:

• Colaboração:

Times multidisciplinares que trabalham juntos com objetivos em comum.

• Automação:

Processos como testes, integração contínua, entrega contínua e monitoramento são automatizados.

• Integração Contínua (CI):

Cada alteração de código é integrada ao projeto automaticamente, garantindo testes e feedback rápidos.

• Entrega Contínua (CD):

Novas versões do sistema são entregues com frequência e com menos riscos.

• Monitoramento e feedback:

O sistema é monitorado em tempo real e os times utilizam os dados para melhorar continuamente.

Benefícios do DevOps

Adotar DevOps traz uma série de benefícios para empresas e profissionais de tecnologia. Entre os principais, destacam-se:

• Entregas mais rápidas e frequentes de software;
• Maior confiabilidade nas implantações em produção;
• Redução de erros e falhas;
• Melhoria na colaboração entre áreas;
• Maior satisfação do cliente.

Além disso, o DevOps permite uma melhor adaptação a mudanças, essencial em um mercado tão dinâmico como o de tecnologia.

DevOps é só ferramenta?

Embora existam muitas ferramentas que suportam práticas DevOps (como Jenkins, Docker, Kubernetes, GitLab CI/CD, entre outras), é importante entender que DevOps é, antes de tudo, uma mudança de cultura.

Sem colaboração entre os times e comprometimento com a melhoria contínua, nenhuma ferramenta será suficiente para garantir o sucesso da adoção de DevOps.

Considerações finais:

DevOps é uma abordagem que vem transformando a maneira como desenvolvemos e entregamos software. Ao unir desenvolvimento e operações com foco em automação, colaboração e melhoria contínua, as empresas conseguem ser mais ágeis, resilientes e inovadoras.

Se você trabalha com tecnologia, seja como desenvolvedor, administrador de sistemas, QA ou gestor, entender e aplicar os princípios de DevOps pode ser um diferencial importante na sua carreira e nos resultados da sua equipe.

Feito!

Por que você deveria usar Docker no seu projeto?

Se você é desenvolvedor há algum tempo, com certeza já ouviu, ou falou, a famigerada frase: "Ué, na minha máquina funciona!".

Geralmente ela surge naquele momento crítico em que você compartilha seu projeto com alguém da equipe (ou vai subir pro servidor), a pessoa segue a documentação (às vezes até bem feita), instala as dependências, executa o build… e boom!

Erro.

Na sua máquina está tudo liso. Mas do outro lado da tela, tudo quebra.

O culpado? Nem sempre é o código.

Na maioria das vezes, o vilão está escondido em detalhes sutis: a versão do Java instalada, o Node.js diferente, uma lib do sistema que não está presente, ou até o próprio sistema operacional.

É aqui que entra um dos maiores aliados da consistência no desenvolvimento moderno: o Docker.

O que é Docker (de forma simples)?

Docker é uma plataforma que permite "empacotar" uma aplicação com tudo o que ela precisa para executar: sistema, bibliotecas, dependências, ferramentas, versão específica de runtime, tudo mesmo.

Esse "pacote" é chamado de container. Ele roda de forma isolada, como se fosse uma mini-máquina configurada só para a sua aplicação, e que funciona igualzinha em qualquer lugar.

Por que usar Docker no seu projeto?

1. Ambiente padronizado para todos

Não importa se quem vai executar o projeto usa Windows, Linux ou macOS. Com Docker, o ambiente de execução é exatamente o mesmo.

O famoso "na minha máquina funciona" vira "funciona igual em qualquer máquina".

2. Documentação viva

O Dockerfile e docker-compose.yml viram a documentação executável do seu ambiente.

Em vez de dizer "instale o PostgreSQL 13", "instale o Java 8/11/17", "instale o PHP 8.3", você diz: docker-compose up.

Simples, direto, sem margem para erro humano.

3. Facilidade para novos desenvolvedores

Quantas vezes você já perdeu um ou dois dias configurando o ambiente para alguém novo no time?

Com Docker, isso cai para alguns minutos. A pessoa só precisa ter Docker instalado, clonar o repositório e subir os containers.

4. Isolamento real

Você pode ter dois projetos rodando com versões completamente diferentes de uma linguagem ou banco de dados, sem conflitos.

Um usando Node 18, outro executando Python 3.7 com PostgreSQL 9? Sem problema.

5. Ambiente próximo ao de produção

Se você sobe sua aplicação em produção usando containers, nada mais justo do que desenvolver e testar no mesmo ambiente.

Menos surpresas, menos bugs de "ambiente".

Mas e o desempenho? Não complica demais?

Essa é uma dúvida legítima. Sim, dependendo do sistema operacional (Windows 😂), o Docker pode consumir mais recursos. Mas nos últimos anos, ele melhorou bastante em desempenho e integração nativa. Graças o suporte de WSL2, que permite instalar o Docker no Ubuntu via WSL, sem precisar do Docker Desktop.

Além disso, com o tempo você percebe que o pequeno custo de performance se paga facilmente pela economia de tempo, confiabilidade e tranquilidade de saber que o projeto vai executar bem onde quer que esteja.

Considerações finais

Docker não é moda. É uma das ferramentas mais poderosas que surgiram para tornar o desenvolvimento mais previsível, colaborativo e escalável.

Se você está cansado de ouvir (ou dizer) "na minha máquina funciona", talvez esteja na hora de subir o seu projeto com docker-compose.yml e entrar de vez no mundo dos containers.

Porque no fim das contas, o que a gente mais quer é isso:

Que funcione. Em todas as máquinas. Sem drama.

Nota final

Docker é uma ferramenta poderosa, mas não é um martelo para todos os pregos.

Projetos que exigem acesso direto a hardware, interfaces gráficas nativas ou virtualização avançada (como emuladores de Android, Arduino, ou dispositivos USB) podem encontrar no Docker mais limitação do que benefício.

E tudo bem.

Isso não é uma falha no seu projeto, é apenas uma questão de usar a tecnologia certa no lugar certo.

Feito!

Qual o melhor Sistema Operacional para Desenvolvedores?

Uma visão honesta de quem está há mais de 10 anos no campo de batalha.

Quando alguém me pergunta "qual é o melhor sistema operacional para desenvolvimento?", minha resposta automática costuma ser: depende. E não é uma forma preguiçosa de responder. É porque realmente depende do contexto, da linguagem, do tipo de projeto e até do seu gosto pessoal. Mas depois de mais de uma década mergulhado em código de aplicações web a scripts de automação, de APIs em nuvem a sistemas embarcados, aprendi que cada sistema tem suas vantagens (e dores).

No presente post, vou comentar sobre os quatro principais candidatos: uma distro Linux (como Ubuntu ou Fedora), macOS, FreeBSD e Windows. Spoiler: todos funcionam. Mas uns funcionam melhor dependendo do seu objetivo.

Linux: O queridinho dos devs raiz

Se você trabalha com backend, cloud, containers, automação, DevOps ou simplesmente curte ter o controle do seu ambiente, Linux é quase imbatível. O terminal é poderoso, a performance é sólida e quase tudo que executa em produção na nuvem, executa em Linux.

Vantagens:

• robusta, personalizável, e amigável a scripts.
• Integração nativa com ferramentas como Docker, Git, Node, Python, Go etc.
• É gratuito e leve (especialmente distros como Arch ou Debian).
• Ideal para quem quer entender o que está acontecendo "por baixo dos panos".

Desvantagens:

• Pode exigir mais curva de aprendizado para quem vem do Windows.
• Suporte a hardware (especialmente placas Wi-Fi ou impressoras) ainda pode ser uma dor.
• Softwares como Adobe, MS Office, etc., não funcionam nativamente.
• Para quem é: Devs backend, DevOps, SysAdmins, Cientistas de Dados, ou qualquer um que goste de uma abordagem hands-on.

macOS: O equilíbrio entre Unix e usabilidade

Se você desenvolve para iOS/macOS, você precisa de um Mac, ponto. Mas mesmo fora do ecossistema Apple, o macOS é uma ótima escolha para devs que querem a estabilidade e poder do Unix com uma interface polida e um ecossistema de ferramentas premium.

Vantagens:

• Terminal baseado em Unix (zsh/bash), com boa compatibilidade POSIX.
• Excelente suporte a linguagens como Python, Ruby, Node.js, embora todas precisem ser instaladas e gerenciadas com ferramentas como pyenv, rbenv e nvm.
• Interface gráfica polida e integração com o hardware Apple.
• Ideal para quem quer produtividade em um sistema robusto, mas ainda amigável.

Observações importantes:

O Docker não executa nativamente no macOS. Ele depende de uma máquina virtual leve (HyperKit/AppleHV) para simular o kernel Linux, o que pode impactar desempenho em alguns cenários.

Apesar de o Python vir pré-instalado, costuma ser uma versão desatualizada usada pelo sistema. Desenvolvedores geralmente precisam gerenciar múltiplas versões manualmente.

Desvantagens:

• Custo elevado.
• Atualizações podem quebrar ambientes de desenvolvimento se não forem feitas com cautela.
• Menos liberdade para personalizar o sistema profundamente (em comparação ao Linux).
• Para quem é: Desenvolvedores iOS, web, front-end, ou quem busca um ambiente Unix-like com visual refinado e conforto no uso diário.

Windows: O mais comum e... agora muito mais útil

Por muito tempo, o Windows foi visto como o pior ambiente para desenvolvimento. Mas isso mudou drasticamente com o WSL (Windows Subsystem for Linux). Hoje é totalmente viável programar em Windows, especialmente se você trabalha com .NET, C#, ou precisa de compatibilidade com softwares corporativos.

Vantagens:

• Compatibilidade com todos os softwares comerciais.
• Visual Studio (que ainda é imbatível para C# e C++).
• WSL2 permite executar Linux dentro do Windows com performance decente.
• Ideal para ambientes corporativos e desenvolvimento de jogos com DirectX.

Desvantagens:

• Gerenciamento de dependências e pacotes ainda é mais confuso.
• O sistema pode ficar instável com muitas customizações.
• Terminal padrão ainda é inferior (mas o Windows Terminal e o PowerShell melhoraram bastante).
• Para quem é: Devs C#, .NET, Unity, SQL Server, devs corporativos que precisam de Office, e quem trabalha com automação para Windows.

FreeBSD: Para os corajosos e curiosos

FreeBSD não é mainstream, mas quem já usou sabe: é rápido, seguro e com um sistema de permissões e gerenciamento de rede excelente. Se você é o tipo de dev que gosta de montar servidores otimizados, entender o sistema profundamente ou está buscando estabilidade acima de tudo, vale testar.

Vantagens:

• Estabilidade lendária.
• Sistema de ports eficiente.
• Ótimo para servidores e redes.

Desvantagens:

• Curva de aprendizado íngreme.
• Poucos tutoriais voltados para desenvolvimento moderno.
• Suporte de ferramentas e IDEs limitado.
• Para quem é: Devs hardcore, administradores de sistemas, especialistas em redes, ou quem quer aprender além do mainstream.

E no final, qual eu uso?

Hoje, pessoalmente, meu setup principal é o Linux (Ubuntu LTS) no notebook, mas por muitos anos usei o Slackware e o Debian no desktop. Aliás, o Slackware ainda é uma ótima escolha para quem quer aprender Linux no modo raiz, hands-on de verdade. Atualmente, meus servidores executam Debian, pela estabilidade e confiabilidade que oferece. Também já usei Windows por anos. Além disso, aprendi muito explorando o FreeBSD.

No fim das contas, o sistema operacional não faz o desenvolvedor, é apenas uma ferramenta. A melhor escolha é aquela que te permite ser produtivo, feliz e resolver problemas reais.

Dica de ouro: Se você está confortável com um sistema e ele te permite trabalhar bem, continue com ele. Se está te atrapalhando, experimente outro. Nada é definitivo.

E você, qual sistema usa para programar? E por quê?

Deixe nos comentários!

Se você evitar esses deslizes, com certeza terá uma base sólida para crescer na carreira de forma consistente e profissional.

Participe dos nossos grupos no Telegram:

Programadores Brasil Dicas, vagas, tecnologia e networking.

Linux Para Todos Aprendizado e suporte para quem quer migrar ou dominar o Linux no dia a dia do desenvolvimento.

FreeBSD Brasil Aprendizado e suporte para quem quer aprender FreeBSD no dia a dia.

Feito!