DEV Community: Brayan Monteiro

Tutorial – Formatar Pendrive em exFAT (Fedora KDE)

Brayan Monteiro — Fri, 27 Feb 2026 01:11:47 +0000

🎯 Objetivo

Apagar tudo do pendrive
Criar nova tabela GPT
Criar partição usando 100%
Formatar em exFAT
Definir nome (label)

⚠️ PASSO 0 – Identificar o pendrive

Conecte o pendrive e rode:

lsblk

Exemplo de saída:

sdc   57,7G  1 disk
└─sdc1 3G

📌 O pendrive normalmente:

Tem RM=1
Tamanho menor
Não é nvme
Não é seu HD externo principal

No exemplo aqui usamos:

/dev/sdc

⚠️ MUITO CUIDADO para não errar o disco.

🧹 PASSO 1 – Garantir que não está montado

sudo umount /dev/sdc1

Se aparecer:

not mounted

Está ok.

💣 PASSO 2 – Apagar completamente a assinatura

sudo wipefs -a /dev/sdc

Isso remove:

GPT antigo
MBR
Assinaturas escondidas
Restos de ISO bootável (ex: Ventoy, Rufus)

🗂 PASSO 3 – Criar nova tabela GPT

sudo parted /dev/sdc -- mklabel gpt

📦 PASSO 4 – Criar partição usando 100% do espaço

sudo parted -a optimal /dev/sdc -- mkpart primary exfat 0% 100%

💾 PASSO 5 – Formatar em exFAT

sudo mkfs.exfat /dev/sdc1

Agora o pendrive está 100% funcional em:

Linux
Windows
TV
Android
Mac

E suporta arquivos maiores que 4GB.

🏷 PASSO 6 – Definir nome (LABEL)

Exemplo:

sudo exfatlabel /dev/sdc1 PENDRIVE57

Use:

Sem espaço
Sem acento
Tudo maiúsculo (boa prática)

Exemplo:

BACKUP
ARQUIVOS
ISO_LINUX
PROJETOS

🔄 PASSO 7 – Reconectar

Remova e conecte novamente.

Confirme:

lsblk

Deve aparecer:

sdc
└─sdc1  57,7G  /run/media/brayan/PENDRIVE57

📌 Comando resumido (modo ninja)

Se já souber que é /dev/sdc:

sudo wipefs -a /dev/sdc
sudo parted /dev/sdc -- mklabel gpt
sudo parted -a optimal /dev/sdc -- mkpart primary exfat 0% 100%
sudo mkfs.exfat /dev/sdc1
sudo exfatlabel /dev/sdc1 PENDRIVE57

✅ Resultado Final

✔ 100% do espaço liberado
✔ Compatível com tudo
✔ Suporta arquivos grandes
✔ Nome personalizado

Como corrigir o erro de GPG do repositório do Cursor no Linux Mint

Brayan Monteiro — Thu, 11 Dec 2025 17:23:11 +0000

Se você instalou o Cursor usando o pacote .deb no Linux Mint (ou qualquer distro baseada em Ubuntu), é bem provável que tenha se deparado com erros como:

NO_PUBKEY
Release file is not signed
Erro GPG
hashes inválidos no apt update

Esse problema acontece porque o pacote .deb do Cursor adiciona uma chave GPG antiga e incompatível, e o Linux Mint é mais rigoroso com repositórios externos.
A solução é bem simples: adicionar manualmente a chave GPG correta e recriar o repositório usando o keyring modernizado.

A chave correta está aqui:

https://downloads.cursor.com/keys/anysphere.asc

1. Baixe a chave GPG correta

curl -fsSL https://downloads.cursor.com/keys/anysphere.asc \
    | sudo gpg --dearmor -o /usr/share/keyrings/cursor-archive-keyring.gpg

2. Recrie o arquivo do repositório apontando para esse keyring

Primeiro, remova o arquivo antigo (opcional, mas recomendado):

sudo rm /etc/apt/sources.list.d/cursor.list

Agora crie corretamente o novo arquivo do repositório:

echo "deb [signed-by=/usr/share/keyrings/cursor-archive-keyring.gpg] https://downloads.cursor.com/aptrepo stable main" \
    | sudo tee /etc/apt/sources.list.d/cursor.list

3. Atualize o sistema

sudo apt update

Se tudo estiver certo, os erros de GPG desaparecem:

sumiu o NO_PUBKEY
sumiu o Release file is not signed
sumiu o erro de hash inesperado
sumiu o “arquivo não pôde ser verificado”

O repositório volta a funcionar normalmente e as atualizações automáticas do Cursor passam a funcionar sem quebrar o apt.

Por que isso funciona?

A raiz do problema é bem simples:

o instalador .deb do Cursor adiciona uma chave GPG antiga e fora do padrão moderno do Debian/Ubuntu
Linux Mint exige que cada repositório externo tenha um keyring dedicado, com assinatura válida
a chave antiga não bate com as assinaturas mais recentes do repositório
resultado: o apt bloqueia o repositório por segurança

Quando você adiciona a chave nova (anysphere.asc) e cria o repositório com signed-by, o APT finalmente consegue validar tudo corretamente.

Quer confirmar se funcionou?

Basta rodar:

sudo apt update

Se não aparecer nenhum erro de assinatura, o repositório está configurado corretamente.

Instalar DBeaver no Linux Mint com atualização automática

Brayan Monteiro — Wed, 22 Oct 2025 23:22:55 +0000

A doc oficial do DBeaver diz mesmo que o update automático só existe no Windows e macOS, e que no Linux “não tem”.

Mas... na prática dá sim e o segredo é: usar o repositório APT deles, que não tá documentado direito na página principal, mas existe e funciona 100% (porque eles mantêm o diretório https://dbeaver.io/debs/ com Release e Packages configurados).

Então dá pra instalar e ter o “update automático”. 👇

✅ O método “não-oficial” (mas funcional) com auto update no Linux Mint

Roda esses comandos:

# Adiciona a chave do repositório
wget -O- https://dbeaver.io/debs/dbeaver.gpg.key | sudo gpg --dearmor -o /usr/share/keyrings/dbeaver-keyring.gpg

# Adiciona o repositório no sources.list.d
echo "deb [signed-by=/usr/share/keyrings/dbeaver-keyring.gpg] https://dbeaver.io/debs/dbeaver-ce /" | sudo tee /etc/apt/sources.list.d/dbeaver.list

# Atualiza o cache de pacotes
sudo apt update

# Instala (ou atualiza, se já tiver)
sudo apt install dbeaver-ce -y

🧠 O que acontece por baixo dos panos

Mesmo que o site diga “sem update automático”,
ao usar esse repositório .deb, o DBeaver passa a ser gerenciado pelo apt.
Ou seja, quando o Mint rodar apt upgrade (ou o Atualizador do sistema),
ele vai buscar a nova versão direto do https://dbeaver.io/debs/dists/stable/... e atualizar o pacote.

👉 É por isso que funcionou no teu notebook mesmo sem estar documentado.

🧩 Pra conferir se deu certo

Depois de instalar, roda:

apt policy dbeaver-ce

Se aparecer algo como:

 500 https://dbeaver.io/debs/dbeaver-ce  Packages

então tá perfeito — o repositório tá ativo e o DBeaver vai se atualizar automaticamente junto com o sistema.

Linux Mint + tecla Copilot: abrindo o WebApp do ChatGPT (maximizado)

Brayan Monteiro — Sun, 31 Aug 2025 13:09:25 +0000

Resumo: neste passo a passo eu mostro como mapear o botão Copilot do notebook para abrir o WebApp do ChatGPT criado no Mint (Cinnamon). Também cubro o clássico problema de “abrir como outro Chrome” e como garantir que o app inicie maximizado.

Por que isso dá trabalho?

Quando você cria um Aplicativo Web no Linux Mint (menu Aplicativos Web), o sistema gera um arquivo .desktop para esse app, com parâmetros próprios (perfil isolado, ícone, classe da janela etc.).

Se você usar um atalho de teclado chamando diretamente google-chrome --app=..., o Mint entende como um Chrome genérico, e ele aparece separado na barra de tarefas — não como o seu WebApp “ChatGPT”.

A solução é: lançar o .desktop do WebApp — não o binário do navegador.

1) Crie o WebApp do ChatGPT (via interface)

Abra Aplicativos Web (Web Apps).
Preencha, por exemplo:

Nome: ChatGPT
Endereço: https://chatgpt.com
Perfil isolado: ativado (recomendado)
Parâmetros personalizados: opcional; falaremos de maximização abaixo.
1. Salve.

Isso vai gerar um .desktop em ~/.local/share/applications/.

2) Confirme o `.desktop` do seu WebApp

No meu caso (exemplo real), o arquivo ficou assim:

~/.local/share/applications/WebApp-ChatGPT6914.desktop

Conteúdo relevante (trecho):

[Desktop Entry]
Name=ChatGPT
Exec=google-chrome-stable --app="https://chatgpt.com" --class=WebApp-ChatGPT6914 --name=WebApp-ChatGPT6914 --user-data-dir=/home/brayan/.local/... 
StartupWMClass=WebApp-ChatGPT6914
X-WebApp-Browser=Chrome
X-WebApp-URL=https://chatgpt.com
X-WebApp-CustomParameters=--start-maximized

Dica: o StartupWMClass precisa bater com o --class do Exec para o app agrupar certo no painel.

3) Mapeie o botão Copilot para abrir o WebApp (GUI)

Vá em Menu → Preferências → Teclado → Atalhos → Atalhos personalizados.
Clique em Adicionar atalho personalizado.
Nome: ChatGPT
Comando: use o lançador do .desktop (não chame o Chrome direto):

gtk-launch WebApp-ChatGPT6914

O nome após gtk-launch é o nome do arquivo .desktop sem a extensão.

Clique em Capturar atalho e pressione o botão Copilot.
Salve e teste.

Pronto: agora o Mint abre exatamente o WebApp “ChatGPT”, com ícone correto e agrupamento único — sem criar “outro Chrome” ao lado.

4) Como abrir maximizado de forma confiável

O X-WebApp-CustomParameters=--start-maximized é o suficiente para abrir o app maximizado, para adicionar ele usando a interface, basta fazer igual na imagem abaixo:

5) Teste o `.desktop` pelo terminal

Antes de amarrar na tecla, teste o lançador:

gtk-launch WebApp-ChatGPT6914

Se abrir o app certo, o atalho de teclado também vai funcionar.

6) Por que “abria como outro Chrome” antes?

Porque o comando do atalho era algo como:

google-chrome --app=https://chatgpt.com

Esse comando ignora as pistas que o Mint usa para agrupar a janela (classe da janela, nome, perfil isolado). Já o .desktop tem --class, --name, StartupWMClass e --user-data-dir corretos, então o painel reconhece como o mesmo app que você fixou.

7) Extras úteis (opcionais)

Focar a janela se já estiver aberta

Se quiser que o atalho traga para frente o ChatGPT quando já estiver aberto (em vez de abrir outra janela), você pode criar um script com wmctrl/xdotool (instale via apt se não tiver):

#!/usr/bin/env bash
if wmctrl -x -a WebApp-ChatGPT6914; then
  exit 0
else
  gtk-launch WebApp-ChatGPT6914
fi

Aponte o atalho para esse script.

Usando Edge/Brave/Chromium

O conceito é o mesmo; o .desktop terá Exec=microsoft-edge ... ou Exec=brave .... O importante é sempre lançar pelo .desktop com gtk-launch.

Onde ficam os `.desktop`

Usuário atual: ~/.local/share/applications/
Sistema todo: /usr/share/applications/ (os WebApps normalmente ficam no diretório do usuário)

8) Check-list final

[x] Criei o WebApp do ChatGPT no Aplicativos Web.
[x] Achei o .desktop (ex.: WebApp-ChatGPT6914.desktop).
[x] No ata

PHP e Java equivalências

Brayan Monteiro — Thu, 13 Mar 2025 20:28:28 +0000

Comparação entre ferramentas e conceitos equivalentes no PHP e no Java:

PHP	Java	Descrição
Composer	Maven / Gradle	Gerenciadores de dependências e automação de builds.
Laravel Artisan	Spring Boot CLI	Ferramentas de linha de comando para auxiliar no desenvolvimento.
PDO (PHP Data Objects)	JDBC (Java Database Connectivity)	Interfaces para conexão com bancos de dados.
Eloquent ORM (Laravel)	Hibernate (JPA)	ORMs para mapeamento objeto-relacional.
Monolog	SLF4J / Logback / Log4j	Frameworks de logging.
Guzzle	RestTemplate / WebClient (Spring WebFlux)	Clientes HTTP para consumir APIs REST.
Swoole	Netty	Frameworks assíncronos para redes e aplicações de alto desempenho.
PHPUnit	JUnit / TestNG	Frameworks para testes unitários.
Xdebug	JVM Debugger / VisualVM	Ferramentas para depuração de código.
Twig / Blade (Laravel)	Thymeleaf / JSP	Motores de templates para renderização de views.
Symfony Console	Picocli / JCommander	Frameworks para CLI.
Symfony Event Dispatcher	Spring Events	Sistemas de eventos para modularidade e desacoplamento.
dotenv	Spring Boot @ConfigurationProperties / System.getenv()	Gerenciamento de variáveis de ambiente e configuração.
Opcache	JIT Compiler / GraalVM	Melhorias de desempenho por cache e otimização de código.
Supervisor	Systemd / PM2 / Kubernetes Jobs	Gerenciadores de processos e jobs em background.
Apache / Nginx + PHP-FPM	Tomcat / Jetty / Undertow	Servidores para execução de aplicações web.
cURL	Apache HttpClient / OkHttp	Bibliotecas para requisições HTTP.
memcached / Redis (extensões PHP)	Ehcache / Redis (Spring Cache)	Soluções de cache.
RabbitMQ / Kafka (via PHP client)	Spring Cloud Stream / Kafka Clients	Mensageria e filas.
Laravel Queues / Symfony Messenger	Spring Batch / Java Executors	Processamento assíncrono e filas de tarefas.
Imagem oficial do PHP no Docker	Imagem oficial do OpenJDK no Docker	Contêineres oficiais para execução de aplicações.
Slim / Lumen / Symfony HTTP Kernel	Spring Boot / Micronaut / Quarkus	Frameworks para APIs e microservices.
cURL / Guzzle para APIs externas	Feign (Spring Cloud OpenFeign) / Retrofit	Bibliotecas para comunicação com APIs externas.

Scrum explicado

Brayan Monteiro — Tue, 11 Mar 2025 12:26:49 +0000

O que é o Scrum?

Scrum é uma metodologia ágil de gestão de projetos, geralmente usada no desenvolvimento de software, mas que também pode ser aplicada em outras áreas. O objetivo do Scrum é ajudar equipes a trabalhar de maneira mais eficiente, colaborativa e organizada, entregando resultados mais rápidos e com maior qualidade.

Imagine que você está tentando fazer um projeto grande, como construir uma casa. Em vez de planejar tudo de uma vez e entregar só no final, no Scrum você vai fazer tudo em etapas pequenas e ir entregando resultados parciais durante o caminho. Cada etapa é chamada de Sprint.

Principais conceitos do Scrum

Equipes Scrum:
- Product Owner (PO): O dono do produto é a pessoa que tem a visão do que precisa ser feito no projeto. Ele vai definir quais são as prioridades do que deve ser feito e comunicar isso para a equipe. É como um "representante do cliente".
- Scrum Master: O Scrum Master é o facilitador do processo. Ele não toma decisões sobre o que deve ser feito, mas ajuda a equipe a seguir o processo do Scrum, tira obstáculos que possam aparecer e garante que todos sigam as regras do Scrum.
- Time de Desenvolvimento: A equipe de desenvolvimento é composta pelos profissionais que vão realmente fazer o trabalho (programadores, designers, etc.). Eles são responsáveis por transformar as ideias do Product Owner em um produto funcional.
Artefatos:
- Product Backlog: É uma lista de todas as funcionalidades, melhorias, correções e requisitos que o produto final deve ter. O Product Owner é quem vai manter essa lista atualizada e priorizada.
- Sprint Backlog: Quando a equipe vai trabalhar em uma parte do Product Backlog durante uma Sprint, eles criam uma lista menor com as tarefas específicas que devem ser feitas naquele período.
- Incremento: Ao final de cada Sprint, a equipe entrega um "incremento" do produto, ou seja, uma versão funcional que tem algo novo pronto. É como se fosse uma atualização.
Eventos:
- Sprint: Uma Sprint é um ciclo de trabalho que dura entre 1 e 4 semanas. Durante esse período, a equipe trabalha nas tarefas do Sprint Backlog e ao final entrega um incremento funcional do produto.
- Sprint Planning: Antes de cada Sprint, a equipe se reúne para planejar o que será feito. Nessa reunião, o Product Owner explica o que está no Product Backlog e a equipe decide o que pode ser feito dentro do tempo da Sprint.
- Daily Scrum (ou Stand-up): Todos os dias, a equipe se reúne por cerca de 15 minutos para se atualizar sobre o que foi feito, o que será feito e se há algum obstáculo. Cada membro responde a três perguntas: "O que fiz ontem?", "O que vou fazer hoje?", "Há algum impedimento no meu caminho?".
- Sprint Review: No final da Sprint, a equipe mostra o que foi feito. O Product Owner e outros interessados (como clientes ou stakeholders) revisam o incremento e discutem o progresso do projeto.
- Sprint Retrospective: Após a Sprint Review, a equipe se reúne para refletir sobre o que funcionou bem e o que pode ser melhorado no processo. Essa reunião ajuda a equipe a evoluir constantemente, melhorando a colaboração e a entrega.

Como o Scrum funciona na prática?

Planejamento da Sprint:
- O Product Owner define o que é mais importante no Product Backlog (prioridades) e a equipe escolhe o que será feito na próxima Sprint.
- Durante a Sprint, a equipe vai se concentrar exclusivamente nas tarefas selecionadas. Não se adicionam novas tarefas à Sprint a menos que algo muito importante surja (mas isso é raro).
Trabalhando nas tarefas:
- A equipe trabalha nas tarefas do Sprint Backlog, tendo o acompanhamento do Scrum Master para garantir que o processo esteja fluindo sem bloqueios.
- A comunicação diária (via Daily Scrum) ajuda a todos se manterem atualizados e a resolverem rapidamente qualquer problema.
Final da Sprint e entrega:
- Ao final da Sprint, a equipe entrega um incremento do produto que está pronto para ser utilizado, mesmo que seja uma parte do produto completo.
- Esse incremento passa pela revisão do Product Owner e dos stakeholders.
Melhorias contínuas:
- Durante a Sprint Retrospective, a equipe analisa como foi o processo e como pode melhorar na próxima Sprint, o que garante que o time esteja sempre evoluindo e entregando mais valor.

Vantagens do Scrum

Flexibilidade: Mudanças podem ser feitas a qualquer momento durante o desenvolvimento, já que o trabalho é dividido em Sprints pequenas.
Transparência: Todos sabem o que está sendo feito, o que foi feito e o que falta. Isso reduz mal-entendidos.
Entrega rápida: Como há entregas a cada Sprint, o produto vai ganhando forma mais rapidamente.
Feedback constante: Como o produto é mostrado ao final de cada Sprint, o Product Owner pode dar feedback rápido, permitindo ajustes rápidos.

Resumo do Scrum em uma analogia simples:

Imagina que você está fazendo uma caminhada de várias etapas para chegar até um destino final (o produto). Em vez de planejar a viagem toda de uma vez, você faz o seguinte:

Cada etapa da caminhada é como uma Sprint (um ciclo de trabalho).
Antes de começar uma etapa, você olha no mapa (Sprint Planning) e decide o que vai fazer na próxima parte da caminhada.
Todos os dias, você se encontra com sua equipe (Daily Scrum) para garantir que todos estão indo na direção certa.
Quando você termina uma etapa, você olha para o que conseguiu fazer (Sprint Review) e pensa em como pode melhorar para a próxima etapa (Sprint Retrospective).

Deixar tabela responsiva em site wordpress

Brayan Monteiro — Sun, 09 Mar 2025 13:20:26 +0000

Essa abordagem realmente funciona bem de forma universal, especialmente para evitar que tabelas quebrem no mobile. O uso de border-collapse: separate; e overflow-x: auto; garante que as células fiquem bem organizadas e o scroll horizontal seja ativado quando necessário.

/* Tabela responsiva */
@media (max-width: 768px) {
table {
border-collapse: separate;
border-spacing: 0;
border-width: 1px 0 0 1px;
display: block;
overflow-x: auto;
white-space: nowrap;
width: 100% !important;
}
}

Como criar e consumir uma API REST simples em Java puro

Brayan Monteiro — Thu, 06 Mar 2025 22:27:43 +0000

Vou criar uma API REST simples em Java puro** (usando com.sun.net.httpserver) e consumir essa API usando java.net.HttpURLConnection.

Parte 1: Criando a API (Servidor HTTP)

Passo 1: Estrutura do Projeto

src
└── main
    └── java
        ├── api
        │   ├── Task.java          // Modelo de dados
        │   ├── TaskHandler.java   // Manipulador de requisições
        │   └── Server.java        // Servidor principal
        └── client
            └── ApiClient.java     // Cliente para consumir a API

Passo 2: Código do Servidor

Classe `Task` (Modelo)

package api;

public class Task {
    private int id;
    private String title;
    private boolean completed;

    // Construtor, getters e setters
    public Task(int id, String title, boolean completed) {
        this.id = id;
        this.title = title;
        this.completed = completed;
    }

    public int getId() { return id; }
    public String getTitle() { return title; }
    public boolean isCompleted() { return completed; }
}

Classe `TaskHandler` (Manipulador de Requisições)

package api;

import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpHandler;
import java.io.IOException;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.List;

public class TaskHandler implements HttpHandler {
    private List<Task> tasks = new ArrayList<>();
    private int nextId = 1;

    @Override
    public void handle(HttpExchange exchange) throws IOException {
        String method = exchange.getRequestMethod();
        String path = exchange.getRequestURI().getPath();

        switch (method) {
            case "GET":
                handleGet(exchange);
                break;
            case "POST":
                handlePost(exchange);
                break;
            default:
                sendResponse(exchange, 405, "{\"error\": \"Método não permitido\"}");
        }
    }

    private void handleGet(HttpExchange exchange) throws IOException {
        String json = "[";
        for (Task task : tasks) {
            json += String.format(
                "{\"id\": %d, \"title\": \"%s\", \"completed\": %b},",
                task.getId(), task.getTitle(), task.isCompleted()
            );
        }
        json = json.isEmpty() ? "[]" : json.substring(0, json.length() - 1) + "]";
        sendResponse(exchange, 200, json);
    }

    private void handlePost(HttpExchange exchange) throws IOException {
        String body = new String(exchange.getRequestBody().readAllBytes());
        // Simples parsing (em produção, use uma biblioteca JSON)
        String title = body.split("\"")[3]; // Extrai o título do JSON
        Task task = new Task(nextId++, title, false);
        tasks.add(task);
        sendResponse(exchange, 201, "{\"id\": " + task.getId() + "}");
    }

    private void sendResponse(HttpExchange exchange, int statusCode, String response) throws IOException {
        exchange.getResponseHeaders().set("Content-Type", "application/json");
        exchange.sendResponseHeaders(statusCode, response.getBytes().length);
        try (OutputStream os = exchange.getResponseBody()) {
            os.write(response.getBytes());
        }
    }
}

Classe `Server` (Iniciar Servidor)

package api;

import com.sun.net.httpserver.HttpServer;
import java.io.IOException;
import java.net.InetSocketAddress;

public class Server {
    public static void main(String[] args) throws IOException {
        HttpServer server = HttpServer.create(new InetSocketAddress(8080), 0);
        server.createContext("/tasks", new TaskHandler());
        server.start();
        System.out.println("Servidor iniciado na porta 8080");
    }
}

Parte 2: Consumindo a API (Cliente HTTP)

Classe `ApiClient`

package client;

import java.io.IOException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.io.OutputStream;
import java.io.InputStream;
import java.util.Scanner;

public class ApiClient {

    public static String get(String url) throws IOException {
        HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
        conn.setRequestMethod("GET");

        try (InputStream is = conn.getInputStream();
             Scanner scanner = new Scanner(is)) {
            return scanner.useDelimiter("\\A").next();
        }
    }

    public static String post(String url, String jsonBody) throws IOException {
        HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
        conn.setRequestMethod("POST");
        conn.setRequestProperty("Content-Type", "application/json");
        conn.setDoOutput(true);

        try (OutputStream os = conn.getOutputStream()) {
            os.write(jsonBody.getBytes());
        }

        try (InputStream is = conn.getInputStream();
             Scanner scanner = new Scanner(is)) {
            return scanner.useDelimiter("\\A").next();
        }
    }

    public static void main(String[] args) {
        try {
            // POST: Criar uma tarefa
            String responsePost = post("http://localhost:8080/tasks", 
                "{\"title\": \"Aprender Java\", \"completed\": false}");
            System.out.println("POST Response: " + responsePost);

            // GET: Listar tarefas
            String responseGet = get("http://localhost:8080/tasks");
            System.out.println("GET Response: " + responseGet);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Passo 3: Execução

Inicie o Servidor:

   java api.Server

Execute o Cliente:

   java client.ApiClient

Testando com cURL (Opcional)

# Criar tarefa
curl -X POST -H "Content-Type: application/json" -d "{\"title\":\"Estudar API\",\"completed\":false}" http://localhost:8080/tasks

# Listar tarefas
curl http://localhost:8080/tasks

Considerações

Simplicidade vs. Robustez:
- O servidor usa com.sun.net.httpserver, ideal para protótipos. Em produção, prefira frameworks como Spring Boot ou Javalin.
- O parsing de JSON é simplificado. Use bibliotecas como Jackson ou Gson para manipulação real de JSON.
Cliente HTTP:
- Para projetos reais, use HttpClient (Java 11+) ou bibliotecas como OkHttp.
Melhorias Possíveis:
- Adicionar tratamento de erros.
- Implementar métodos PUT e DELETE.
- Validar entradas.

CRUD Java, MySQL e JDBC

Brayan Monteiro — Thu, 06 Mar 2025 22:24:59 +0000

Vou criar um guia CRUD (Create, Read, Update, Delete) em Java puro (usando JDBC para conexão com banco de dados). Usaremos o MySQL como exemplo, mas você pode adaptar para outros bancos.

Pré-requisitos

Banco de dados MySQL instalado.
Driver JDBC do MySQL (arquivo mysql-connector-java-X.X.XX.jar).
Java 8 ou superior.

Passo 1: Configurar o Banco de Dados

Crie uma tabela usuarios no MySQL:

CREATE DATABASE crud_java;
USE crud_java;

CREATE TABLE usuarios (
    id INT PRIMARY KEY AUTO_INCREMENT,
    nome VARCHAR(50) NOT NULL,
    email VARCHAR(50) NOT NULL UNIQUE,
    idade INT
);

Passo 2: Estrutura do Projeto Java

Crie um projeto Java e adicione o driver JDBC ao classpath (dependência).

src
└── main
    └── java
        ├── ConnectionFactory.java
        ├── UsuarioDAO.java
        └── Main.java

Passo 3: Código Java

Classe `ConnectionFactory` (Conexão com o Banco)

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class ConnectionFactory {
    private static final String URL = "jdbc:mysql://localhost:3306/crud_java";
    private static final String USER = "root";
    private static final String PASSWORD = "sua_senha";

    public static Connection getConnection() {
        try {
            return DriverManager.getConnection(URL, USER, PASSWORD);
        } catch (SQLException e) {
            throw new RuntimeException("Erro ao conectar ao banco de dados", e);
        }
    }
}

Classe `UsuarioDAO` (Operações CRUD)

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class UsuarioDAO {

    // CREATE
    public void create(Usuario usuario) {
        String sql = "INSERT INTO usuarios (nome, email, idade) VALUES (?, ?, ?)";
        try (Connection conn = ConnectionFactory.getConnection();
             PreparedStatement stmt = conn.prepareStatement(sql)) {

            stmt.setString(1, usuario.getNome());
            stmt.setString(2, usuario.getEmail());
            stmt.setInt(3, usuario.getIdade());
            stmt.executeUpdate();

        } catch (SQLException e) {
            throw new RuntimeException("Erro ao criar usuário", e);
        }
    }

    // READ
    public List<Usuario> read() {
        String sql = "SELECT * FROM usuarios";
        List<Usuario> usuarios = new ArrayList<>();

        try (Connection conn = ConnectionFactory.getConnection();
             PreparedStatement stmt = conn.prepareStatement(sql);
             ResultSet rs = stmt.executeQuery()) {

            while (rs.next()) {
                Usuario usuario = new Usuario(
                    rs.getInt("id"),
                    rs.getString("nome"),
                    rs.getString("email"),
                    rs.getInt("idade")
                );
                usuarios.add(usuario);
            }

        } catch (SQLException e) {
            throw new RuntimeException("Erro ao listar usuários", e);
        }
        return usuarios;
    }

    // UPDATE
    public void update(Usuario usuario) {
        String sql = "UPDATE usuarios SET nome = ?, email = ?, idade = ? WHERE id = ?";
        try (Connection conn = ConnectionFactory.getConnection();
             PreparedStatement stmt = conn.prepareStatement(sql)) {

            stmt.setString(1, usuario.getNome());
            stmt.setString(2, usuario.getEmail());
            stmt.setInt(3, usuario.getIdade());
            stmt.setInt(4, usuario.getId());
            stmt.executeUpdate();

        } catch (SQLException e) {
            throw new RuntimeException("Erro ao atualizar usuário", e);
        }
    }

    // DELETE
    public void delete(int id) {
        String sql = "DELETE FROM usuarios WHERE id = ?";
        try (Connection conn = ConnectionFactory.getConnection();
             PreparedStatement stmt = conn.prepareStatement(sql)) {

            stmt.setInt(1, id);
            stmt.executeUpdate();

        } catch (SQLException e) {
            throw new RuntimeException("Erro ao deletar usuário", e);
        }
    }
}

Classe `Usuario` (Modelo)

public class Usuario {
    private int id;
    private String nome;
    private String email;
    private int idade;

    // Construtor, getters e setters
    public Usuario(int id, String nome, String email, int idade) {
        this.id = id;
        this.nome = nome;
        this.email = email;
        this.idade = idade;
    }

    // Getters e Setters
    public int getId() { return id; }
    public String getNome() { return nome; }
    public String getEmail() { return email; }
    public int getIdade() { return idade; }
}

Classe `Main` (Teste)

import java.util.List;

public class Main {
    public static void main(String[] args) {
        UsuarioDAO usuarioDAO = new UsuarioDAO();

        // CREATE
        Usuario novoUsuario = new Usuario(0, "João Silva", "joao@email.com", 30);
        usuarioDAO.create(novoUsuario);

        // READ
        List<Usuario> usuarios = usuarioDAO.read();
        for (Usuario u : usuarios) {
            System.out.println(u.getId() + " - " + u.getNome());
        }

        // UPDATE
        Usuario usuarioAtualizado = new Usuario(1, "João Silva Atualizado", "joao.novo@email.com", 35);
        usuarioDAO.update(usuarioAtualizado);

        // DELETE
        usuarioDAO.delete(1);
    }
}

Passo 4: Execução

Adicione o driver JDBC ao classpath (no Eclipse: Botão direito no projeto > Build Path > Configure Build Path > Libraries > Add JARs).
Execute a classe Main.

Considerações

Tratamento de Exceções: Use try-with-resources para garantir que conexões sejam fechadas automaticamente.
Segurança: Use PreparedStatement para evitar SQL injection.
Transações: Para operações críticas, adicione controle transacional com commit() e rollback().

Este é um exemplo básico. Para projetos reais, considere usar:

Frameworks como Hibernate (JPA) ou Spring JDBC.
Pool de conexões (ex: HikariCP).
Tratamento mais robusto de exceções.

PL/SQL na prática!

Brayan Monteiro — Thu, 06 Mar 2025 22:20:31 +0000

Seção 1 – PL/SQL Fundamentos - Bloco Anônimo

Um bloco anônimo é um trecho de código PL/SQL executado uma única vez, sem ser armazenado no banco de dados.

Estrutura Básica:

DECLARE
  -- Declarações de variáveis e constantes
BEGIN
  -- Lógica principal
EXCEPTION
  -- Tratamento de exceções
END;

Exemplo:

DECLARE
  v_nome VARCHAR2(50) := 'João';
BEGIN
  DBMS_OUTPUT.PUT_LINE('Olá, ' || v_nome);
EXCEPTION
  WHEN OTHERS THEN
    DBMS_OUTPUT.PUT_LINE('Erro: ' || SQLERRM);
END;

Seção 2 – Declaração de Identificadores

Variáveis

DECLARE
  v_id NUMBER := 10;          -- Tipo NUMBER
  v_data DATE := SYSDATE;     -- Tipo DATE
  v_texto VARCHAR2(100);      -- Variável não inicializada
BEGIN
  v_texto := 'Texto dinâmico';
END;

Constantes

DECLARE
  c_pi CONSTANT NUMBER := 3.1415;
BEGIN
  DBMS_OUTPUT.PUT_LINE('Valor de PI: ' || c_pi);
END;

Tipos de Dados

NUMBER, VARCHAR2, DATE, BOOLEAN, etc.

Variável Bind

Variáveis declaradas fora do bloco PL/SQL (em SQL*Plus ou SQL Developer):

VARIABLE g_id NUMBER
BEGIN
  :g_id := 100;
END;
/
PRINT g_id;

Seção 3 – Sintaxe e Diretrizes

Exemplo com Função:

DECLARE
  v_total NUMBER;
BEGIN
  SELECT COUNT(*) INTO v_total FROM employees;
  DBMS_OUTPUT.PUT_LINE('Total de empregados: ' || v_total);
END;

Blocos Aninhados:

DECLARE
  v_global NUMBER := 1;
BEGIN
  DECLARE
    v_local NUMBER := 2;
  BEGIN
    DBMS_OUTPUT.PUT_LINE(v_global + v_local); -- Resultado: 3
  END;
END;

Seção 4 – Comandos SQL no PL/SQL

SELECT INTO

DECLARE
  v_nome employees.first_name%TYPE;
BEGIN
  SELECT first_name INTO v_nome 
  FROM employees 
  WHERE employee_id = 100;
  DBMS_OUTPUT.PUT_LINE(v_nome);
END;

INSERT

BEGIN
  INSERT INTO employees (employee_id, first_name, last_name)
  VALUES (1000, 'Maria', 'Silva');
  COMMIT;
END;

Cursor Implícito

BEGIN
  UPDATE employees SET salary = salary * 1.1;
  DBMS_OUTPUT.PUT_LINE(SQL%ROWCOUNT || ' linhas atualizadas.');
END;

Seção 5 – Estruturas de Controle

IF-THEN-ELSE

DECLARE
  v_nota NUMBER := 75;
BEGIN
  IF v_nota >= 70 THEN
    DBMS_OUTPUT.PUT_LINE('Aprovado');
  ELSE
    DBMS_OUTPUT.PUT_LINE('Reprovado');
  END IF;
END;

CASE

DECLARE
  v_dia VARCHAR2(10) := 'Segunda';
BEGIN
  CASE v_dia
    WHEN 'Segunda' THEN DBMS_OUTPUT.PUT_LINE('Dia útil');
    ELSE DBMS_OUTPUT.PUT_LINE('Fim de semana');
  END CASE;
END;

LOOP Básico

DECLARE
  i NUMBER := 1;
BEGIN
  LOOP
    DBMS_OUTPUT.PUT_LINE(i);
    i := i + 1;
    EXIT WHEN i > 5;
  END LOOP;
END;

Seção 6 – Tipos Compostos (Records)

DECLARE
  TYPE t_empregado IS RECORD (
    id employees.employee_id%TYPE,
    nome employees.first_name%TYPE
  );
  v_emp t_empregado;
BEGIN
  SELECT employee_id, first_name INTO v_emp 
  FROM employees 
  WHERE employee_id = 100;
  DBMS_OUTPUT.PUT_LINE(v_emp.nome);
END;

%ROWTYPE

DECLARE
  v_emp employees%ROWTYPE;
BEGIN
  SELECT * INTO v_emp 
  FROM employees 
  WHERE employee_id = 100;
  DBMS_OUTPUT.PUT_LINE(v_emp.first_name);
END;

Seção 7 – Collections

Associative Array

DECLARE
  TYPE t_nomes IS TABLE OF VARCHAR2(50) INDEX BY PLS_INTEGER;
  v_lista t_nomes;
BEGIN
  v_lista(1) := 'Maria';
  v_lista(2) := 'João';
  DBMS_OUTPUT.PUT_LINE(v_lista(1));
END;

Bulk Collect

DECLARE
  TYPE t_emp_ids IS TABLE OF employees.employee_id%TYPE;
  v_ids t_emp_ids;
BEGIN
  SELECT employee_id BULK COLLECT INTO v_ids 
  FROM employees 
  WHERE department_id = 50;
  DBMS_OUTPUT.PUT_LINE(v_ids.COUNT || ' registros.');
END;

Seção 8 – Cursor Explícito

Cursor com Parâmetros

DECLARE
  CURSOR c_emp (p_dept_id NUMBER) IS
    SELECT * FROM employees WHERE department_id = p_dept_id;
  v_emp employees%ROWTYPE;
BEGIN
  OPEN c_emp(50);
  LOOP
    FETCH c_emp INTO v_emp;
    EXIT WHEN c_emp%NOTFOUND;
    DBMS_OUTPUT.PUT_LINE(v_emp.first_name);
  END LOOP;
  CLOSE c_emp;
END;

Seção 9 – Tratamento de Exceções

DECLARE
  v_div NUMBER;
BEGIN
  v_div := 10 / 0; -- Divisão por zero
EXCEPTION
  WHEN ZERO_DIVIDE THEN
    DBMS_OUTPUT.PUT_LINE('Erro: Divisão por zero.');
END;

Seção 10 – Procedures

Criando uma Procedure

CREATE OR REPLACE PROCEDURE aumentar_salario (
  p_emp_id IN NUMBER,
  p_percentual IN NUMBER
) AS
BEGIN
  UPDATE employees 
  SET salary = salary * (1 + p_percentual/100)
  WHERE employee_id = p_emp_id;
  COMMIT;
END aumentar_salario;

Chamando a Procedure:

BEGIN
  aumentar_salario(100, 10); -- Aumenta 10% para o empregado 100
END;

Seção 11 – Funções

Criando uma Função

CREATE OR REPLACE FUNCTION calcular_idade (
  p_data_nasc DATE
) RETURN NUMBER AS
  v_idade NUMBER;
BEGIN
  v_idade := TRUNC(MONTHS_BETWEEN(SYSDATE, p_data_nasc) / 12);
  RETURN v_idade;
END calcular_idade;

Usando a Função em SQL:

SELECT first_name, calcular_idade(birth_date) AS idade 
FROM employees;

Seção 12 – Packages

Package Specification

CREATE OR REPLACE PACKAGE pkg_emp AS
  PROCEDURE aumentar_salario(p_emp_id NUMBER, p_percentual NUMBER);
  FUNCTION calcular_idade(p_data_nasc DATE) RETURN NUMBER;
END pkg_emp;

Package Body

CREATE OR REPLACE PACKAGE BODY pkg_emp AS
  PROCEDURE aumentar_salario(p_emp_id NUMBER, p_percentual NUMBER) IS
  BEGIN
    UPDATE employees 
    SET salary = salary * (1 + p_percentual/100)
    WHERE employee_id = p_emp_id;
    COMMIT;
  END;

  FUNCTION calcular_idade(p_data_nasc DATE) RETURN NUMBER IS
    v_idade NUMBER;
  BEGIN
    v_idade := TRUNC(MONTHS_BETWEEN(SYSDATE, p_data_nasc) / 12);
    RETURN v_idade;
  END;
END pkg_emp;

Seção 13 – Triggers DML

Trigger a Nível de Linha

CREATE OR REPLACE TRIGGER trg_audit_salary
BEFORE UPDATE OF salary ON employees
FOR EACH ROW
BEGIN
  INSERT INTO salary_audit (employee_id, old_salary, new_salary)
  VALUES (:OLD.employee_id, :OLD.salary, :NEW.salary);
END;

Seção 14 – Bulk Collect com LIMIT

DECLARE
  TYPE t_emp_ids IS TABLE OF employees.employee_id%TYPE;
  v_ids t_emp_ids;
  CURSOR c_emp IS SELECT employee_id FROM employees;
BEGIN
  OPEN c_emp;
  LOOP
    FETCH c_emp BULK COLLECT INTO v_ids LIMIT 100;
    EXIT WHEN v_ids.COUNT = 0;
    -- Processar 100 registros por vez
  END LOOP;
  CLOSE c_emp;
END;

Seção 15 – SQL Dinâmico

EXECUTE IMMEDIATE

DECLARE
  v_sql VARCHAR2(200);
  v_emp_id NUMBER := 100;
  v_salary NUMBER;
BEGIN
  v_sql := 'SELECT salary FROM employees WHERE employee_id = :id';
  EXECUTE IMMEDIATE v_sql INTO v_salary USING v_emp_id;
  DBMS_OUTPUT.PUT_LINE(v_salary);
END;

Seção 16 – LOBs (BLOB)

DECLARE
  v_blob BLOB;
  v_bfile BFILE := BFILENAME('DIR_IMAGENS', 'foto.jpg');
BEGIN
  INSERT INTO imagens (id, imagem) 
  VALUES (1, EMPTY_BLOB())
  RETURNING imagem INTO v_blob;

  DBMS_LOB.OPEN(v_bfile, DBMS_LOB.LOB_READONLY);
  DBMS_LOB.LOADFROMFILE(v_blob, v_bfile, DBMS_LOB.GETLENGTH(v_bfile));
  DBMS_LOB.CLOSE(v_bfile);
  COMMIT;
END;

Fluxo completo do GIT para trabalhar

Brayan Monteiro — Wed, 05 Mar 2025 01:16:06 +0000

📌 1. Instalação e Configuração Inicial

Se for uma máquina nova, instale o Git:

🔹 Windows: Baixe aqui e instale.

🔹 Linux (Debian/Ubuntu):

sudo apt update && sudo apt install git -y

🔹 Linux (Fedora/RHEL):

sudo dnf install git -y

Depois de instalar, configure seu usuário:

git config --global user.name "Seu Nome"
git config --global user.email "seu@email.com"

Verifique se ficou certo:

git config --list

🔑 2. Autenticação no GitLab

O GitLab pode exigir autenticação via token de acesso pessoal (PAT) em vez de senha.

Para configurar:

1️⃣ Gerar um token no GitLab:

Vá em Configurações > Acessos Tokens no GitLab
Crie um token com permissão de leitura/gravação no repositório

2️⃣ Autenticar usando o token ao clonar ou enviar commits:

git clone https://oauth2:<TOKEN>@gitlab.com/usuario/repo.git

ou configure o SSH para evitar login manual.

📥 3. Clonar um Repositório e Criar uma Branch de Desenvolvimento

🔹 Baixar um projeto do GitLab:

git clone https://gitlab.com/usuario/repositorio.git

🔹 Entrar na pasta do repositório:

cd repositorio

🔹 Listar branches disponíveis:

git branch -r

🔹 Criar uma branch nova para desenvolvimento:

git checkout -b minha-branch

🔹 Se a branch já existe no remoto:

git checkout -b minha-branch origin/minha-branch

✏️ 4. Fazer Mudanças e Commitar

Após modificar arquivos, siga este fluxo:

🔹 Verificar o que mudou:

git status

🔹 Adicionar os arquivos ao commit:

git add .

🔹 Criar um commit com mensagem:

git commit -m "Descrição clara da mudança"

🔹 Enviar as mudanças para o repositório remoto:

git push origin minha-branch

🔹 Se for o primeiro push da branch para o remoto:

git push --set-upstream origin minha-branch

📤 5. Atualizar o Código Antes de Trabalhar

Antes de começar a desenvolver, sempre atualize seu código:

🔹 Baixar as últimas mudanças da branch principal:

git checkout main  # Ou master
git pull origin main

🔹 Atualizar sua branch com a última versão:

git checkout minha-branch
git merge main  # Ou rebase: git rebase main

🔄 6. Resolver Conflitos e Corrigir Erros

Se houver conflitos ao fazer merge/rebase:

🔹 Ver arquivos com conflito:

git status

🔹 Editar os arquivos manualmente, resolver o conflito e adicionar novamente:

git add arquivo-com-conflito
git commit -m "Resolvido conflito no arquivo X"

🔄 7. Criar e Restaurar Commits

🔹 Se precisar desfazer mudanças antes de commitar:

git checkout -- arquivo.txt  # Restaura um arquivo específico
git reset --hard HEAD        # Restaura tudo (⚠️ perda de mudanças)

🔹 Se precisar desfazer um commit já enviado:

git revert <ID-do-commit>
git push origin minha-branch

📌 8. Revisão Final Antes de Enviar para Produção

🔹 Mesclar a branch de desenvolvimento na branch principal:

git checkout main
git merge minha-branch

🔹 Enviar para produção (se aplicável):

git push origin main

Fluxo para navegar entre as branchs: como Alternar Entre Branches no Git Sem Clonar o Repositório Novamente

Quando trabalhamos em projetos com Git, é comum precisarmos alternar entre diferentes branches sem perder o progresso atual. Neste artigo, vamos mostrar um fluxo eficiente para trocar de branch sem precisar clonar o repositório novamente.

🎯 Cenário: Você já clonou o repositório e precisa alternar de branch

Imagine que você já tem um repositório clonado e está atualmente na branch feature-login. Agora, deseja trabalhar nas branches feature-dashboard e feature-relatorio. Como fazer isso sem perder as mudanças?

📝 Passo 1: Verificar em Qual Branch Você Está

Antes de trocar de branch, veja em qual você está atualmente:

git branch

A branch atual será marcada com um *.

Se houver mudanças não commitadas e você não quiser perdê-las ao trocar de branch, faça um stash para guardá-las temporariamente:

git stash

🔀 Passo 2: Listar Todas as Branches Disponíveis

Para ver todas as branches remotas disponíveis, use:

git branch -r

Exemplo de saída:

  origin/feature-login
  origin/feature-dashboard
  origin/feature-relatorio
  origin/develop
  origin/main

🚀 Passo 3: Alternar Para Outra Branch

Agora, escolha a branch que deseja trabalhar. Para trocar para feature-dashboard, execute:

git checkout -b feature-dashboard origin/feature-dashboard

Isso cria uma cópia local da branch remota e muda para ela.

Se quiser ir para a feature-relatorio, basta repetir o processo:

git checkout -b feature-relatorio origin/feature-relatorio

🔄 Passo 4: Atualizar a Branch com o Código Mais Recente

Depois de mudar para a branch desejada, atualize o código para garantir que está com a versão mais recente:

git pull origin feature-dashboard

git pull origin feature-relatorio

Isso sincroniza sua branch local com as últimas atualizações do repositório remoto.

🔄 Passo 5: Alternar Entre as Branches Sempre Que Precisar

Caso precise voltar para a branch anterior, use:

git checkout feature-login

Se você tinha usado git stash para salvar suas mudanças antes de trocar de branch, recupere-as com:

git stash pop

🏁 Conclusão

Agora você já sabe como alternar entre branches no Git sem precisar clonar o repositório novamente! Esse fluxo ajuda a manter o ambiente organizado e evita trabalho duplicado.

Se tiver dúvidas ou sugestões, deixe nos comentários! 🚀

Como fazer procv

Brayan Monteiro — Wed, 08 Jan 2025 12:14:14 +0000

O conceito é o mesmo pro Excel e pro libreCalc, apenas adaptando a sintaxe.

Este PROCV verifica se o valor da célula B2 existe na coluna A de um intervalo fixo ($A$2:$A$12). O intervalo de procura foi fixado utilizando referências absolutas ($), garantindo que a tabela de busca não mude ao copiar ou arrastar a fórmula para outras linhas. Apenas o valor de referência (neste caso, B2) será ajustado automaticamente, permitindo que a fórmula seja aplicada dinamicamente a outras células.

base1	base2	procv
1	1	1
2	25	#N/D
4	23	#N/D
3	2	2
4	21	#N/D
5	58	#N/D
4	4	4
8	13	#N/D
9	85	#N/D
10	86	#N/D
11	90	#N/D

=PROCV(B2; $A$2:$A$12; 1; 0)

Explicação de como funciona o PROCV

O PROCV é uma fórmula do Excel que busca um valor em uma tabela verticalmente (daí o nome PROCV, ou "Procura Vertical"). Ele é usado para localizar informações em uma tabela com base em uma referência.

A estrutura da fórmula é a seguinte:

=PROCV(valor_procurado; tabela_array; número_índice_coluna; [procurar_intervalo])

Explicação dos argumentos:

valor_procurado: O valor que você deseja buscar na primeira coluna da tabela. Pode ser uma célula (ex.: A2) ou um valor fixo (ex.: "João").
tabela_array: O intervalo onde está sua tabela. Deve incluir a coluna onde você busca o valor e a(s) coluna(s) de onde deseja retornar os dados (ex.: A1:D10).
número_índice_coluna: O número da coluna na tabela_array que contém o valor a ser retornado. A contagem começa do número 1 (a primeira coluna do intervalo).
procurar_intervalo (opcional): Define se a busca será por uma correspondência exata ou aproximada:
- VERDADEIRO (ou 1): Busca aproximada (a tabela deve estar ordenada por ordem crescente).
- FALSO (ou 0): Busca exata (mais usada).

Dicas:

Cuidado com dados duplicados: O PROCV retorna apenas o primeiro valor encontrado.
Caso de erro (#N/D): Use a função SEERRO para tratar erros:

   =SEERRO(PROCV("Maria", A2:C4, 3, FALSO), "Não encontrado")

O PROCV é limitado a buscas verticais. Para buscas mais flexíveis (ex.: horizontais ou múltiplos critérios), considere o ÍNDICE + CORRESP ou o XLOOKUP (ProcurarX nas versões mais recentes).

DEV Community: Brayan Monteiro

Tutorial – Formatar Pendrive em exFAT (Fedora KDE)

🎯 Objetivo

⚠️ PASSO 0 – Identificar o pendrive

🧹 PASSO 1 – Garantir que não está montado

💣 PASSO 2 – Apagar completamente a assinatura

🗂 PASSO 3 – Criar nova tabela GPT

📦 PASSO 4 – Criar partição usando 100% do espaço

💾 PASSO 5 – Formatar em exFAT

🏷 PASSO 6 – Definir nome (LABEL)

🔄 PASSO 7 – Reconectar

📌 Comando resumido (modo ninja)

✅ Resultado Final

Como corrigir o erro de GPG do repositório do Cursor no Linux Mint

1. Baixe a chave GPG correta

2. Recrie o arquivo do repositório apontando para esse keyring

3. Atualize o sistema

Por que isso funciona?

Quer confirmar se funcionou?

Instalar DBeaver no Linux Mint com atualização automática

✅ O método “não-oficial” (mas funcional) com auto update no Linux Mint

🧠 O que acontece por baixo dos panos

🧩 Pra conferir se deu certo

Linux Mint + tecla Copilot: abrindo o WebApp do ChatGPT (maximizado)

Por que isso dá trabalho?

1) Crie o WebApp do ChatGPT (via interface)

2) Confirme o .desktop do seu WebApp

3) Mapeie o botão Copilot para abrir o WebApp (GUI)

4) Como abrir maximizado de forma confiável

5) Teste o .desktop pelo terminal

6) Por que “abria como outro Chrome” antes?

7) Extras úteis (opcionais)

Focar a janela se já estiver aberta

Usando Edge/Brave/Chromium

Onde ficam os .desktop

8) Check-list final

PHP e Java equivalências

Scrum explicado

O que é o Scrum?

Principais conceitos do Scrum

Como o Scrum funciona na prática?

Vantagens do Scrum

Resumo do Scrum em uma analogia simples:

Deixar tabela responsiva em site wordpress

Como criar e consumir uma API REST simples em Java puro

Parte 1: Criando a API (Servidor HTTP)

Passo 1: Estrutura do Projeto

Passo 2: Código do Servidor

Classe Task (Modelo)

Classe TaskHandler (Manipulador de Requisições)

Classe Server (Iniciar Servidor)

Parte 2: Consumindo a API (Cliente HTTP)

Classe ApiClient

Passo 3: Execução

Testando com cURL (Opcional)

Considerações

CRUD Java, MySQL e JDBC

Pré-requisitos

Passo 1: Configurar o Banco de Dados

Passo 2: Estrutura do Projeto Java

Passo 3: Código Java

Classe ConnectionFactory (Conexão com o Banco)

Classe UsuarioDAO (Operações CRUD)

Classe Usuario (Modelo)

Classe Main (Teste)

Passo 4: Execução

Considerações

PL/SQL na prática!

Seção 1 – PL/SQL Fundamentos - Bloco Anônimo

Seção 2 – Declaração de Identificadores

Variáveis

Constantes

Tipos de Dados

Variável Bind

Seção 3 – Sintaxe e Diretrizes

Seção 4 – Comandos SQL no PL/SQL

SELECT INTO

INSERT

Cursor Implícito

Seção 5 – Estruturas de Controle

2) Confirme o `.desktop` do seu WebApp

5) Teste o `.desktop` pelo terminal

Onde ficam os `.desktop`

Classe `Task` (Modelo)

Classe `TaskHandler` (Manipulador de Requisições)

Classe `Server` (Iniciar Servidor)

Classe `ApiClient`

Classe `ConnectionFactory` (Conexão com o Banco)

Classe `UsuarioDAO` (Operações CRUD)

Classe `Usuario` (Modelo)

Classe `Main` (Teste)