DEV Community: Matheus de Gondra

C23, CMake e vcpkg: Como estruturar um projeto C moderno

Matheus de Gondra — Fri, 02 Oct 2026 22:07:05 +0000

A linguagem C evolui ao longo do tempo atualizando sua versão, até a atual C23. As ferramentas do ambiente C também evoluíram, e isso que quero mostrar.

Criando projeto

Não vamos começar com algo complexo de início. Vamos apenas criar um código C simples com um src/main.c e ir incrementando.

#include <stdio.h>
#include <stdlib.h>

int main() {
  printf("Iniciando projeto!\n");

  return EXIT_SUCCESS;
}

Agora vamos compilar usando o GCC e executar

gcc src/main.c -o main
./main

Agora vamos criar um struct para representar um usuário. Essa struct terá os campos id, nome, email e created_at. Vamos criar também funções para criar a struct, printar os valores dela e para liberar a memória.

#include <stdint.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

typedef struct {
    uint64_t id;
    char *name;
    char *email;
    time_t created_at;
} User;

User *User_new(uint64_t id, const char *name, const char *email) {
    User *user = malloc(sizeof(User));
    if (!user) {
        fprintf(stderr, "Falha ao alocar memória para o usuário\n");
        exit(EXIT_FAILURE);
    }

    bool is_email_valid = strstr(email, "@") != NULL;
    if (!is_email_valid) {
        fprintf(stderr, "Email inválido: %s\n", email);
        free(user);
        exit(EXIT_FAILURE);
    }

    user->id = id;
    user->name = strdup(name);
    user->email = strdup(email);
    user->created_at = time(NULL);

    return user;
}

void User_free(User *user) {
    if (user) {
        free(user->name);
        free(user->email);
        free(user);
    }
}

void User_print(const User *user) {
    struct tm *info_time = gmtime(&user->created_at);
    char timestamp_str[20];

    strftime(timestamp_str, sizeof(timestamp_str), "%Y-%m-%dT%H:%M:%S", info_time);

    printf(
    "User{id: %" PRIu64 ", name: %s, email: %s, created_at: %s}\n",
        user->id,
        user->name,
        user->email,
        timestamp_str
    );
}

int main() {
  printf("Iniciando projeto!\n");
  User *user = User_new(1, "Fulano", "fulano@mail.com");

  User_print(user);

  User_free(user);
  return EXIT_SUCCESS;
}

Agora vamos compilar e vamos adicionar explicitamente para usar a versão C23 da linguagem C.

gcc src/main.c -o main -std=c23
./main

Separando arquivos

Fazer tudo dentro do arquivo main.c deixa tudo muito poluído. Uma boa prática é separar o código em outros arquivos. Em C podemos criar arquivo de cabeçalho (.h) com as definições das funções e structs e um arquivo fonte (.c) para implementar o cabeçalho.

Vamos criar o include/user.h e mover a definições da estrutura e das funções para lá. Vamos usar o #pragma once no arquivo para impedir que o cabeçalho seja importado duas vezes.

// Garante que só importe o cabeçalho apenas uma vez,
// caso use o #include duas vezes ou mais
#pragma once

#include <stdint.h>
#include <time.h>

typedef struct {
    uint64_t id;
    char *name;
    char *email;
    time_t created_at;
} User;

User *User_new(uint64_t id, const char *name, const char *email);
void User_free(User *user);
void User_print(const User *user);

E criaremos um arquivo fonte src/user.c para implementar essas funções.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <inttypes.h>
#include "user.h" // importa o cabeçalho

User *User_new(uint64_t id, const char *name, const char *email) {
    User *user = malloc(sizeof(User));
    if (!user) {
        fprintf(stderr, "Falha ao alocar memória para o usuário\n");
        exit(EXIT_FAILURE);
    }

    bool is_email_valid = strstr(email, "@") != NULL;
    if (!is_email_valid) {
        fprintf(stderr, "Email inválido: %s\n", email);
        free(user);
        exit(EXIT_FAILURE);
    }

    user->id = id;
    user->name = strdup(name);
    user->email = strdup(email);
    user->created_at = time(NULL);

    return user;
}

void User_free(User *user) {
    if (user) {
        free(user->name);
        free(user->email);
        free(user);
    }
}

void User_print(const User *user) {
    struct tm *info_time = gmtime(&user->created_at);
    char timestamp_str[20];

    strftime(timestamp_str, sizeof(timestamp_str), "%Y-%m-%dT%H:%M:%S", info_time);

    printf(
    "User{id: %" PRIu64 ", name: %s, email: %s, created_at: %s}\n",
        user->id,
        user->name,
        user->email,
        timestamp_str
    );
}

E nosso src/main.c irá importar nosso arquivo de cabeçalho user.h e isso deixará nosso código na main mais limpo.

#include <stdio.h>
#include <stdlib.h>
#include "user.h"

int main() {
  printf("Iniciando projeto!\n");
  User *user = User_new(1, "Fulano", "fulano@mail.com");

  User_print(user);

  User_free(user);
  return EXIT_SUCCESS;
}

Agora para compilar vamos ter que passar os dois arquivos fonte main.c e user.c.

Além disso como importamos o cabeçalho como #include "user.h" vamos precisar passar onde esse cabeçalho está usando a flag -I<path>. Poderiamos passar o caminho completo ou relativo do arquivo no include, eliminando a necessidade da flag, #include "../include/user.h, mas o padrão é passar a flag ao compilar.

Também vou adicionar outras flag para tornar o compilador mais rigoroso como -Wall e -Wextra para ativar alguns warnings e -Werror para transformar os warnings em erros.

gcc -o main -std=c23 -Wall -Wextra -Werror -Iinclude src/main.c src/user.c
./main

Automatizando o build

À medida que o projeto cresce, novos arquivos de cabeçalho e fonte são criados. Com isso, o nosso comando de compilação vai crescendo e se torna cada vez mais difícil de lembrar. Você pode acabar esquecendo de incluir um arquivo ou um diretório e falhar na compilação.

Para resolver isso, temos ferramentas de build como o Make e o Ninja, que é uma opção mais rápida e moderna que iremos usar. Geralmente, o Ninja não é escrito diretamente à mão, ele costuma ser usado junto de outra ferramenta: o CMake. O CMake é um gerador de sistema de build. Ele lê um arquivo de configuração simples e gera a estrutura complexa necessária para o Ninja realizar o trabalho pesado da compilação.

Vamos criar um arquivo chamado CMakeLists.txt na raiz do projeto para descrever como nosso código deve ser compilado:

cmake_minimum_required(VERSION 3.20) # versão mínima do CMake necessária para o projeto
project(projectUsers LANGUAGES C) # Nome do projeto e a linguagem como C

set(CMAKE_C_STANDARD 23) # definindo a versão padrão do C como C23
set(CMAKE_C_STANDARD_REQUIRED ON) # garantindo que a versão especificada seja obrigatória
set(CMAKE_C_EXTENSIONS OFF) # desativando extensões específicas do compilador

# Nome do arquivo de saída e os arquivos fonte que serão compilados para gerar o executável
# Usarei o nome do projeto como nome do executável
add_executable(${PROJECT_NAME}
    src/main.c
    src/user.c
)

# Informa ao CMake onde procurar pelos arquivos de cabeçalho (.h)
# O equivalente à flag -Iinclude do GCC
target_include_directories(${PROJECT_NAME} PRIVATE include)

# Adiciona opções de compilação específicas para o alvo (target) do projeto
target_compile_options(${PROJECT_NAME} PRIVATE -Wall -Wextra -Werror)

Agora podemos gerar o sistema de build, ninja, usando o CMake. Usaremos a flag -B <path> para dizer o direto de saída e -G <generator> para dizer qual o sistema de build será gerado.

cmake -B build -G Ninja

Com isso o cmake criará um diretório build com o Ninja como sistema de build. Agora para compilar o código e gerar um executável usamos o seguinte comando:

cmake --build build

Isso irá gerar o executável build/projectUsers que é o nome que demos no nosso CMakeLists.txt no add_executable().

./build/projectUsers

Iniciando projeto!
User{id: 1, name: Fulano, email: fulano@mail.com, created_at: 2026-10-02T12:10:42}

Com isso se eu modificar algum arquivo já existente eu só preciso recompilar usando o cmake --build build.

void User_print(const User *user) {
    struct tm *info_time = gmtime(&user->created_at);
    char timestamp_str[20];

    strftime(timestamp_str, sizeof(timestamp_str), "%Y-%m-%dT%H:%M:%S", info_time);

    // Colocando as string entre aspas no print
    printf(
    "User{id: %" PRIu64 ", name: \"%s\", email: \"%s\", created_at: %s}\n",
        user->id,
        user->name,
        user->email,
        timestamp_str
    );
}

cmake --build build
./build/projectUsers

Iniciando projeto!
User{id: 1, name: "Fulano", email: "fulano@mail.com", created_at: 2026-10-02T12:11:38}

Mas se eu adicionar novos arquivos ao projeto eu tenho que listar esses arquivos dentro do CMakeLists.txt e recriar o sistema de build com o cmake -B build -G Ninja e depois compilar com cmake --build build.

Dependências Externas

Para usar bibliotecas externas no C é um pouco trabalhoso, pois você precisa manualmente baixar e compilar cada biblioteca. Em linguagens como Java, NodeJS, Python, temos um gerenciador de dependências. No C temos o vcpkg, um gerenciador de dependências da Microsoft.

O vcpkg pode ser integrado com o CMake para buscar as dependências externa ao criar o sistema de build.

Na raiz do projeto vamos usar o comando vcpkg new --aplication. Isso irá gerar os arquivos vcpkg-configuration.json e vcpkg.json.

No vcpkg.json será onde ficará listados as dependências do projeto. Vamos usar a biblioteca cJSON. Para adicionar ela ao projeto usamos o comando vcpkg add port cjson. Isso atualizará o vcpkg.json.

{
  "dependencies": [
    "cjson"
  ]
}

Se quiser achar outra dependência pode olhar no site do vcpkg.

Integrando vcpkg e CMake

Agora no comando para gerar o sistema de build passamos a flag --toolchain <diretorio_vcpkg>/scripts/buildsystems/vcpkg.cmake para injetar o script do vcpkg no CMake que fica dentro do diretório de instalação do vcpkg.

rm -rf build
cmake -B build -G Ninja --toolchain $VCPKG_ROOT/scripts/buildsystems/vcpkg.cmake

Na saída do terminal você verá que mostra o que deve ser adicionado ao CMakeLists.txt para compilar com essa dependência. No caso do cJSON temos essa saída

cjson provides CMake targets:

  # this is heuristically generated, and may not be correct
  find_package(cJSON CONFIG REQUIRED)
  target_link_libraries(main PRIVATE cjson)

O CMakeLists.txt ficou assim:

cmake_minimum_required(VERSION 3.20) 
project(projectUsers LANGUAGES C) 

set(CMAKE_C_STANDARD 23) 
set(CMAKE_C_STANDARD_REQUIRED ON) 
set(CMAKE_C_EXTENSIONS OFF)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON) # Para intelisense da IDE usando o clangd

find_package(cJSON CONFIG REQUIRED)

add_executable(${PROJECT_NAME}
    src/main.c
    src/user.c
)

target_link_libraries(${PROJECT_NAME} PRIVATE cjson)

target_include_directories(${PROJECT_NAME} PRIVATE include)

target_compile_options(${PROJECT_NAME} PRIVATE -Wall -Wextra -Werror)

rf -rf build
cmake -B build -G Ninja --toolchain $VCPKG_ROOT/scripts/buildsystems/vcpkg.cmake

Com isso temos o cJSON configurado para usar no projeto. Vamos criar um nova função no include/user.h para usar a biblioteca.

#pragma once

#include <stdint.h>
#include <time.h>

typedef struct {
    uint64_t id;
    char *name;
    char *email;
    time_t created_at;
} User;

User *User_new(uint64_t id, const char *name, const char *email);
void User_free(User *user);
void User_print(const User *user);

// Nova função para converter um User em JSON
char *User_to_json(const User *user);

E vamos implementar no src/user.c a nova função usando o cJSON.

#include <cjson/cJSON.h>

// resto do código omitido

char *User_to_json(const User *user) {
    if (!user) {
        return nullptr;
    }

    cJSON *user_json = cJSON_CreateObject();

    struct tm *info_time = gmtime(&user->created_at);
    char timestamp_str[20];
    strftime(timestamp_str, sizeof(timestamp_str), "%Y-%m-%dT%H:%M:%S", info_time);

    cJSON_AddNumberToObject(user_json, "id", user->id);
    cJSON_AddStringToObject(user_json, "name", user->name);
    cJSON_AddStringToObject(user_json, "email", user->email);
    cJSON_AddStringToObject(user_json, "created_at", timestamp_str);

    char *json_string = cJSON_Print(user_json);
    cJSON_Delete(user_json);

    return json_string;
}

E agora vamos usar a função no src/main.c

#include <stdio.h>
#include <stdlib.h>
#include "user.h"

int main() {
  printf("Iniciando projeto!\n");
  User *user = User_new(1, "Fulano", "fulano@mail.com");

  User_print(user);

  char *json = User_to_json(user);
  if (!json) {
    fprintf(stderr, "Falha ao converter o usuário para JSON\n");
    User_free(user);
    return EXIT_FAILURE;
  }

  printf("JSON: %s\n", json);

  User_free(user);
  free(json);
  return EXIT_SUCCESS;
}

cmake --build build
./build/projectUsers

Iniciando projeto!
User{id: 1, name: "Fulano", email: "fulano@mail.com", created_at: 2026-10-02T16:06:28}
JSON: {
        "id":   1,
        "name": "Fulano",
        "email":        "fulano@mail.com",
        "created_at":   "2026-10-02T16:06:28"
}

Simplificando comandos com CMake Presets

Se você reparou, nosso comando do CMake ainda está muito grande e pode ser que acabe sendo digitado de forma errada ou faltando algo.

cmake -B build -G Ninja --toolchain $VCPKG_ROOT/scripts/buildsystems/vcpkg.cmake

E além disso, se rodar o mesmo comando no Windows irá falhar, pois a sintaxe para variáveis de ambiente é diferente.

Para resolver isso o CMake possui os Presets. Podemos criar um arquivo CMakePresets.json na raiz do projeto.

{
    "version": 3,
    "cmakeMinimumRequired": {
        "major": 3,
        "minor": 20,
        "patch": 0
    },
    "configurePresets": [
        {
            "name": "default",
            "displayName": "Configuração padrão (Ninja + vcpkg)",
            "generator": "Ninja",
            "binaryDir": "${sourceDir}/build",
            "cacheVariables": {
                "CMAKE_TOOLCHAIN_FILE": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake"
            }
        }
    ],
    "buildPresets": [
        {
            "name": "default",
            "configurePreset": "default"
        }
    ]
}

Repare que transferimos a variável do vcpkg para o arquivo de preset, usando $env{VCPKG_ROOT} para ler a variável de ambiente do sistema operacional, seja ele Windows ou Linux.

Agora podemos gerar nosso sistema de build usando um comando mais simples

rm -rf build
cmake --preset default

O CMake vai ler o CMakePresets.json para usar o preset default que criamos para gerar o sistema de build. Agora basta compilar o projeto e executar:

cmake --build build
./build/projectUsers

Iniciando projeto!
User{id: 1, name: Fulano, email: fulano@mail.com, created_at: 2026-10-02T21:38:56}
JSON: {
        "id":   1,
        "name": "Fulano",
        "email":        "fulano@mail.com",
        "created_at":   "2026-10-02T21:38:56"
}

Conclusão

O C tem a fama de ser uma linguagem velha e intimidadora e ter um ecossistema difícil de configurar. No entanto, como vimos ao longo deste artigo, isso não é verdade hoje em dia.

A versão C23 trouxe muita modernidade e as ferramentas do ecossistema C está evoluindo.

Espero ter te ajudado a ver como algo simples com 1 arquivo e compilando usando o gcc pode evoluir para arquivos separados e um build automatizado com bibliotecas externas.

Tente fazer um projeto C e adicionar alguma biblioteca e deixe o link do repositório nos comentários e diga o que você achou da leitura.

Java: JPA e Hibernate

Matheus de Gondra — Sun, 20 Sep 2026 02:18:21 +0000

Java é uma linguagem de programação que usa o paradigma Orientado a Objetos. E assim como em outras linguagens, podemos integrar nossos programas com um banco de dados para armazenar dados importantes.

Dentre os tipos de banco de dados, o mais tradicional é o Banco de Dados Relacional. Esse tipo de banco trabalha com tabela relacionais, onde as colunas são os campos da tabela e as linhas são os registros.

Mas, então como podemos unir o Java, orientado a objetos, com um banco de dados relacional, orientado a tabelas?

JDBC

A forma mais simples de unir um programa Java com um banco de dados é usando o JDBC (Java Database Connectivity).

O JDBC é uma API do java para comunicação com o banco de dados. Essa API é formada pelos pacotes java.sql e javax.sql. Ela permite que você realize queries no banco de dados ao usar o driver JDBC do banco que precisa.

Por exemplo, se você tem um projeto maven, pode usar o driver JDBC do PostgreSQL

<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <version>42.7.13</version>
    <scope>compile</scope>
</dependency>

package com.example;

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

public class Main {
    public static record User(String name, String email) {}

    public static void main(String[] args) {
        // url de conexão
        String url = "jdbc:postgresql://localhost:5432/db4java";
        String username = "dev";
        String password = "dev";

        try (Connection conn = DriverManager.getConnection(url, username, password)) {
            // INSERT
            User user = new User("Fulano", "fulano@mail.com");

            String sql = "INSERT INTO users (name, email) VALUES (?, ?)";

            PreparedStatement statement = conn.prepareStatement(sql);

            statement.setString(1, user.name());
            statement.setString(2, user.email());

            int rowsInserted = statement.executeUpdate();
            if (rowsInserted > 0) {
                System.out.println("Usuário cadastrado com sucesso!");
                conn.commit();
            }

            statement.close();

            // SELECT
            List<User> users = new ArrayList<>();

            sql = "SELECT * FROM users";

            Statement selectStatement = conn.createStatement();
            ResultSet resultSet = selectStatement.executeQuery(sql);
            while (resultSet.next()) {
                String name = resultSet.getString("name");
                String email = resultSet.getString("email");

                users.add(new User(name, email));
            }

            resultSet.close();
            selectStatement.close();

            System.out.println("Lista de usuários cadastrados:");
            users.forEach(System.out::println);
        } catch (SQLException ex) {
            System.out.println("Erro: " + ex.getMessage());
        }
    }
}

Desvantagem do JDBC

Como o JDBC usa o SQL para fazer as consultas no banco de dados, temos que trabalhar com dois paradigmas diferentes, relacional e orientado a objetos.

Isso torna o código mais trabalhoso a longo prazo, apesar de ter padrões de projetos que ajudam a resolver isso como o DAO e Repository.

JPA

Com a dificuldade de gerenciar dois paradigmas no código java, surgiu o JPA (Jakarta Persistence API). O JPA é uma especificação que permite você criar entidades para representar as tabelas do banco de dados. Essas entidades são classes com anotações do JPA para fazer o Mapeamento Objeto-Relacional (ORM).

Algo que deve ter atenção é que o JPA é apenas uma especificação, como uma interface do java. Ou seja, precisamos de uma biblioteca que implemente essa especificação. As mais famosas são o Hibernate e o Spring Data JPA que roda em cima do Hibernate. Mas, há outras implementações do JPA como o EclipseLink, Apache OpenJPA e DataNucleus.

Pacotes javax e jakarta

As classes que lidam com o JPA fazem parte do Java EE e fazem parte do pacote javax.*, mas em código mais moderno você pode se deparar com o pacote jakarta.*.

Depois que o Java foi comprado pela empresa Oracle, parte do código fonte do Java EE foi doado para a Eclipse Foundation, porém o nome Java ainda era legalmente da Oracle. Isso fez a Eclipse Foundation mudar o nome do projeto Java EE para Jakarta EE mudando o pacote javax.* para jakarta.*.

Por isso se você pegar código mais antigos verá importações como import javax.persistence.Entity; e import jakarta.persistence.Entity; em código modernos.

Projeto JPA

Vou usar o Hibernate v7 como biblioteca de ORM em um projeto maven junto do driver JDBC do PostgreSQL e o lombok.

Vamos começar criando a tabela tb_users no banco

CREATE TABLE tb_users(
  id BIGSERIAL PRIMARY KEY,
  name VARCHAR(100) NOT NULL, 
  email VARCHAR(100) NOT NULL UNIQUE,
  created_at TIMESTAMP NOT NULL DEFAULT now(),
  updated_at TIMESTAMP NOT NULL DEFAULT now()
);

Configurando Hibernate

No pom.xml do projeto adicionei as dependencias do hibernate, driver do postgresql e o lombok

<dependencies>
    <dependency>
        <groupId>org.postgresql</groupId>
        <artifactId>postgresql</artifactId>
        <version>42.7.13</version>
        <scope>compile</scope>
    </dependency>

    <dependency>
        <groupId>org.hibernate.orm</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>7.4.7.Final</version>
    </dependency>

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.40</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

As configurações do Hibernate ficam dentro do arquivo src/main/resources/META-INF/persistence.xml. Nesse arquivo será onde fica a url de conexão, usuário e senha do banco e outras configurações.

<persistence xmlns="https://jakarta.ee/xml/ns/persistence"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="https://jakarta.ee/xml/ns/persistence https://jakarta.ee/xml/ns/persistence/persistence_3_1.xsd"
             version="3.1">
    <!-- nome da unidade de persistencia -->
    <persistence-unit name="com.matheusgondra.java4db">
        <!-- As entidades do JPA devem ser listadas usando <class></class> -->
        <class>com.matheusgondra.User</class>

        <properties>
            <!-- URL do banco -->
            <property name="jakarta.persistence.jdbc.url" value="jdbc:postgresql://localhost:5432/db4java" />

            <!-- Credenciais do banco -->
            <property name="jakarta.persistence.jdbc.user" value="dev" />
            <property name="jakarta.persistence.jdbc.password" value="dev" />

            <!-- Ação a ser realizada na geração do schema -->
            <!-- validate verifica se as entidades estão mapeadas corretamente -->
            <property name="jakarta.persistence.schema-generation.database.action" value="validate" />
        </properties>
    </persistence-unit>
</persistence>

Entidade User

Agora vamos criar a entidade User para mapear a tabela tb_users que foi criada no banco de dados. Uma entidade é apenas uma classe java com anotações do JPA. Usarei o lombok para deixar o Código mais enxuto.

A classe de entidade precisa de um construtor vazio (@NoArgsConstructor), um construtor com todos os campos (@AllArgsConstructor), os getters e os setters (@Data).

package com.matheusgondra;

import java.time.LocalDateTime;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private Long id;
    private String name;
    private String email;
    private LocalDateTime createdAt;
    private LocalDateTime updatedAt;
}

Agora para tornar essa classe uma entidade JPA usamos a anotação @jakarta.persistence.Entity.

package com.matheusgondra;

import java.time.LocalDateTime;

import jakarta.persistence.Entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
@Entity
public class User {
    private Long id;
    private String name;
    private String email;
    private LocalDateTime createdAt;
    private LocalDateTime updatedAt;
}

Ao adicionar essa anotação o Hibernate já vê aquela classe como uma entidade JPA. Por padrão a anotação define o nome da entidade como o nome da classe. Isso pode ser alterado na anotação se necessário @Entity(name = "UserEntity"). E o mapeamento fica dessa forma

Podemos ver que temos informações errada, a tabela não é User e sim tb_users. Por padrão o nome da tabela é o mesmo nome da entidade. Quando o nome da tabela é diferente da entidade, usamos a anotação @jakarta.persistence.Table para passar o nome correto.

package com.matheusgondra;

import java.time.LocalDateTime;

import jakarta.persistence.Entity;
import jakarta.persistence.Table;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
@Entity
@Table(name = "tb_users")
public class User {
    private Long id;
    private String name;
    private String email;
    private LocalDateTime createdAt;
    private LocalDateTime updatedAt;
}

A tabela foi corrigida, mas ainda precisamos corrigir os campos da entidade. Os campos VARCHAR são de tamanho 100 e não podem ser nulo. O email deve ser único. Além disso, o campo id é uma chave primária que é auto incrementada. Os campos createdAt e updatedAt tem o nome diferente dos campos no banco que se chamam created_at e updated_at.

Para corrigir essas coisas usamos a anotação @jakarta.persistence.Column. E para o id temos o @jakarta.persistence.Id e o @jakarta.persistence.GeneratedValue para definir a estrategia de geração do id.

package com.matheusgondra;

import java.time.LocalDateTime;

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
@Entity
@Table(name = "tb_users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, length = 100)
    private String name;

    @Column(nullable = false, length = 100, unique = true)
    private String email;

    @Column(name = "created_at", nullable = false, updatable = false)
    private LocalDateTime createdAt;

    @Column(name = "updated_at", nullable = false)
    private LocalDateTime updatedAt;
}

Outra coisa que podemos fazer é adicionar anotações do Hibernate, não do JPA, para gerar o valor do createdAt e do updatedAt.

import org.hibernate.annotations.CreationTimestamp;
import org.hibernate.annotations.UpdateTimestamp;

@CreationTimestamp
@Column(name = "created_at", nullable = false, updatable = false)
private LocalDateTime createdAt;

@UpdateTimestamp
@Column(name = "updated_at", nullable = false)
private LocalDateTime updatedAt;

Estado da Entidade JPA

Algo que você deve saber é o ciclo de vida de uma entidade. Uma entidade JPA possui 4 estados:

Transient
Managed
Detached
Removed

Estado Transient

Nesse estado a entidade ainda não está sendo gerenciada pelo contexto de persintência (EntityManager). A entidade entra nesse estado quando você cria um novo objeto com new

public static void main(String[] args) {
    // Entidade no estado Transient
    User user = new User();
}

Nesse estado as modificações no objeto não são refletidas no banco de dados.

Estado Managed

Nesse estado a entidade já está associada a um contexto de persistência (EntityManager) ativo. Alterações nos campos do objetos são sincronizadas com a tabela no banco de dados.

Um objeto java entra nesse estado ao chamar o método persist(), find(), merge() da classe EntityManager.

public static void main(String[] args) {
    // Entidade no estado Transient
    User user = new User();

   entityManager.persist(user);

   // Entidade no estado Managed agora
}

Estado Detached

Nesse estado a entidade a entidade reflete um registro no banco de dados, mas o contexto de persistência (EntityManager) não está mais gerenciando a entidade.

Por exemplo, se criarmos uma nova instância da entidade (estado Transient) e criarmos um registro no banco com o método persist() (estado Managed) e fechar o contexto de persistência com o método close() a entidade irá passar para o estado Detached. É uma entidade válida que reflete um registro no banco, mas está fora do contexto de persistência e precisaria voltar para o estado Managed para refletir as mudanças no banco.

public static void main(String[] args) {
   // Entidade no estado Transient
   User user = new User();

   entityManager.persist(user);

   // Entidade no estado Managed agora

   entityManager.close(); // fim do contexto

   // Entidade no estado Detached agora
}

Estado Removed

Nesse estado a entidade é marcado pelo contexto de persistência (EntityManager) para ser deletada do banco de dados. Uma entidade entra nesse estado ao chamar o método remove() do EntityManager

public static void main(String[] args) {
   // Entidade no estado Transient
   User user = new User();

   entityManager.persist(user);

   // Entidade no estado Managed agora

   entityManager.remove(user);

   // Entidade no estado Removed agora
}

Contexto de Persistência

Todas as queries no banco de dados são feitas dentro de um contexto de persistência usando a classe jakarta.persistence.EntityManager.

Para criar o EntityManager usamos o padrão de fabrica usando a interface jakarta.persistence.EntityManagerFactory, a classe jakarta.persistence.Persistence e passando o nome da unidade persistência definido no persistence.xml

// o nome da <persistence-unit /> no persistence.xml deve ser passado para o createEntityManagerFactory
EntityManagerFactory factory = Persistence.createEntityManagerFactory("com.matheusgondra.java4db");
EntityManager entityManager = factory.createEntityManager();

CRUD

Com o contexto criado podemos fazer queries no banco de dados. Vou mostrar como é possível fazer as operações de CRUD.

Adicionei a anotação @lombok.Builder na nossa entidade User para facilitar a instanciação dos objetos.

Create

A primeira operação é o CREATE. Para criar um novo registro no banco de dados, o EntityManager possui o método persist() que recebe uma entidade JPA.

Ao chamar o método irá ser feito uma query INSERT no banco com os valores da entidade que mapeamos.

static void create(EntityManagerFactory factory) {
    EntityManager entityManager = factory.createEntityManager();

    EntityTransaction transaction = entityManager.getTransaction();
    try {
        transaction.begin();

        // Estado da entidade: Transient
        User user = User.builder()
                .name("Fulano")
                .email("fulano@email.com")
                .build();

        System.out.println("Entidade em Trasient: " + user);

        // Persiste no banco
        entityManager.persist(user);

        // Estado da entidaed: Managed
        System.out.println("Entidade em Managed: " + user);

        transaction.commit();
    } catch (Exception e) {
        if (transaction.isActive()) {
            transaction.rollback();
        }

        throw e;
    } finally {
        // fechando o contexto de persistência
        entityManager.close();
    }
}

Entidade em Trasient: User(id=null, name=Fulano, email=fulano@email.com, createdAt=null, updatedAt=null)
Entidade em Managed: User(id=1, name=Fulano, email=fulano@email.com, createdAt=2026-09-19T13:59:23.564330, updatedAt=2026-09-19T13:59:23.564399)

Read

A próxima operação é o READ. Para isso, o EntityManager possui o método find().

static void find(EntityManagerFactory factory) {
    try (EntityManager entityManager = factory.createEntityManager()) {
        User user = entityManager.find(User.class, 1L);
        if (user == null) {
            throw new RuntimeException("Entidade não encontrada");
        }

        System.out.println("Entidade Managed: " + user);
    } catch (Exception e) {
        throw e;
    }
}

Entidade Managed: User(id=1, name=Fulano, email=fulano@email.com, createdAt=2026-09-19T23:15:18.470144, updatedAt=2026-09-19T23:15:18.470205)

Para um findAll não temos um método pronto no Hibernate. Mas, podemos usar o método createQuery para criar um query que busca todos os registros usando JPQL (Java Persistence Query Language) que é bem parecido com o SQL.

No SQL as consultas são feitas baseada nas tabelas, no JPQL as consultas são feitas baseadas nas entidade JPA.

Adicionei outros registros para retornar mais de um registro.

static void findAll(EntityManagerFactory factory) {
    try (EntityManager entityManager = factory.createEntityManager()) {
        List<User> users = entityManager.createQuery("SELECT u FROM User u", User.class).getResultList();

        users.forEach(System.out::println);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

User(id=1, name=Fulano, email=fulano@email.com, createdAt=2026-09-19T14:15:58.822469, updatedAt=2026-09-19T14:15:58.822552)
User(id=2, name=ciclano, email=ciclano@email.com, createdAt=2026-09-19T22:22:39.055243, updatedAt=2026-09-19T22:22:39.055243)
User(id=3, name=beltrano, email=beltrano@email.com, createdAt=2026-09-19T22:22:39.055243, updatedAt=2026-09-19T22:22:39.055243)

Update

A operação de UPDATE iremos buscar uma entidade com o método find() para termos uma entidade no estado Managed. Com isso, iremos atualizar os atributos da entidade e ao fazer o commit da transação, ou usando o método merge, o Hibernate irá atualizar o registro no banco.

static void update(EntityManagerFactory factory) {
    EntityManager entityManager = factory.createEntityManager();

    EntityTransaction transaction = entityManager.getTransaction();
    try {
        transaction.begin();

        User user = entityManager.find(User.class, 1L);
        if (user == null) {
            throw new RuntimeException("User not found");
        }

        System.out.println("User antes: " + user);

        user.setName("Fulano Atualizado");

        System.out.println("User depois: " + user);

        // No commit a query UPDATE é rodada no banco
        transaction.commit();
    } catch (Exception e) {
        if (transaction.isActive()) {
            transaction.rollback();
        }

        throw new RuntimeException(e);
    } finally {
        entityManager.close();
    }
}

User antes: User(id=1, name=Fulano, email=fulano@email.com, createdAt=2026-09-19T14:15:58.822469, updatedAt=2026-09-19T14:15:58.822552)
User depois: User(id=1, name=Fulano Atualizado, email=fulano@email.com, createdAt=2026-09-19T14:15:58.822469, updatedAt=2026-09-19T14:15:58.822552)

DELETE

A operação de DELETE é parecido com o UPDATE, iremos buscar uma entidade com o método find() para termos uma entidade no estado Managed. Com isso, iremos chamar o método remove() com a entidade e ao fazer o commit da transação o Hibernate irá atualizar o registro no banco.

static void delete(EntityManagerFactory factory) {
    EntityManager entityManager = factory.createEntityManager();

    EntityTransaction transaction = entityManager.getTransaction();

    try {
        transaction.begin();

        User user = entityManager.find(User.class, 1L);
        if (user == null) {
            throw new RuntimeException("User not found");
        }

        entityManager.remove(user);

        //No commit a query DELETE é rodada no banco
        transaction.commit();
    } catch (Exception e) {
        if (transaction.isActive()) {
            transaction.rollback();
        }

        throw new RuntimeException(e);
    } finally {
        entityManager.close();
    }
}

Closures Javascript

Matheus de Gondra — Wed, 15 Jul 2026 18:16:58 +0000

Escopo

O javascript trabalha com escopo. Vamos pegar o código abaixo:

// Escopo do arquivo
const name = "Fulano";
const age = 25;

const foo = () => {
    // Escopo da função

    const contador = 10;

    console.log(`Olá ${name}, você tem ${age} anos.`);
}

foo();

Esse código possui 3 escopos ou contextos: escopo global, escopo de arquivo (módulo) e o escopo da função foo.

Se colocarmos um breakpoint na execução da função foo podemos rodar o código em modo de debug e usar o painel de debug do vscode para ver isso.

Na esquerda, no painel VARIABLES, podemos observar 2 escopos definidos: Module que é o escopo do arquivo, e Global que é o escopo global onde ficam variáveis e funções globais do javascript.

Agora vamos colocar um breakpoint no console.log dentro da função foo. Vamos ver que um novo escopo será criado quando o código chegar dentro da função.

Esse Local: foo é o escopo da função foo e dentro dele existe a variável contador.

No javascript o escopo interno tem acesso ao escopo externo, mas o contrario não.

O que são Closures?

Uma closure é a combinação de uma função com as referências ao estado que a circunda (o ambiente léxico).

Essa é a definição de closure no site do MDN. Explicando melhor o que seria isso, é uma função que consegue guardar o estado do escopo onde ela foi definida.

const externa = () => {
    let contador = 0;

    // interna é uma closure, pois ela consegue salvar o escopo de externa mesmo ao fim dela
    const interna = () => {
        contador++;
        console.log(contador);
    }

    return interna;
}

const funcaoInterna = externa(); // retorna a função interna, que é uma closure

funcaoInterna(); // 1
funcaoInterna(); // 2
funcaoInterna(); // 3

Se eu colocar um breakpoint no contador++, no painel de debug terá o escopo Local: interna que é o escopo da função interna e Closure (externa) que é o escopo que a função interna manteve salvo.

Na segunda execução o contador estará com o valor 1, pois foi atualizado na primeira execução de funcaoInterna()

O código vai funcionar assim

// [Sem Closure]

// cria o escopo na memória
const foo = () => {
    let contador = 0;

    contador++;
}
// acabou o escopo
// O coletor de lixo vai limpar tudo que estava no escopo da memória


// [Com Closure]

// cria o escopo na memória
const foo = () => {
    let contador = 0;

    // cria o escopo na memória
    const bar = () => {
        contador++;
        console.log(contador);
    }

    return bar;
}
// acabou o escopo
// Como a função bar é retornada
// ela continua existindo na memória, mesmo que a função foo tenha acabado
// isso mantem o escopo da função foo na memória, mesmo que a função foo tenha acabado

Exemplos

Irei listar alguns exemplo de uso de closures no javascript.

Debounce

Um dos usos de closures é para criar um debounce. O Debounce atrasa a execução de uma função para que caso a função seja chamada novamente dentro desse intervalo, ela reinicia esse atraso para garantir que não execute a função novamente.

Isso é útil para caso um usuário clique várias vezes em um botão que faz uma chama a uma API. Garantindo que a chamada só ocorra quando o usuário para de clicar várias vezes.

const debounce = (func, wait = 100) => {
    let timeout;

    // closure recebe todos os argumentos
    return (...args) => {
        clearTimeout(timeout);

        timeout = setTimeout(() => {
            // passa todos os argumentos para a função
            func(...args);
        }, wait)
    }
}

const chamaAPI = async () => {
    const response = await fetch('https://jsonplaceholder.typicode.com/todos/1');
    const data = await response.json();
    console.log(data);
}

// espera 2 segundos para chamar a API.
const debouncedChamaAPI = debounce(chamaAPI, 2000);

// Simulando o clicks rápidos do usuário
debouncedChamaAPI();
debouncedChamaAPI();
debouncedChamaAPI();

Cache

Outro uso de closure é para criar uma função com um cache para casos onde o processamento dos resultados é muito custoso ou lento.

const calcWithCache = () => {
    const cache = {}; // cria um cache para armazenar os resultados

    // closure que faz o cálculo e armazena no cache
    return (num) => {
        if (cache[num]) {
            console.log("Retornando do cache");
            return cache[num];
        }

        console.log("Calculando... Processamento pesado");
        const resultado = num * 999999; // Simulando um cálculo pesado

        cache[num] = resultado;
        return resultado;
    };
}

const calc = calcWithCache();

console.log(calc(5));
console.log(calc(10));
console.log(calc(5)); // Deve retornar do cache

Mais Streams

Matheus de Gondra — Wed, 15 Jul 2026 12:12:05 +0000

No post anterior falei sobre os 3 tipos de streams do NodeJS: Readable, Writable e Duplex. Neste post, vamos mergulhar um pouco mais fundo nessa API para você entender como ela funciona na prática e em situações do dia a dia.

PassThrough

O PassThrough é uma implementação bem simples de uma stream Transform que apenas repassa os dados de entrada diretamente para a saída, sem alterá-los. Um caso de uso muito comum para ele é a injeção de logs no meio de um pipeline de dados.

import { stdout } from "node:process";
import { PassThrough, Readable } from "node:stream";
import { styleText } from "node:util";

const data = ["10\n", "22\n", "31\n", "14\n", "523\n"];
const readable = Readable.from(data);

const loggerStream = new PassThrough();
const consoleStream = new PassThrough();
const otherStream = new PassThrough();

loggerStream.on("data", (chunk) => {
    console.log(styleText(["cyan"], `Logger: ${chunk.toString()}`));
});

consoleStream.on("data", (chunk) => {
    console.log(styleText(["green"], `Console: ${chunk.toString()}`));
});

otherStream.on("data", (chunk) => {
    console.log(styleText(["yellow"], `Other: ${chunk.toString()}`));
});

readable.pipe(loggerStream).pipe(consoleStream).pipe(otherStream).pipe(stdout);

Na teoria o PassThrough não deve alterar os dados, apesar de ser possível, já que é uma stream Transform.

Async Iterators e Async Generators

A API de streams do node é compatível com async iterators e async generators. O que pode tornar o código mais fácil de ler ou ser escrito em alguns caso.

Para isso usamos a função pipeline que cria um fluxo de streams, async iterators ou async generators.

import { stdout } from "node:process";
import { PassThrough, Readable } from "node:stream";
import { pipeline } from "node:stream/promises";

// Função geradora assíncrona
async function* sumGenerator(stream) {
  // o for await...of é usado para iterar sobre os chunks de dados do stream
  for await (const chunk of stream) {
    const data = Number(chunk.toString().trim());

    const sumData = data + 100;

    // O yield é usado para enviar o resultado para o próximo estágio do pipeline
    // O valor deve ser uma string ou Buffer
    yield sumData.toString() + "\n";
  }
}

const data = [" 10 ", " 20 ", " 30 ", " 40 ", " 50 "];
const readable = Readable.from(data);

try {
    await pipeline(
      readable,
      sumGenerator,
      stdout
    );
} catch (error) {
    console.error("Pipeline failed.", error);
}

Requisições HTTP

Você pode pensar que as streams são algo que você não usaria no dia a dia. Mas, na realidade algumas APIs usam streams e você acaba não percebendo.

O módulo HTTP do NodeJS é um exemplo disso. Podemos criar um servidor http usando o node:http e o objeto request, que representa a requisição do usuário, será um stream Readable e o objeto response, que representa a resposta do servidor, será uma stream Writable.

Isso acontece porque a requisição viaja pela rede e chega ao nosso servidor como um fluxo contínuo de dados (uma stream). Graças a isso, o servidor não precisa esperar o carregamento de 100% do body da requisição para começar a processá-la. O mesmo princípio de performance se aplica na hora de devolver a resposta ao cliente.

import { createServer } from "node:http";
import { PassThrough } from "node:stream";
import { styleText } from "node:util";

const logger = new PassThrough();

logger.on("data", (chunk) => {
    const prefix = styleText(["cyan"], "Logger: \n");
    const message = styleText(["yellow", "bold"], chunk.toString());
    console.log(prefix + message);
});

// request é um Readable
// response é um Writable
const server = createServer((request, response) => {
  // redirecionando o que chega no request body para o response
  request.pipe(logger).pipe(response);
});

server.listen(3000, () => {
  console.log("Server is listening on port 3000");
});

No express podemos adicionar um middleware para lidar com requisições json usando app.use(express.json()) e podemos devolver uma resposta em json usando response.json().

import express from "express";

const app = express();

app.use(express.json());

app.post("/", async (request, response) => {
    const body = request.body;
    response.json({ message: "Dados recebidos com sucesso", data: body });
});

O módulo node:http não tem essa abstração, mas podemos construir essa abstração agora que entendemos melhor as streams do node:http

import { createServer } from "node:http";

// Middleware para extrair o corpo da requisição como JSON
async function json(request, response) {
  let body = "";

  // como o request é uma stream, consumimos ela com o for await of
  for await (const chunk of request) {
    // acumulamos os pedaços do corpo da requisição
    body += chunk;
  }

  try {
    // transformamos o corpo da requisição em JSON e adicionamos ao objeto request
    body = JSON.parse(body);
  } catch {
    // Se não for um json válido, definimos o corpo como um objeto vazio
    body = {};
  }

  // adicionamos o corpo da requisição ao objeto request
  request.body = body;
}

// Middleware para adicionar o método status ao objeto response
async function statusResponse(request, response) {
  response.status = (statusCode) => {
    response.statusCode = statusCode;
    return response;
  }
}

// Middleware para enviar respostas JSON
async function jsonResponse(request, response) {
  response.json = async (data) => {
    const status = response.statusCode || 200;

    response.writeHead(status, { "Content-Type": "application/json" });
    response.end(JSON.stringify(data));
  }
}

const middlewares = [json, statusResponse, jsonResponse];

// Mudamos para uma função assíncrona para lidar com os middlewares
const server = createServer(async (request, response) => {
  const { method, url } = request;

  // Chamamos cada middleware em sequência, passando o request e response
  for (const middleware of middlewares) {
    await middleware(request, response);
  }

  if (method === "POST" && url === "/") {
    const body = request.body || {};

    response.status(201).json({ message: "Dados recebidos com sucesso", data: body });
  }
});

server.listen(3000, () => {
  console.log("Server is listening on port 3000");
});

Conexão Serial

Outra biblioteca que usa streams por baixo dos panos é a serialport, uma biblioteca para fazer a conexão com dispositivos através da porta serial.

Você pode se conectar a um Arduino ou ESP32, por exemplo, para coletar os dados que eles enviam e salvar em um arquivo de log. A conexão que a serialport faz é usando uma stream Duplex.

import { ReadlineParser } from "@serialport/parser-readline";
import { SerialPort } from "serialport";
import { createWriteStream } from "node:fs";
import { pipeline } from "node:stream/promises";
import { Transform } from "node:stream";

const baudRate = 38400; // taxa de transmissão em bits por segundo do dispositivo serial
const path = "COM10"; // porta serial do dispositivo (ex: COM1, /dev/ttyUSB0, etc.)

// uma stream Duplex para ler e escrever dados na porta serial
const port = new SerialPort({ path, baudRate });

// um parser para ler os dados da porta serial linha por linha
const parser = new ReadlineParser({ delimiter: "\n" });

// uma stream para colocar os dados linha a linha
const lineStream = new Transform({
    transform(chunk, encoding, callback) {
        const line = chunk.toString().trim();
        if (line) {
            this.push(line + "\n");
        }
        callback();
    }
})

// uma stream para escrever os dados recebidos da porta serial em um arquivo de log
const logFileStream = createWriteStream("serial_log.txt");


try {
    await pipeline(port, parser, lineStream, logFileStream);
} catch (error) {
    console.error("Erro ao processar os dados da porta serial:", error);
}

Conclusão

Muitas vezes, quando estudamos os conceitos de Streams no Node.js, tudo parece muito teórico ou voltado apenas para a leitura de arquivos gigantescos em disco. Mas, como vimos, as streams estão por trás de muitas ferramentas que usamos diariamente.

Elas estão presentes quando levantamos um servidor HTTP, quando o Express faz o parse de um JSON no body da requisição e até quando nos comunicamos com hardwares externos usando portas seriais.

Entender como as streams funcionam por debaixo dos panos te dá uma vantagem imensa: você passa a escrever códigos mais performáticos, que consomem muito menos memória e conseguem processar informações sob demanda.

Coleções Java

Matheus de Gondra — Sat, 09 May 2026 03:02:36 +0000

O Java possui APIs úteis para o desenvolvimento e uma delas é a API Collections. A API de coleções do java é algo que você usará todo o dia, mesmo que não perceba.

Agrupar valores relacionados é algo comum no desenvolvimento, como notas de alunos, eventos que ocorreram em um certo dia ou uma lista de tarefas para serem feitas.

Esse agrupamento pode ser feitos de várias formas e o java collections fornece a API necessária para isso no java.

Array

A forma mais simples de agrupar valores é usando um Array. O array é uma estrutura de dados homogenia, ou seja, todos os valores possuem o mesmo tipo.

O Array deve ter tamanho fixo que pode ser declarado definindo os valores na inicialização ou definindo um tamanho usando new.

public class Main {
    public static void main(String[] args) {
        int[] notas = { 10, 8, 9, 7 };

        String[] tarefas = {
                "Dar like no post",
                "Comentar algo",
                "Compartilhar o post"
        };

        String[] diasDaSemana = new String[7];
        diasDaSemana[0] = "Domingo";
        diasDaSemana[1] = "Segunda-feira";
        diasDaSemana[2] = "Terça-feira";
        diasDaSemana[3] = "Quarta-feira";
        diasDaSemana[4] = "Quinta-feira";
        diasDaSemana[5] = "Sexta-feira";
        diasDaSemana[6] = "Sábado";
    }
}

O array é alocado de forma contígua na memória. Isso significa que os espaços para cada dado no array é seguido um após o outro. O array notas estaria mais ou menos assim na memória.

A desvantagem é que caso não houver um o espaço contíguo na memória o array não conseguiria ser criado.

A vantagem disso é permitir um acesso instantâneo O(1) a qualquer valor do array. O programa faz uma conta simples para o acesso aos valores:

endereço = endereço_da_variavel_array + tamanho_do_tipo_de_dado * indice_do_array

Por exemplo, vamos pegar o array notas, o tamanho de um int no java é 4 bytes, o índice de um array inicia em 0 e vamos imaginar que notas está no endereço 0x100 (256 em hexadecimal). Então a conta para acessar seria:

// acessando o índice 0 (primeiro índice)
x = 0x100 + 0x4 * 0x0
x = 0x100 + 0x0
x = 0x100 // 200 em hexadecimal que é o endereço onde está o primeiro valor

E se quisermos o último valor? O último índice é 3 já que os índices vão de 0 até o tamanho do array - 1.

// acessando o índice 3 (último índice)
x = 0x100 + 0x4 * 0x3
x = 0x100 + 0xC
x = 0x10C // 268 em hexadecimal que é o endereço onde está o último valor

Por isso o array é uma ótima estrutura para acessar valores.

Coleções

O array é a forma mais simples de agrupar valores. O java possui uma API completa para isso chamada Java Collections.

Essa API possui várias classes e interfaces para diferentes tipos de agrupamentos de valores e métodos para manipulação desses agrupamentos.

Abaixo temos a hierarquia das interfaces dessa API.

List

List é uma interface que defini operações para uma coleção de lista de valores, com ordem e índices. Temos duas principais implementações dessa interface, ArrayList e LinkedList.

ArrayList

O ArrayList uma implementação da interface List. Essa classe armazena os dados em um formato de array. O ArrayList pode aumentar ou diminuir o seu tamanho, diferente do array convencional que tem tamanho fixo.

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

public class Main {
    public static void main(String[] args) {
        List<String> linguagens = new ArrayList<>();

        linguagens.add("Java");
        linguagens.add("Python");
        linguagens.add("C++");

        linguagens.remove(1); // Remove "Python"

        linguagens.forEach(System.out::println); // imprimi os elementos
    }
}

O ArrayList resolve o problema de tamanho fixo de um array. Internamente ele cria um array com um tamanho inicial de 10 por padrão.

A medida que você adiciona elementos com o método add() o ArrayList cria um novo array internamente e copia os dados para esse novo array.

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

public class Main {
    public static void main(String[] args) {
        // internamente é um array de tamanho 10: Integer[] notas = new Integer[10];
        List<Integer> notas = new ArrayList<>();

        notas.add(10);
        notas.add(8);
        notas.add(9);
        notas.add(7);

        Integer nota = 6;
        notas.add(nota);

        // remoção por referência ao objeto
        notas.remove(nota); // Remove o objeto nota da lista
        System.out.println(notas); // [10, 8, 9, 7]

        // adiciona mais elementos no ArrayList
        // Internamente o ArrayList cria um novo array com mais capacidade e copia os elementos para ele
        for (int i = 0; i < 10; i++) {
            notas.add(i);
        }

        System.out.println(notas); 
        // [10, 8, 9, 7, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    }
}

LinkedList

O ArrayList resolve o problema de ter um array de tamanho fixo, mas ainda temos o problema de precisar ter espaço contíguo na memória para array, mesmo usando um ArrayList.

Para esse tipo de problema temos uma outra implementação da interface List chamada LinkedList. Essa classe é uma lista encadeada, onde cada valor é um nó da lista que aponta para o nó anterior e posterior. Se usarmos um LinkedList para armazenar aquele array de notas ficaria algo parecido com isso:

A desvantagem desse tipo de implementação é que o acesso a um valor é linear O(n). Ou seja, se eu quiser o terceiro valor na lista, eu preciso acessar o primeiro e o segundo elemento até chegar no terceiro.

A vantagem desse tipo de implementação é que adicionar e remove valores é menos custoso já que é apenas necessário mudar o valor dos campos próximo e anterior dos nós o que é uma complexidade linear O(1).

Como LinkedList implementa a interface List podemos continuar com o código anterior e mudar apenas a classe ArrayList para LinkedList.

import java.util.LinkedList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> notas = new LinkedList<>(); // Alterando a implementação para LinkedList

        notas.add(10);
        notas.add(8);
        notas.add(9);
        notas.add(7);

        Integer nota = 6;
        notas.add(nota);

        // remoção por referência ao objeto
        notas.remove(nota); // Remove o objeto nota da lista
        System.out.println(notas); // [10, 8, 9, 7]

        for (int i = 0; i < 10; i++) {
            notas.add(i);
        }

        System.out.println(notas);
        // [10, 8, 9, 7, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    }
}

Set

O Set é outra interface que pertence ao java collections e representa uma estrutura de conjunto. Os conjuntos guardam elementos sem um índice ou ordem, como fazia com List, e não permite elementos duplicados.

Algumas implementações da interface Set são HashSet, TreeSet e LinkedHashSet.

HashSet

O HashSet implementa a interface Set usando um tabela hash através da classe HashMap. Assim, quando você adiciona um valor ao HashSet ele cria um registro no HashMap interno com a chave sendo o valor que você adicionou e um Object para preencher o valor do HashMap

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

public class Main {
    public static void main(String[] args) {
        Set<String> linguagens = new HashSet<>();

        String java = "Java";
        String javascript = "JavaScript";

        // internamente: HashMap: { "Java": Object }
        linguagens.add(java);

        // adicionar o mesmo valor faz apenas recriar a chave no HashMap
        linguagens.add(java);

        // internamente: HashMap: { "Java": Object, "JavaScript": Object }
        linguagens.add(javascript);

        /*
         * internamente:
         * HashMap: {
         * "Java": Object,
         * "C": Object,
         * "Typescript": Object,
         * "JavaScript": Object
         * }
         */
        linguagens.add("Typescript");
        linguagens.add("C");

        System.out.println(linguagens); // [Java, C, Typescript, JavaScript]

        linguagens.remove(javascript); // Remove "JavaScript" do conjunto

        System.out.println(linguagens); // [Java, C, Typescript]
    }
}

Esse tipo de implementação permite um acesso constante O(1) já que acessar um valor na tabela hash é acesso constante.

Note que mesmo adicionando a string "C" por último, ela foi impressa como sendo a segunda. Isso, porque o Set não garante uma ordem dos elementos.

LinkedSet

Essa implementação do Set utiliza uma lista duplamente encadeada para manter a ordem dos elementos e um HashMap para implementar os métodos da interface Set.

import java.util.LinkedHashSet;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Set<String> linguagens = new LinkedHashSet<>(); // Trocando para LinkedHashSet

        String java = "Java";
        String javascript = "JavaScript";

        /*
         * internamente:
         * HashMap: { "Java": Object }
         * LinkedList: head <-> "Java" <-> tail
         */
        linguagens.add(java);

        // adicionar o mesmo valor faz apenas recriar a chave no HashMap
        linguagens.add(java);

        /*
         * internamente:
         * HashMap: { "Java": Object, "JavaScript": Object }
         * LinkedList: head <-> "Java" <-> "JavaScript" <-> tail
         */
        linguagens.add(javascript);

        /*
         * internamente:
         * HashMap: {
         * "Java": Object,
         * "JavaScript": Object,
         * "Typescript": Object,
         * "C": Object
         * }
         * LinkedList: head <-> "Java" <-> "JavaScript" <-> "Typescript" <-> "C" <-> tail
         */
        linguagens.add("Typescript");
        linguagens.add("C");

        System.out.println(linguagens); // [Java, JavaScript, Typescript, C]

        linguagens.remove(javascript); // Remove "JavaScript" do conjunto

        System.out.println(linguagens); // [Java, Typescript, C]
    }
}

TreeSet

O TreeSet é um implementação da interface NavigableSet que extende o SortedSet que é um interface que extende o Set. O SortedSet são conjuntos ordenados. Internamente o TreeSet usa uma Árvore Rubro-Negra que é uma árvore binária de busca auto balanceada, um tipo de estrutura de dados, para guarda os valores ordenados.

O TreeSet ordena os valores que podem ser comparados, ou seja, que implementam a interface Comparable. Caso o valor não implemente a interface Comparable, pode ser passado um Comparator no construtor do TreeSet para que a classe saiba como ordenar os valores.

A impressão dos valores utiliza o algoritmo de percurso "em ordem" das árvores binárias.

import java.util.Set;
import java.util.TreeSet;

public class Main {
    static record Product(String name, double price) {
    }

    static class ProductCompable implements Comparable<ProductCompable> {
        String name;
        double price;

        public ProductCompable(String name, double price) {
            this.name = name;
            this.price = price;
        }

        @Override
        public int compareTo(ProductCompable other) {
            return Double.compare(this.price, other.price);
        }
    }

    public static void main(String[] args) {
        // Passando um Comparable
        Set<ProductCompable> productSetComparable = new TreeSet<>();

        // Passando um Comparator através de uma expressão lambda para ordenar
        Set<Product> productSet = new TreeSet<>((p1, p2) -> Double.compare(p1.price, p2.price));

        productSet.add(new Product("Laptop", 999.99));
        productSet.add(new Product("Smartphone", 499.99));
        productSet.add(new Product("Tablet", 299.99));
        productSet.add(new Product("Headphones", 199.99));
        productSet.add(new Product("Smartwatch", 199.50));
        productSet.add(new Product("Camera", 599.99));

        // Imprime os produtos usando o percurso "em ordem" de árvores binárias de busca
        productSet.forEach(System.out::println);
        /* 
         Product[name=Smartwatch, price=199.5]
         Product[name=Headphones, price=199.99]
         Product[name=Tablet, price=299.99]
         Product[name=Smartphone, price=499.99]
         Product[name=Camera, price=599.99]
         Product[name=Laptop, price=999.99]
        */
    }
}

A árvore gerada pelo código acima seria algo assim:

Queue e Deque

Outra interface que pertence ao Java Collection é a Queue. Essa interface representa uma estrutura de fila.

Filas tem a propriedade de FIFO (Fisrt In Last Out), o primeiro elemento a entrar na fila será sempre o primeiro a sair dela.

A Deque é um tipo especialmente de fila, uma "fila de duas pontas". Ela permite inserir e excluir da fila pelo inicio (head) ou final (tail).

Deque adiciona métodos com sufixo First e Last para manipular a fila como addFirst() e addLast.

Algumas classes que implementam a interface Queue e Deque são LinkedList, PriorityQueue e ArrayDeque.

PriorityQueue

A PriorityQueue é uma fila de prioridade. Ela usa um array para armazenar os valores, mas ela também usa a interface Comparable para definir a prioridade dos elementos adicionados.

Caso a classe que a PriorityQueue guarda não implemente Comparable, pode ser passado um Comparator no construtor para definir o critério de prioridade que será usado.

import java.util.PriorityQueue;
import java.util.Queue;

public class Main {
    record Person(String name, int age) {
    }

    public static void main(String[] args) {
        Person jose = new Person("José", 30);
        Person zezinho = new Person("Zezinho", 25);
        Person seuZe = new Person("Seu Zé", 65);
        Person maria = new Person("Maria", 70);

        // Prioridade de atendimento: pessoas mais velhas têm prioridade
        Queue<Person> atendimento = new PriorityQueue<>((p1, p2) -> Integer.compare(p2.age(), p1.age()));


        atendimento.add(jose);
        atendimento.add(maria);
        atendimento.add(zezinho);
        atendimento.add(seuZe);

        // Imprimindo a fila de atendimento na ordem de prioridade
        Queue<Person> copia = new PriorityQueue<>(atendimento);
        System.out.print("Fila de atendimento: [");
        do {
            Person p = copia.poll();
            System.out.print(p.name() + (copia.isEmpty() ? "" : ", "));
        } while (!copia.isEmpty());
        System.out.println("]");
        // Fila de atendimento: [Maria, Seu Zé, José, Zezinho]

        // Removendo o primeiro da fila. Sempre o primeiro da fila
        Person atendido = atendimento.poll();
        System.out.println("Atendido: " + atendido.name()); // Atendido: Maria

        System.out.println("Fila após o atendimento: " + atendimento.stream().map(Person::name).toList());
        // Fila após o atendimento: [Seu Zé, Zezinho, José]

        // Verificando o primeiro da fila sem removê-lo
        System.out.println("Primeiro da fila: " + atendimento.peek().name()); // Primeiro da fila: Seu Zé
    }
}

LinkedList

Além de implementar a interface List, o LinkedList implementa a interface Deque. Como uma lista encadeada tem um referência para o inicio (head) e para o final (tail) da lista, para funcionar como uma fila dupla é só usar essas referências para inserir e remover no final e remover no inicio da lista encadeada.

import java.util.Deque;
import java.util.LinkedList;

public class Main {
    record Person(String name, int age) {
    }

    public static void main(String[] args) {
        Person jose = new Person("José", 30);
        Person zezinho = new Person("Zezinho", 25);
        Person seuZe = new Person("Seu Zé", 65);
        Person maria = new Person("Maria", 70);

        Deque<Person> atendimento = new LinkedList<>();

        // Adicionando no final da fila
        atendimento.add(jose);
        atendimento.add(zezinho);

        // Adicionando no início da fila
        atendimento.addFirst(seuZe);
        atendimento.addFirst(maria);

        System.out.println("Fila de atendimento: " + atendimento.stream().map(Person::name).toList());
        // Fila de atendimento: [Maria, Seu Zé, José, Zezinho]

        // Removendo o primeiro da fila
        Person atendido = atendimento.poll();
        System.out.println("Atendido: " + atendido.name());
        // Atendido: Maria

        // Removendo o último da fila
        Person person = atendimento.pollLast();
        System.out.println("Desistiu da fila: " + person.name());
        // Desistiu da fila: Zezinho

        System.out.println("Fila de atendimento: " + atendimento.stream().map(Person::name).toList());
        // Fila de atendimento: [Seu Zé, José]

        // Verificando o primeiro da fila sem removê-lo
        System.out.println("Primeiro da fila: " + atendimento.peek().name());
        // Primeiro da fila: Seu Zé
    }
}

ArrayDeque

O ArrayDeque é uma classe que implementa o Deque. Usa internamente um array circular de tamanho 16 para armazenar os valores.

Internamente, o ArrayDeque guarda o índice do inicio (head) e do fim (tail) do array circular. A medida que adicionar valores no fim com o método add(), por exemplo, a classe altera o valor do tail. E quando adicionar no inicio com o método addFist(), por exemplo, a classe altera o head.

Quando não há mais espaço no array, um novo array com mais capacidade é criado e os dados são copiados para esse novo array

import java.util.ArrayDeque;
import java.util.Deque;

public class Main {
    public static void main(String[] args) {
        Deque<Integer> deque = new ArrayDeque<>();

        // adiciona no fim e altera o valor de tail
        deque.add(3);
        deque.add(22);
        deque.addLast(10);

        // adiciona no início e altera o valor de head
        deque.addFirst(15);

        System.out.println(deque);
        // [15, 3, 22, 10]

        // Cria um novo array com mais capacidade e copia os elementos do array antigo
        // para o novo array
        for (int i = 0; i < 100; i++) {
            deque.add(i);
        }

    }
}

Iterable e Collection

Subindo ao nível mais genérico, temos as interfaces Collection e Iterable.

O Collection é uma coleção genérica. Todas as classes do Java Collection implementam essa interface. Se, por exemplo, você precisa modificar qualquer tipo de coleção do Java Collection através de um método, você pode usar um Collection como argumento.

O Iterable é um coleção objetos que pode ser lida e percorrida um objeto por vez. Se, por exemplo, você precisar acessar cada valor de uma coleção de objetos, você pode receber como argumento um Iterable. Cada classe tem uma forma de guardar os valores e por isso cada uma tem sua implementação de Iterable para pode ser navegável de acordo com sua implementação usando um Iterator, um objeto que sabe navegar por um Iterable.

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Deque;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        Queue<Integer> queue = new ArrayDeque<>();
        Deque<Integer> deque = new LinkedList<>();
        Set<Integer> set = new HashSet<>();

        modifyCollection(list);
        modifyCollection(queue);
        modifyCollection(deque);
        modifyCollection(set);

        System.out.print("List:");
        printCollection(list); // List: 42

        System.out.print("Queue:");
        printCollection(queue); // Queue: 42

        System.out.print("Deque:");
        printCollection(deque); // Deque: 42

        System.out.print("Set:");
        printCollection(set); // Set: 42
    }

    static void printCollection(Iterable<Integer> iterable) {
        // Iterables podem ser usados nesse tipo de for
        for (Integer element : iterable) {
            System.out.println(element);
        }
    }

    static void modifyCollection(Collection<Integer> collection) {
        if (collection.isEmpty()) {
            collection.add(42);
        } else {
            collection.remove(collection.iterator().next());
        }
    }
}

[Boost]

Matheus de Gondra — Sun, 12 Apr 2026 12:10:08 +0000

Paul J. Lucas

Jan 18 '24

auto in C23

6 min read

Liguagem C moderna e suas versões

Matheus de Gondra — Fri, 20 Mar 2026 17:34:21 +0000

Se você estuda programação você deve ter visto ou ao menos ouvido falar sobre a linguagem C. Essa linguagem que muitos não entenderam nada ao ver a primeira vez e já sofreram muitos com o uso de ponteiro e gerenciamento de memória manual.

Ao procurar sobre tutoriais ou na faculdade, muitas vezes é ensinado a versão ANSI C ou ISO C. Essa é uma versão bem antiga do C, mas assim como toda linguagem de programação o C foi se modernizando ao decorrer do tempo.

Nesse artigo eu quero comentar um pouco dessas versões que acabei descobrindo sobre elas ao fazer um projeto em C para a faculdade.

C89/C90

A linguagem C foi criada por Dennis Ritchie em 1972. E em 1989 o instituto norte-americano de padrões (ANSI) definiu as especificações para a linguagem C. Posteriormente, essa especificação sofreu pequenas mudanças na organização do documento pela Organização Internacional de Padrões (ISO). Esses padrões da linguagem ficaram conhecidos, respectivamente, como C89 e C90.

Essa versão da linguagem permite uma alta portabilidade da linguagem e é usado em sistemas legados e sistema embarcados sem suporte para versões modernas.

O ISO C ou C90 possui algumas características que são que todas as variáveis devem ser declaradas no inicio de um bloco de código.

main.c

#include <stdio.h>

int main() {
    int x = 5;

    printf("O valor de x é: %d\n", x);

    int y = 10;

    printf("O valor de y é: %d\n", y);

    return 0;
}

Para compilar para C90 vamos usar a flag -std=c90 e -pedantic para o alerta aparecer ou -pedantic-errors para transforma o alerta em erro e impedir a compilação.

gcc main.c -std=c90 -pedantic-errors 
main.c: In function ‘main’:
main.c:8:5: error: ISO C90 forbids mixed declarations and code [-Wdeclaration-after-statement]
    8 |     int y = 10;
      |     ^~~

No C90 não havia comentário de uma linha com o // apenas blocos de comentário com /* */. Usar comentários com // gera um erro de compilação.

main.c

int main() {
    /* comentario no C89/C90 */

    // isso gera erro
    return 0;
}

gcc main.c -std=c90                 
main.c: In function ‘main’:
main.c:4:5: error: C++ style comments are not allowed in ISO C90
    4 |     // isso gera erro
      |     ^
main.c:4:5: note: (this will be reported only once per input file)

O loop for não permitia que você declarasse a variável dentro dele. Ela deveria ser declarada antes, e como dito, no inicio do bloco.

#include <stdio.h>

int main() {
    /* correto no C89/C90 */
    int i;

    for (i = 0; i < 10; i++) {
        printf("Hello, World! %d\n", i);
    }

    /* erro no C89/C90 */
    for (int j = 0; j < 10; j++) {
        printf("Hello, World! %d\n", j);
    }

    return 0;
}

gcc main.c -std=c90 
main.c: In function ‘main’:
main.c:12:5: error: ‘for’ loop initial declarations are only allowed in C99 or C11 mode
   12 |     for (int j = 0; j < 10; j++) {
      |     ^~~
main.c:12:5: note: use option ‘-std=c99’, ‘-std=gnu99’, ‘-std=c11’ or ‘-std=gnu11’ to compile your code

C99

Em 1999, a linguagem C recebeu uma revisão e surgiu a versão conhecida como C99. Essa versão trouxe muitas melhorias a linguagem.

Uma das mudanças e que agora variáveis não precisavam mais estar no inicio do bloco e a variável de controle do for poderia ser declarada dentro dele. Também era possível usar comentário com //.

O C99 trouxe os tipos booleanos para a linguagem através do cabeçalho stdbool.h. Ou seja, quando disserem que C não tem tipo booleano, saiba que ele tem desde da versão C99!

main.c

#include <stdio.h>
#include <stdbool.h> // adiciona suporte a booleanos

int main() {
    bool reagiu_ao_post = true; // exemplo de variável booleana

    if (!reagiu_ao_post) {
        printf("Deixe sua reação ao post!\n");
    } else {
        printf("Obrigado por reagir ao post!\n");
    }

    return 0;
}

gcc main.c -std=c99 -o main && ./main
Obrigado por reagir ao post!

Outra adição é tipos inteiros com tamanho padronizados. Pois, o tipo int poderia ter tamanhos diferentes dependendo do compilador e da arquitetura do sistema. Quando você tem pouca memória, como em sistemas embarcados, essa variação pode te fazer consumir mais memória do que você acha que está ou estar com memória sobrando por ter um inteiro menor do que você achava.

O C99 adicionou o cabeçalho stdint.h com esses novos tipos inteiros:

int8_t: inteiro com sinal de 8 bits ou 1 byte. Armazena de -128 até 127.
uint8_t: inteiro sem sinal de 8 bits ou 1 byte. Armazena de 0 até 255.
int16_t: inteiro com sinal de 16 bits ou 2 bytes. Armazena de -32.768 até 32.767.
uint16_t: inteiro sem sinal de 16 bits ou 2 bytes. Armazena de 0 até 65.535.
int32_t: inteiro com sinal de 32 bits ou 4 bytes. Armazena de -2.147.483.648 até 2.147.483.647.
uint32_t: inteiro sem sinal de 32 bits ou 4 bytes. Armazena de 0 até 4.294.967.295.
int64_t: inteiro com sinal de 64 bits ou 8 bytes. Armazena de -9.223.372.036.854.775.808 até 9.223.372.036.854.775.807.
uint64_t: inteiro sem sinal de 64 bits ou 8 bytes. Armazena de 0 até 18.446.744.073.709.551.615.

E temos o cabeçalho inttypes.h que adicionar macros de formatação para lidar com a coleta e impressão desses tipos.

Para a impressão temos macros que são formadas com o seguinte padrão:

PRI: significa que é um print do valor
formato: formato para inteiros usado no printf como d para inteiro com sinal e u para sem sinal ou x para hexadecimal.
tamanho: tamanhos dos tipos do stdint.h como 8, 16, 32 ou 64

main.c

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>

int main() {
    int8_t num = INT8_MAX; // inteiro de 8 bits com sinal
    uint8_t unum = UINT8_MAX; // inteiro de 8 bits sem sinal

    int16_t num16 = INT16_MAX; // inteiro de 16 bits com sinal
    uint16_t unum16 = UINT16_MAX; // inteiro de 16 bits sem sinal

    int32_t num32 = INT32_MAX; // inteiro de 32 bits com sinal
    uint32_t unum32 = UINT32_MAX; // inteiro de 32 bits sem sinal

    int64_t num64 = INT64_MAX; // inteiro de 64 bits com sinal
    uint64_t unum64 = UINT64_MAX; // inteiro de 64 bits sem sinal

    // O compilador junta as strings literal na compilação
    printf("int8_t:   %" PRId8 "\n", num);
    printf("int16_t:  %" PRId16 "\n", num16);
    printf("int32_t:  %" PRId32 "\n", num32);
    printf("int64_t:  %" PRId64 "\n", num64);
    printf("uint8_t:  %" PRIu8 "\n", unum);
    printf("uint16_t: %" PRIu16 "\n", unum16);
    printf("uint32_t: %" PRIu32 "\n", unum32);
    printf("uint64_t: %" PRIu64 "\n", unum64);

    return 0;
}

gcc main.c -std=c99 -o main && ./main
int8_t:   127
int16_t:  32767
int32_t:  2147483647
int64_t:  9223372036854775807
uint8_t:  255
uint16_t: 65535
uint32_t: 4294967295
uint64_t: 18446744073709551615

Temos uma macro para escanear valores do usuário. Essas macros segue o seguinte formato:

SCN: significa que é um sca*n* do valor
formato: formato para inteiros usado no scanf como d para inteiro com sinal e u para sem sinal ou x para hexadecimal.
tamanho: tamanhos dos tipos do stdint.h como 8, 16, 32 ou 64

main.c

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>

int main(){
    int8_t age;

    printf("Digite sua idade: ");
    scanf("%" SCNd8, &age);

    printf("Voce tem %" PRId8 " anos.\n", age);

    return 0;
}

gcc main.c -std=c99 -o main && ./main
Digite sua idade: 25
Voce tem 25 anos.

O C99 adicionou versões mais seguras de algumas funções como a fnprintf para ser usada no lugar da sprintf que poderia causar um estouro de buffer.

main.c

#include <stdio.h>

int main() {
    char buffer[30];
    char string[] = "Linguagem C";

    /*
     Causa um buffer overflow, pois a string formatada é maior que o tamanho do buffer

    sprintf(buffer, "Escrevendo a string formatada %s.", string); 

    */

    // Evita o buffer overflow, pois limita a escrita ao tamanho do buffer
    snprintf(buffer, sizeof(buffer), "formatada %s.", string); 

    printf("%s\n", buffer);

    return 0;
}

gcc main.c -std=c99 -o main && ./main
formatada Linguagem C.

Foi adicionado também um suporte matemático melhor com complex.h para lidar com números complexos. Uma api genérica com macros do tgmath.h que chama a função correta de acordo com o tipo passado, por exemplo a macro sin() chama as funções especificas para cada tipo, como sin() para double, sinf() para float, etc. E foi adicionado mais funções para math.h

main.c

#include <complex.h>
#include <tgmath.h>

int main() {
    double x = 10.0f;
    float y = 10.0f;
    double complex z = 2.0 * I;

    sin(x);  // chama sin(x)
    sin(y);  // chama sinf(y)
    sin(z);  // chama csin(z)

    return 0;
}

C11

Em 2011 uma nova versão estável da linguagem C, chamada C11. Essa versão trouxe um suporte nativo a threads e operações atômicas.

Antes, para usar threads no C era necessário usar o Posix Threads no Linux com o pthreads.h e a Windows API no Windows com o windows.h. No C11 foi adicionado o cabeçalho threads.h para trabalhar com threads e stdatomic.h para operações atômicas, evitando condições de corrida.

main.c

#include <stdio.h>
#include <stdlib.h> // para macro EXIT_SUCCESS
#include <threads.h>
#include <stdatomic.h>

int incrementar_contador(void* arg) {
    atomic_int *contador = (atomic_int*) arg;

    for (int i = 0; i < 100; i++) {
        atomic_fetch_add(contador, 1); // incrementa o contador 100 vezes
    }

    return EXIT_SUCCESS; // retorna 0 de forma mais clara, indicando sucesso
}

int main() {
    const int num_threads = 10;
    atomic_int contador = 0;
    thrd_t threads[num_threads];


    // cria as threads para incrementar o contador
    for (int i = 0; i < num_threads; i++) {
        // cria a thread passando incrementar_contador para ser executado nela com a parâmetro da função sendo o contador
        thrd_create(&threads[i], incrementar_contador, &contador);
    }

    // aguarda as threads terminarem
    for (int i = 0; i < num_threads; i++) {
        thrd_join(threads[i], NULL);
    }

    printf("Valor final do contador: %d\n", contador);

    return EXIT_SUCCESS;
}

gcc main.c -std=c11 -o main && ./main
Valor final do contador: 1000

O C11 introduziu o _Generic que retorna instruções baseado no tipo passado para ele.

Você passa a expressão no primeiro argumento e dependendo do tipo da expressão ele retorna algo.

_Generic(expressao, tipo1: instrucao1, tipo2: instrucao2, ..., tipoN: instrucaoN)

Isso nos permite cria macros genéricas. Por exemplo, uma macro print_arr para printar qualquer tipo de array. A macro irá receber o array e o tamanho e dependendo do tipo do array irá retornar a função correta para printar e irá executar ela.

main.c

#include <stdio.h>

// o \ permite quebrar linha nas macros
#define print_arr(arr, size) _Generic((arr), \
    int*: print_arr_int, \
    double*: print_arr_double, \
    char*: print_arr_char, \
    float*: print_arr_float \
)(arr, size) // _Generic retorna uma função e executamos passando arr e size

void print_arr_int(int *arr, int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

void print_arr_double(double *arr, int size) {
    for (int i = 0; i < size; i++) {
        printf("%.2lf ", arr[i]);
    }
    printf("\n");
}

void print_arr_char(char *arr, int size) {
    for (int i = 0; i < size; i++) {
        printf("%c ", arr[i]);
    }
    printf("\n");
}

void print_arr_float(float *arr, int size) {
    for (int i = 0; i < size; i++) {
        printf("%.2f ", arr[i]);
    }
    printf("\n");
}

int main() {
    char char_arr[6] = {'H', 'e', 'l', 'l', 'o', '\0'};
    int int_arr[6] = {1, 2, 3, 4, 5, 6};
    double double_arr[6] = {1.1, 2.2, 3.3, 4.4, 5.5, 6.6};
    float float_arr[6] = {1.1f, 2.2f, 3.3f, 4.4f, 5.5f, 6.6f};

    print_arr(char_arr, 6);
    print_arr(int_arr, 6);
    print_arr(double_arr, 6);
    print_arr(float_arr, 6);

    return 0;
}

gcc main.c -std=c11 -o main && ./main
H e l l o  
1 2 3 4 5 6
1.10 2.20 3.30 4.40 5.50 6.60
1.10 2.20 3.30 4.40 5.50 6.60

Temos asserções estáticas com o _Static_assert para fazer verificações em tempo de compilação em vez de tempo de execução.

main.c

#include <stdlib.h>

// Garante em tempo de compilação que o int tenha 4 bytes
_Static_assert(sizeof(int) != 4, "O compilador nao suporta inteiros de 4 bytes");


int main() {

    return 0;
}

 gcc main.c -std=c11 -o main && ./main
main.c:5:1: error: static assertion failed: "O compilador n\37777777703\37777777643o suporta inteiros de 4 
bytes"
    5 | _Static_assert(sizeof(int) != 4, "O compilador nao suporta inteiros de 4 bytes");
      | ^~~~~~~~~~~~~~

C17

O C17 é uma versão que não trouxe novas funcionalidades. Essa versão focou em correções de bug da versão C11.

C23

Esse é a versão mais atual da linguagem C, lançada em 2023, o C23 trouxe grandes mudanças trazendo funcionalidades que deixaram o C mais próximo ao C++.

Uma dessas mudança é que os tipos booleanos se tornaram padrão e você não precisa mais incluir o cabeçalho stdbool.h para usar no seu código.

#include <stdio.h>
#include <stdlib.h>

int main() {
    bool isValid = false;

    isValid = 10 == 10;
    if (isValid) {
        printf("O valor e valido: %d\n", isValid);
    } else {
        printf("O valor nao e valido: %d\n", isValid);
    }

    return EXIT_SUCCESS;
}

gcc main.c -std=c23 -o main  && ./main
O valor e valido: 1

Foi introduzido na linguagem o nullptr que, como no C++, faz um ponteiro apontar para nada. Antes era usado a macro NULL, mas em alguns casos essa macro poderia causar comportamentos inesperados.

A macro NULL geralmente é expandida para 0 ou (void *)0. Se NULL fosse passado para um _Generic ele seria tratado como int ou void *. Já o nullptr é um novo tipo para representar um valor de um ponteiro nulo e não seria confundido com outro tipo

#include <stdio.h>
#include <stdlib.h>

int main() {
    _Generic(NULL, 
        int: printf("NULL e um inteiro\n"),
        int*: printf("NULL e um ponteiro do tipo int\n"), 
        void*: printf("NULL e um ponteiro do tipo void\n"), 
        default: printf("NULL e de um tipo desconhecido\n")
    );

    _Generic(nullptr, 
        int: printf("nullptr e um inteiro\n"),
        int*: printf("nullptr e um ponteiro do tipo int\n"), 
        void*: printf("nullptr e um ponteiro do tipo void\n"), 
        default: printf("nullptr e de um tipo desconhecido\n")
    );

    return EXIT_SUCCESS;
}

gcc main.c -std=c23 -o main  && ./main
NULL e um ponteiro do tipo void
nullptr e de um tipo desconhecido

No C23 a palavra chave auto foi redefinida. Antes o auto era um modificador para indicar que a variável tinha armazenamento automático na stack, servia como a contrapartida do static. Mas, isso já era o padrão de uma variável e usar o auto era uma redundância.

// as duas declarações são a mesma coisa
int valor = 10;
auto int outro_valor = 10;

A partir do C23, você pode usar o auto para inferir o tipo na variável. Há também o typeof que serve para inferir o tipo em uma variável.

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

typedef struct { 
    char *name;
    uint8_t age;
} User;

int main() {
    auto age = 10; // infere o tipo int
    auto name = "Fulano"; // infere o tipo const char* (string literal)

    User user = { .name = name, .age = age };
    // typeof infere o tipo da variável user e cria user2 com o mesmo tipo
    typeof(user) user2 = { .name = "Ciclano", .age = 20 }; 

    printf("User 1: %s, Age: %d\n", user.name, user.age);
    printf("User 2: %s, Age: %d\n", user2.name, user2.age);

    return EXIT_SUCCESS;
}

gcc main.c -std=c23 -o main  && ./main
User 1: Fulano, Age: 25
User 2: Ciclano, Age: 20

Temos o constexpr que cria uma constante. Diferente do const que é avaliado em tempo de execução o constexpr é avaliado em tempo de compilação.

#include <stdio.h>
#include <stdlib.h>

int main() {
    // VALUE é resolvido em tempo de compilação, permitindo a definição de um array de tamanho fixo
    // usar `const` daria um erro, pois `const` é resolvido em tempo de execução
    // e o tamanho do array precisa ser conhecido em tempo de compilação
    constexpr int VALUE = 4;
    int arr[VALUE] = { 1, 2, 3, 4 };

    for (int i = 0; i < VALUE; ++i) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return EXIT_SUCCESS;
}

gcc main.c -std=c23 -o main  && ./main
1 2 3 4

C23 adicionou o prefixo 0b para declarar números binários literais e uso do ' para separar os dígitos dos números, facilitando a leitura.

#include <stdio.h>
#include <stdlib.h>

int main() {
    int binario = 0b101; // O prefixo "0b" indica que o número é binário
    printf("O valor do binario 0b101 e: %d\n", binario);

    int milhao = 1'000'000; // O apóstrofo é usado como separador de dígitos para melhorar a legibilidade
    printf("O valor do milhao e: %d\n", milhao);

    return EXIT_SUCCESS;
}

gcc main.c -std=c23 -o main  && ./main
O valor do binario 0b101 e: 5
O valor do milhao e: 1000000

A inicialização segura de array, union e struct mudou um pouco. Antes para fazer a inicialização de valores de uma struct, union ou array você usava {0} e no C23 isso foi simplificado para {}.

#include <stdio.h>
#include <stdlib.h>

struct ProdutoEstoque {
    int id_produto;
    float preco;
    char nome[50];
    int *historico_movimentacoes;
};

void print_produto(struct ProdutoEstoque *produto) {
    printf("ID: %d\n", produto->id_produto);
    printf("Preco: %.2f\n", produto->preco);
    printf("Nome: '%s'\n", produto->nome);

    if (produto->historico_movimentacoes == NULL) {
        printf("Ponteiro de historico inicializado como nulo de forma segura.\n");
    }
}

int main() {
    // Inicialização segura antes do C23
    struct ProdutoEstoque novo_item = {0}; 

    // Inicialização segura usando a nova sintaxe do C23
    struct ProdutoEstoque outro_item = {};

    print_produto(&novo_item);
    print_produto(&outro_item);

    return EXIT_SUCCESS;
}

gcc main.c -std=c23 -o main && ./main
ID: 0
Preco: 0.00
Nome: ''
Ponteiro de historico inicializado como nulo de forma segura.
ID: 0
Preco: 0.00
Nome: ''
Ponteiro de historico inicializado como nulo de forma segura.

Versão do compilador

Mostrei algumas funcionalidades de cada versão do C, mas como eu sei qual versão o meu compilador está usando?

Existe uma macro chamada __STDC_VERSION__ que armazena um número inteiro do tipo long que indica a versão do C usada na compilação. O valor dessa macro é o ano mais o mês de lançamento da versão. Usando a flag -std mudamos a versão do C usada na compilação e o valor dessa macro também é mudado.

#include <stdio.h>
#include <stdlib.h>

/* 
O C89/C90 não define __STDC_VERSION__ então se for C89/C90
compilamos o primeiro main, caso contrário compilamos o segundo main
*/
#ifndef __STDC_VERSION__

int main() {
    printf("C89/C90\n");
    return EXIT_SUCCESS;
}

#else

int main() {
    switch (__STDC_VERSION__) {
        case 202311L: // ano 2023 + mês 11 = 202311
            printf("C23\n");
            break;

        case 201710L: // ano 2017 + mês 10 = 201710
            printf("C17\n");
            break;

        case 201112L: // ano 2011 + mês 12 = 201112
            printf("C11\n");
            break;

        case 199901L: // ano 1999 + mês 01 = 199901
            printf("C99\n");
            break;
    }

    return EXIT_SUCCESS;
}
#endif

gcc main.c -std=c89 -o main && ./main
C89/C90

gcc main.c -std=c99 -o main && ./main
C99

gcc main.c -std=c11 -o main && ./main
C11

gcc main.c -std=c17 -o main && ./main
C17

gcc main.c -std=c23 -o main && ./main
C23

Eu estou usando o gcc versão 15.2.0, que adota o C23 como padrão ao compilar. Se eu tirar a flag -std e compilar terei "C23" como saída.

gcc main.c -o main && ./main
C23

Java: a classe String

Matheus de Gondra — Mon, 23 Feb 2026 17:48:31 +0000

Java é uma linguagem com tipos primitivos para representar números, como int e long, representar valores booleanos, com o boolean, e representar caracteres, com o char. Mas, como o java representar uma palavra ou um texto?

Array de caracteres

Uma palavra é um conjunto de letra e o java tem o tipo char para representar uma letra. Então, podemos representar uma palavra usando um array de char.

char[] letras = { 'H', 'e', 'l', 'l', 'o' };
for (char letra : letras) {
  System.out.print(letra); // Hello
}

Isso funciona. Mas, não é desse jeito que o java representa um texto. Esse código está mais parecido com um código C.

Classe String

O java não possui um tipo primitivo para representar um texto. Ele usa uma classe chamada String.

A classe String criar uma string imutável e para criar uma string é só usar as aspas "".

String palavra = "Hello";
System.out.println(palavra); // Hello

Como é uma classe, também podemos usar o operador new.

String palavra = new String("Hello");
System.out.println(palavra); // Hello

Porém, não devemos usar o new para criar uma String, porque o java otimiza as strings criando um Pool de Strings.

String Pool

Toda vez que criamos um nova string um novo objeto é criado na memoria heap. Usando string literais " " o java consegue otimizar a memória criando a string dentro de um pool de strings.

O String Pool é uma área que o java cria dentro da memória heap para reutilizar objetos String.

Quando você cria uma string literal, usando aspas, o java primeiro verifica se essa string existe no String Pool. Se não existir ele cria o objeto e devolve a referência para ele, se existir ele só devolve a referência. Isso permite reutilizar objetos String diminuindo o consumo de memória.

Usando o operador new, a string é criada na memória heap, mas fora do String Pool. Com isso, mesmo que você tenta duas strings iguais elas serão objetos diferentes.

String s1 = "Hello";

// a string "Hello" já existe no String Pool então apenas retorna a referência
String s2 = "Hello";

// Um novo objeto é criado fora do String Pool
String s3 = new String("Hello");

// comparando as referências
System.out.println(s1 == s2); // true
System.out.println(s1 == s3); // false

Métodos

Como eu disse, a string no java é um objeto. Isso significa que ela possuí métodos que nos ajudam na manipulação.

Por ser imutável, toda manipulação gera uma nova string em vez de mudar a string anterior. Por isso, os métodos da classe String sempre retornam algo.

String nome = "Fulano";
String nomeMaiusculo = nome.toUpperCase();
String nomeMinusculo = nome.toLowerCase();

System.out.println(nome); // Fulano
System.out.println(nomeMaiusculo); // FULANO
System.out.println(nomeMinusculo); // fulano

A classe String possui vários métodos, esses são alguns deles:

boolean isEmpty(): verifica se a string é vazia.
boolean isBlank(): verifica se a string é vazia ou se só tem espaço vazio.
boolean startsWith(String prefixo): verifica se a string começa com o prefixo
boolean endsWith(String sufixo): verifica se a string termina com o sufixo.
String trim(): retorna uma string sem os espaço vazios no inicio e no fim dela.
int length(): retorna o tamanho da string.

Conclusão

Espero que ao final dessa leitura você tenha entendido melhor sobre como o java faz para representar textos e como a classe String funciona por baixo dos panos.

Preparando uma API NodeJS para produção

Matheus de Gondra — Mon, 05 Jan 2026 18:33:54 +0000

Hoje vou mostrar o que deve ser feito para preparar sua aplicação NodeJS para o ambiente de produção. Mas, antes vamos criar um projeto para isso.

Iniciando projeto

A versão do NodeJS que estarei usando é v22.17.0 e usarei o pnpm na versão v10.18.3 como o gerenciador de pacotes, mas você pode usar o npm ou o yarn se preferir.

Vamos iniciar um projeto com o comando init para gerar o package.json

pnpm init

Vou adicionar a chave "type": "module" para usarmos o ES Modules nos nossos arquivos.

{
  "name": "node-prod",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "type": "module", // Usando ES Modules
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "packageManager": "pnpm@10.18.3"
}

Instalando dependências

Vamos criar API REST, então precisamos instalar algumas dependências no projeto. Vamos ter dependências de produção, que ficam em dependencies e dependências de desenvolvimento, que ficam em devDependencies, tudo isso listado no package.json.

Vamos começar instalando as dependências de produção

express: criação do servidor HTTP
pino: geração de logs
@prisma/client: cliente do banco de dados
@prisma/adapter-pg: adaptador do postgres para o prisma client
pg: driver do banco PostgreSQL
dotenv: para acessar as variáveis de ambiente no .env
express-rate-limit: middleware contra ataque de força bruta
cors: middleware para configurar o CORS
helmet: middleware para adicionar cabeçalhos de segurança

pnpm add express pino @prisma/client @prisma/adapter-pg pg dotenv express-rate-limit cors helmet

Essas são as dependências que serão usadas no ambiente de produção. Agora vamos instalar as dependências que serão usadas apenas no ambiente de desenvolvimento.

typescript: superset do javascript que adiciona tipagem estática
prisma: biblioteca de ORM
tsx: para executar código typescript
@tsconfig/node22: configuração do typescript para o NodeJS v22
pino-pretty: para melhor visualização dos logs em desenvolvimento
@types/pg: tipagem do pg
@types/node: tipagem do NodeJS
@types/express: tipagem do express
@types/cors: tipagem do cors

pnpm add -D typescript prisma tsx @tsconfig/node22 @types/pg @types/node @types/express @types/cors pino-pretty

No pnpm há uma particularidade, algumas biblioteca têm um script postinstall que o pnpm bloqueia por segurança. Para desbloquear isso você precisa usar o comando pnpm approve-builds e escolher quais libs você permite rodar o script postinstall e digita y para rodar os scripts de postinstall.

Com isso, um arquivo pnpm-workspace.yaml também será criado listando as bibliotecas que podem executar o postinstall.

onlyBuiltDependencies:
  - '@prisma/engines'
  - esbuild
  - prisma

O package.json ficou assim.

{
  "name": "node-prod",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "type": "module",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "packageManager": "pnpm@10.18.3",
  "dependencies": {
    "@prisma/adapter-pg": "^7.2.0",
    "@prisma/client": "^7.2.0",
    "cors": "^2.8.5",
    "dotenv": "^17.2.3",
    "express": "^5.2.1",
    "express-rate-limit": "^8.2.1",
    "helmet": "^8.1.0",
    "pg": "^8.16.3",
    "pino": "^10.1.0"
  },
  "devDependencies": {
    "@tsconfig/node22": "^22.0.5",
    "@types/cors": "^2.8.19",
    "@types/express": "^5.0.6",
    "@types/node": "^25.0.3",
    "@types/pg": "^8.16.0",
    "pino-pretty": "^13.1.3",
    "prisma": "^7.2.0",
    "tsx": "^4.21.0",
    "typescript": "^5.9.3"
  }
}

Configurando typescript

Agora vamos configurar o typescript. Use o comando tsc --init para criar o arquivo tsconfig.json. E vamos usar a configuração que instalamos com o @tsconfig/node22, vamos definir o diretório de que irá ser gerado com o código compilado como dist e não vamos permitir a compilação se houver erros. Vamos usar o include para incluir tudo de src na pasta dist quando for gerada, se não seria criada uma pasta src dentro da pasta dist.

pnpm tsc --init

tsconfig.json

{
  "extends": "@tsconfig/node22/tsconfig.json",
  "compilerOptions": {
    "outDir": "dist",
    "noEmitOnError": true
  },
  "include": ["src"]
}

Variáveis de ambiente

Agora vamos criar nossos arquivos typescript. Vamos começar com um arquivo src/env.ts para centralizar as variáveis de ambiente que usaremos.

export const env = {
  port: Number(process.env.PORT) || 3000,
  isProduction: process.env.NODE_ENV === "production",
  databaseUrl: process.env.DATABASE_URL,
  logLevel: process.env.LOG_LEVEL || "info"
};

Logger da aplicação

Agora vamos criar o logger para a nossa aplicação. Usaremos o pino que instalamos antes para isso. Vamos criar o arquivo src/logger.ts.

Na configuração do logger iremos definir o nível de log, para que mensagem de log que estejam abaixo daquele nível não apareçam. E vamos usar o pino-pretty quando não estivermos em ambiente de produção.

import pino from "pino";
import { env } from "./env.js";

export const logger = pino({
  level: env.logLevel,
  transport: env.isProduction ? undefined : { target: "pino-pretty" }
});

Banco de dados

Para a comunicação com o banco de dados vamos usar o Prisma como biblioteca de ORM e o PostgreSQL como banco de dados.

Primeiro precisamos configurar o prisma com o comando init do prisma.

pnpm prisma init

Esse comando irá criar o prisma/schema.prisma onde temos os esquemas, .env onde ficará as variáveis de ambiente, .gitignore para impedir que alguns arquivos sejam salvos pelo git e o prisma.config.ts onde terá a configuração da CLI do prisma.

No prisma/schema.prisma vamos criar a tabela de usuários. Usarei o @map para mudar o nome da coluna no banco e @@map para mudar o nome da tabela no banco.

generator client {
  provider = "prisma-client"
  output   = "../src/generated/prisma"
}

datasource db {
  provider = "postgresql"
}

model User {
  id        Int      @id @default(autoincrement())
  name      String
  email     String   @unique
  createdAt DateTime @default(now()) @map("created_at")
  updatedAt DateTime @updatedAt @map("updated_at")

  @@map("users")
}

Salve o arquivo e defina a URL de conexão com o banco de dados no arquivo .env e após isso gere a migração e os arquivos do prisma

// criando a migração
pnpm prisma migrate dev --name create-table-users


// gerando o PrismaClient
pnpm prisma generate

O prisma generate irá criar o diretório src/generated/prisma onde ficam os tipos definidos no schema.prisma e o PrismaClient que será usado para fazer as query no banco.

O próximo passo é criar o arquivo src/db.ts para criar uma instância do PrismaClient.

import { PrismaPg } from "@prisma/adapter-pg";
import { env } from "./env.js";
import { PrismaClient } from "./generated/prisma/client.js";

const adapter = new PrismaPg({ connectionString: env.databaseUrl! });
export const db = new PrismaClient({ adapter });

Rotas da aplicação

Vamos criar algumas rotas para testarmos a aplicação. Colocaremos logs para saber o que está acontecendo também.

import { Router } from "express";
import { logger } from "./logger.js";
import { db } from "./db.js";
import { PrismaClientKnownRequestError } from "./generated/prisma/internal/prismaNamespace.js";

const router = Router();

router.get("/", (req, res) => {
  logger.info({ route: "/" }, "Health check endpoint called");

  res.json({ status: "OK" });
});

router.post("/users", async (req, res) => {
  const childLogger = logger.child({ route: "/users", method: "POST" });

  try {
    const { name, email } = req.body;

    childLogger.debug({ data: { name, email } }, "Creating new user");

    const newUser = await db.user.create({
      data: {
        name,
        email
      }
    });

    childLogger.info({ userId: newUser.id }, "New user created");

    res.status(201).json(newUser);
  } catch (error) {
    childLogger.error({ error, route: "/users" }, "Error creating user");

    res.status(500).json({ error: "Internal Server Error" });
  }
});

router.get("/users", async (req, res) => {
  const childLogger = logger.child({ route: "/users", method: "GET" });

  try {
    const users = await db.user.findMany();

    childLogger.info({ userCount: users.length }, "Fetched users successfully");

    res.json(users);

  } catch (error) {
    childLogger.error({ error }, "Error fetching users");

    res.status(500).json({ error: "Internal Server Error" });
  }
});

router.delete("/users/:id", async (req, res) => {
  const childLogger = logger.child({ route: "/users/:id", method: "DELETE" });

  try {
    const userId = Number(req.params.id);

    childLogger.debug({ userId }, "Deleting user");

    await db.user.delete({
      where: { id: userId }
    });

    childLogger.info({ userId }, "User deleted successfully");

    res.status(204).send();
  } catch (error) {
    if (error instanceof PrismaClientKnownRequestError && error.code === "P2025") {
      childLogger.warn({ error }, "User not found for deletion");

      return res.status(404).json({ error: "User not found" });
    }

    childLogger.error({ error }, "Error deleting user");

    res.status(500).json({ error: "Internal Server Error" });
  }
});

export { router };

Servidor

Com tudo isso vamos montar nosso arquivo principal src/server.ts onde iremos criar o servidor e iniciá-lo.

import cors from "cors";
import express, { json } from "express";
import rateLimit from "express-rate-limit";
import helmet from "helmet";
import { env } from "./env.js";
import { logger } from "./logger.js";
import { router } from "./routes.js";

const app = express();

// middleware para parsear JSON
app.use(json());

// middleware de segurança
const oneMinute = 60 * 1000;
app.use(
    helmet(),
    cors({
        origin: "*", // ajuste conforme necessário
        methods: ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
        allowedHeaders: ["Content-Type", "Authorization"]
    }),
    rateLimit({
        windowMs: 15 * oneMinute,
        max: 100
    })
);

// rotas
app.use(router);

app.listen(env.port, () => logger.info(`Server is running on port ${env.port}`));

Scripts

Vamos criar os scripts start, dev e build e vamos definir o arquivo de entrada na chave main do package.json

"main": "dist/server.js",
"scripts": {
    "start": "node --env-file-if-exists=.env .",
    "dev": "tsx --env-file-if-exists=.env src/server.ts",
    "build": "tsc"
  }

Testando

Inicie a aplicação em modo de desenvolvimento com o script dev e vamos iniciar com o nível de log como debug para ver todos os logs que foram criados.

.env

DATABASE_URL="postgresql://dev:dev@localhost:5432/node_prod_post"
NODE_ENV="development"
PORT=3000
LOG_LEVEL="debug"

pnpm dev

Irei fazer as requisições para a API usando a extensão do VSCode REST Client usando um arquivo client.http

@baseUrl = http://localhost:3000

GET {{baseUrl}}

###
POST {{baseUrl}}/users
Content-Type: application/json

{
    "name": "John Doe",
    "email": "john@email.com"
}

###
GET {{baseUrl}}/users

###
DELETE {{baseUrl}}/users/1

Fiz algumas requisições e os logs estão sendo gerados corretamente.

Preparando para produção

O código funciona em ambiente de desenvolvimento. Mas, em produção não teremos código typescript sendo executado ou nenhuma dependência de desenvolvimento instalada.

Primeiro vamos compilar o código para javascript usando o script build. Isso irá gerar uma pasta dist com o código compilado.

Agora vamos definir as variáveis de ambiente que serão usadas em produção que são a URL do banco de produção, o nível de log como "warn" e a NODE_ENV como "production" para ativar otimizações das bibliotecas.

DATABASE_URL="postgresql://dev:dev@localhost:5432/node_prod_post_production"
NODE_ENV="production"
PORT=3000
LOG_LEVEL="warn"

Como eu adicionei uma URL para outro banco de dados, preciso rodar as migrações para gerar as tabelas. Para produção, o prisma tem o comando prisma migrate deploy

pnpm prisma migrate deploy

Por fim, vamos desinstalar as dependências de desenvolvimento.

pnpm i --prod

Agora podemos iniciar o projeto com o script start.

pnpm start

O projeto iniciará silenciosamente no terminal. Como definimos o nível como 'warn', apenas avisos e erros críticos serão exibidos, evitando poluição visual e excesso de uso de disco em produção.

Outra mudança é que os logs são impressos em formato JSON. Embora seja difícil para humanos lerem, esse formato é ideal para ferramentas de monitoramento (como Datadog, CloudWatch ou Elastic Stack) indexarem e processarem as informações.

Um ponto que deve ser levado em conta é que nesse projeto o script start eu usei a flag --env-file-if-exists para usar o arquivo .env para definir as variáveis de ambiente, mas em um ambiente real as variáveis de ambiente não são definidas em um arquivo e sim injetadas diretamente no ambiente.

Conclusão

Com essas configurações, transformamos um simples setup de desenvolvimento em uma aplicação pronta para o mundo real. A diferença entre um projeto amador e um profissional muitas vezes está nesses detalhes: a remoção de dependências desnecessárias, a compilação correta do TypeScript e a estruturação de logs em JSON para ferramentas de observabilidade.

Streams o que são e como usar no NodeJS

Matheus de Gondra — Fri, 10 Oct 2025 16:45:03 +0000

Netflix, Prime Video, Crunchyroll todos serviços de streaming, mas você sabe o que uma stream? E mais, você sabe o que uma stream no NodeJS?

Streams

Pensei na Netflix, você não espera um episódio inteiro de uma série baixar para você começar a assistir, por que você está consumindo uma stream de um vídeo.

Uma stream é um fluxo de dados. Em vez de você consumir um dado inteiro de uma vez, como um conteúdo de um arquivo ou um vídeo, você consume o dado em partes.

Memória

Mas, por que eu preciso consumir os dados em partes em vez de consumir tudo de uma vez?

Hoje pode não parece tanto, mas memória era algo escasso. Então quando você criava software, o quanto de memória era usado era uma grande preocupação. Se você precisasse criar um software que para inicializar ele consumisse 30MB de memória e analisasse um arquivo que tivesse 2GB de tamanho o seu software pararia de funcionar por não ter memória suficiente para carregar um arquivo tão grande.

Agora se fosse utilizado um stream em vez de carregar o arquivo completamente não teria esse problema de falta de memoria, pois a arquivo seria enviado em partes, chamadas chunk, e processado a medida que chegam.

Streams no NodeJS

O NodeJS possui um módulo para trabalhar com streams desde a primeira versão: node:stream.

O NodeJS possui 3 tipos de streams diferentes:

Readable Stream

Esse tipo de stream é utilizado quando queremos ler de uma fonte de dados. A stream pode operar em dois modos:

flowing mode: nesse modo os dados são lidos automaticamente através de eventos "data"
paused mode: nesse modo o método read() deve ser chamado explicitamente para ler cada dado da stream.

Por padrão toda Readable Stream começa no paused mode, mas isso pode ser mudado ao chamar o métodos resume(), pipe() ou criando um handler para evento data.

Para criar uma stream de leitura (readable) precisamos importar Readable do módulo node:stream e podemos usar o método from() que recebe um Iterable ou um AsyncIterable.

As streams herdam da classe EventEmitter então podemos usar o método on para lidar com eventos da stream. Alguns eventos que ocorrem com uma Readable Stream são:

data: dados são recebidos.
end: todos os dados foram lidos. Não há mais dados para consumir.
close: a stream foi fechada.
error: algum erro ocorreu durante o fluxo de dados

import { Readable } from "node:stream";

const readableStream = Readable.from([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);

readableStream.on("data", (chunk) => {
    console.log("Dado recebido:", chunk);

    if (chunk === 7) {
        // Simula uma condição para fechar a stream
        if (Math.random() > 0.5) {
            // fecha a stream sem erro (evento "close")
            readableStream.destroy();
        } else {
            // fecha a stream com erro (evento "error")
            readableStream.destroy(new Error("Erro forçado na stream"));
        }
    }
});

readableStream.on("end", () => {
    console.log("Todos os dados consumidos.");
});

readableStream.on("close", () => {
    console.log("Stream foi fechada.");
});

readableStream.on("error", (err) => {
    console.error("Erro na stream:", err);
});

Se for necessário criar sua própria Readable Stream personalizada, você precisa implementar a interface da classe Readable. Isso pode ser feito herdando a classe Readable e implementando o método _read().

import { Readable } from "node:stream";

class MyStream extends Readable {
    data = [1, 2, 3, 4, 5];

       constructor(options = {}) {
          super(options);
       }

    _read() {
        const chunk = this.data.shift();
        if (chunk) {
            const dataToSend = String(chunk);
            this.push(dataToSend); // envia os dados do tipo string ou Buffer
            return;
        }

        this.push(null); // sinaliza o fim da stream
    }
}

const myStream = new MyStream();

myStream.on("data", (chunk) => {
    // Os dados chegam como um tipo Buffer
    console.log(chunk.toString()); // convertendo para string
});

Para casos mais simples pode ser diretamente uma instancia de Readable e implementando o método read().

import { Readable } from "node:stream";

const data = [1, 2, 3, 4, 5];

const myStream = new Readable({
    read() {
        const chunk = data.shift();
        if (chunk) {
            const dataToSend = String(chunk);
            this.push(dataToSend);
            return;
        }
    }
});

myStream.on("data", (chunk) => {
    console.log(chunk.toString());
});

Writable Stream

Esse tipo de stream é utilizado quando queremos escrever dados em algum lugar.

Para criar uma stream de escrita (writable), importamos Writable do módulo node:stream e criamos uma instância com um método write().

O método write() recebe 3 argumentos:

chunk: os dados que serão escritos em algum lugar. O chunk é uma variável do tipo Buffer.
encoding: a codificação usada.
callback: função para continuar o fluxo ou parar caso tenho um error.

import { Writable } from "node:stream";

const writableStream = new Writable({
    write(chunk, _encoding, callback) {
        console.log("Dado recebido:", chunk.toString());

        callback();
    }
});

writableStream.write("Olá");
writableStream.write("Mundo!");

Streams operam com string, Buffer, TypedArray ou DataView. Caso seja necessário trabalhar com outros tipos é preciso usar objectMode: true.

import { Writable } from "node:stream";

const writableStream = new Writable({
    objectMode: true,
    write(chunk, _encoding, callback) {
                // chunk agora é um object
        console.log("Dado recebido:", chunk);

        callback();
    }
});

writableStream.write({ message: "Olá" });
writableStream.write({ message: "Mundo!" });

Para criar uma writable stream customizada é necessário herdar de Writable e implementar o método _write e/ou _writev.

import { Writable } from "node:stream";

class MyStream extends Writable {
    constructor(options = {}) {
        super(options);
    }

    _write(chunk, _encoding, callback) {
        console.log("Dado recebido:", chunk);
        callback();
    }
}

const writableStream = new MyStream({ objectMode: true });

writableStream.write("Olá");
writableStream.write({ message: "Mundo!" });

Duplex e Transform Stream

As duplex streams são streams que implementam o protocolo Readable e Writable, ou seja, ela funciona como uma stream de escrita e leitura.

Dentro das Duplex streams, temos as Transform streams que são streams de transformação. Essas são usadas quando queremos manipular um dados que está passando pelo nossa stream.

Vamos a um exemplo, vamos criar uma stream de leitura (readable) e conectar a uma stream de transformação (transform) usando o método pipe e vamos mandar para o console usando o process.stdout que é uma stream de escrita.

import { Readable, Transform } from "node:stream";

const dados = ["javascript", "nodejs", "java", "elixir", "c++"];
const readableStream = Readable.from(dados);

const transformStream = new Transform({
    transform(chunk, _encoding, callback) {
        const dado = chunk.toString();
        const dadoTransformado = `${dado.toUpperCase()}\n`;

        // callback recebe dois parâmetros: erro e o dado transformado
        callback(null, dadoTransformado);
    }
});

// o método pipe conecta streams
readableStream.pipe(transformStream).pipe(process.stdout);

Resumindo: lemos os dados com uma readable stream, transformamos os dados com uma stream duplex stream (Transform) e escrevemos o conteúdo no console usando uma writable stream (process.stdout).

Por que usar?

Vamos usar numa situação mais real para você entender o porquê usar uma stream no NodeJS.

Vamos fazer a análise de uma base de dados csv, baixei uma base de dados sobre o preço do combustível.

Vamos usar o node:fs para ler o arquivo e escrever no console.

import fs from "node:fs"

const arquivo = fs.readFileSync("ca-2004-01.csv");
const linhas = arquivo.toString().split("\n");
linhas.map(linha => {
  console.log(linha);
});

node index.js

Ao rodar o código funciona perfeitamente.

Vamos tentar novamente, mas limitaremos a memória usada pelo programa para 100MB. Afinal, não teremos gigas de memória em todo ambiente de execução.

node --max-old-space-size=100 index.js

Dessa vez tivemos um erro do motor v8, usado pelo NodeJS para executar o javascript, por falta de memória para o nosso programa.

Agora vamos usar as streams. O módulo node:fs tem uma função para ler um arquivo como uma stream.

import fs from "node:fs"

const readableStream = fs.createReadStream("ca-2004-01.csv");

readableStream.pipe(process.stdout);

node --max-old-space-size=100 index.js

Agora o código funcionou e você vai ver os dados no console.

No primeiro caso, como limitamos a memória do nosso programa, ele quebra ao carregar o arquivo, porque ele precisa de mais de 100MB para isso.

Já com streams lemos e processamos o arquivo em partes e não todo de uma vez. Carregamos 64KB do arquivo e mandamos escrever no console, depois carregamos mais 64KB e mandamos para o console e repetimos até o fim dos dados. Com isso, não usamos o nosso limite de 100MB inteiro e o programa finaliza com sucesso.

[Boost]

Matheus de Gondra — Tue, 30 Sep 2025 10:16:12 +0000

C++ Addons no Node.js

Ryan Vieira ・ Dec 2 '24

#node #javascript #cpp #programming

Exception vs Error no Java

Matheus de Gondra — Sat, 23 Aug 2025 12:56:49 +0000

Introdução

Ao estudar sobre java você pode ter se deparado com o conceito de Exception (exceção) e Error (erro). Mas, qual a diferença entre eles?

As duas classes, Error e Exception, são subclasses da Throwable. Isso permite que elas sejam lançadas com throw para mudar o fluxo da aplicação.

Mas o uso dessas duas classes são diferentes

Error

A classe, e as subclasses, de Error representam erros do ambiente de execução JVM. Esses tipos de erros não devem ser tratados pelo programador e sim pelos programadores da JVM.

Algumas classes que herdam de Error são:

VirtualMachineError -> Erro na JVM
StackOverflowError -> Erro de estouro de pilha
OutOfMemoryError -> Erro de falta de memoria para alocar um objeto

Exception

As exceções são um tipo de erro diferente, elas são fluxos alternativos do seu programa. O programador pode e deve lidar com elas ao desenvolver um software.

Fluxos de falha, que são diferentes de erro, são representados pelas exceções. Por exemplo, ao ler um arquivo há dois fluxos possíveis: O arquivo existe e é possível ler (caso de sucesso) ou o arquivo pode não existir (caso de falha). Isso não é um erro é um fluxo de falha e nesses casos ocorre de uma exceção IOException ser lançada.

Programadores devem lidar com os casos de falha capturando as exceções com um bloco try/catch ou try/catch/finally.

Algumas classes que herdam de Exception são:

IOException -> exceção ao lidar com arquivos
RuntimeException -> exceção que ocorre no momento de execução
NumberFormatException -> exceção ao converter string que não são números