Meus artigos e tutoriais de programação on Cesar Gimenes

Kutta no navegador: mesmo código, outro orçamento de frame

crg@crg.eti.br (Cesar Gimenes) — Sun, 16 Aug 2026 10:30:00 -0300

O Kutta agora roda dentro de uma aba do navegador. Mesmo código do desktop, GOOS=js GOARCH=wasm, nenhum fork, nenhum arquivo duplicado com uma versão “web” do solver.

O que não é de graça é a velocidade. Um passo do solver custa 6,1 ms no wasm contra 2,3 ms nativo, medido no grid de 360x200 que o app usa, num Mac M4, com o mesmo solver compilado para os dois alvos na mesma máquina. Fator 2,6.

Kutta, um pequeno túnel de vento em Go

crg@crg.eti.br (Cesar Gimenes) — Wed, 08 Jul 2026 00:30:00 -0300

Dá pra explicar sustentação com um diagrama e uma equação. Quase nunca gruda. Ver a esteira descolar da traseira de uma asa enquanto você gira o ângulo de ataque gruda na hora. É essa distância que faz o Kutta existir.

É um pequeno túnel de vento 2D escrito em Go, renderizado com Ebitengine, rodando como um único aplicativo desktop.

A ideia nunca passou do primeiro rascunho: escoar ar por um aerofólio e deixar o escoamento visível. Muda o ângulo de ataque e o campo reage. Alterna entre velocidade, vorticidade e um campo tipo pressão. Desenha sua própria forma. Corta uma asa em asa e flap, anima o flap, e vê a esteira ficar instável quando a geometria ou o ângulo passam do ponto.

Glaze, WebView desktop em Go sem CGO

crg@crg.eti.br (Cesar Gimenes) — Mon, 22 Jun 2026 10:15:00 -0300

Abrir uma janela com HTML em Go quase sempre cobra um pedágio em C.

Ou você liga o cgo e arrasta uma toolchain C pro projeto, ou alguém embute uma .dll/.so/.dylib compilada no binário e extrai em disco na primeira execução. Os dois funcionam. E os dois te tiram justamente o que eu gosto no ecossistema: o go build que cross-compila pra três sistemas sem pensar, o build reprodutível, o go install que roda pra quem clonou o repo. É a primeira coisa que vai embora quando o C entra.

singleflight em Go

crg@crg.eti.br (Cesar Gimenes) — Sat, 13 Jun 2026 09:57:41 -0300

Você tem uma função cara e pesada. Em um pico de tráfego chegam seis requisições ao mesmo tempo pedindo exatamente a mesma coisa. Sem nenhum cuidado, você executa esse função seis vezes para obter seis resultados idênticos.

singleflight é um padrão que colapsa essas chamadas. A primeira chamada para uma chave executa o trabalho de verdade. Todas as outras que chegam enquanto ela está em andamento ficam esperando e recebem o mesmo resultado. Uma execução, vários consumidores.

Text chunker com sobreposição para pipelines RAG

crg@crg.eti.br (Cesar Gimenes) — Sat, 06 Jun 2026 11:57:59 -0300

Em pipeline de RAG (Retrieval-Augmented Generation) o primeiro passo é quase sempre o mesmo: pegar um texto grande e quebrar em pedaços antes de vetorizar. Os pedaços não podem ser grandes demais, porque o modelo tem limite de contexto, nem pequenos demais, porque aí o embedding perde semântica. E precisam ter sobreposição entre vizinhos, senão uma resposta que cai bem na fronteira fica espremida entre dois chunks e o retriever erra.

Um cofre cifrado em Go

crg@crg.eti.br (Cesar Gimenes) — Sun, 31 May 2026 01:02:01 -0300

Vamos juntar as três peças anteriores:

Um banco SQLite que vive na RAM e, no disco existe apenas como um blob criptografado.

O banco roda em :memory:. Ao sair, tiramos o snapshot dos bytes do banco, criptografamos com a senha e gravamos. Ao entrar, lemos o blob, decriptamos com a senha e fazemos o deserialize de volta para a RAM.

Aqui a proteção dos dados depende da força da senha, e do algoritmo de criptografia (aqui, AES-GCM). Precisa tomar cuidado com o tamanho do banco porque fazer o dump, criptografar e gravar tudo de uma vez pode ser lento. Mas é muito bom para salvar dados sensíveis, como chaves de API, tokens, etc.

SQLite na RAM: serialize e deserialize em Go

crg@crg.eti.br (Cesar Gimenes) — Sun, 31 May 2026 00:46:31 -0300

O SQLite pode rodar inteiramente na memória, sem nunca tocar o disco. E tem um truque pouco conhecido: dá para tirar um snapshot dos bytes do próprio banco e recarregá-lo depois, sem INSERT, sem reconstruir nada. As funções são sqlite3_serialize e sqlite3_deserialize.

Vou usar o driver modernc.org/sqlite, que é Go puro, sem CGo.

db, err := sql.Open("sqlite", ":memory:")
if err != nil {
 fatal(err)
}
db.SetMaxOpenConns(1)

A pegadinha está no SetMaxOpenConns(1). Um banco :memory: pertence à conexão que o abriu. Sem limitar a uma conexão, o pool do database/sql poderia abrir outra e essa veria um banco vazio e diferente.

Criptografia at rest com a stdlib do Go

crg@crg.eti.br (Cesar Gimenes) — Sun, 31 May 2026 00:38:32 -0300

Quero guardar um dado no disco de forma que, mesmo que o arquivo vaze, ele só seja legível com a senha e que qualquer adulteração seja detectada.

Para isso vamos proteger os dados criptografando ele “at rest” o que basicamente significa que os dados estão protegidos quando são salvos no disco, e só podem ser acessados por quem tem a senha correta.

Dá para fazer isso só com a biblioteca padrão:

Capturando senhas no terminal com Go

crg@crg.eti.br (Cesar Gimenes) — Sat, 30 May 2026 10:00:00 -0300

Ler uma senha no terminal parece trivial, mas tem duas armadilhas: a senha aparece na tela se você usar a leitura comum, e você precisa garantir que é realmente um terminal e não redirecionamento. Vamos resolver as duas com o pacote golang.org/x/term.

Se você ler com bufio.Scanner ou fmt.Scanln, cada tecla aparece na tela. Para senha isso não serve. O term.ReadPassword lê direto do terminal, sem eco:

fd := int(os.Stdin.Fd()) // #nosec G115 -- stdin's fd is small; the conversion is safe
fmt.Print("password: ")
pass, err := term.ReadPassword(fd)
fmt.Println() // the user's Enter doesn't emit a newline; we do it

código fonte completo em

Neko, um gato perseguindo o mouse com Go e Ebitengine

crg@crg.eti.br (Cesar Gimenes) — Sat, 11 Apr 2026 09:15:00 -0300

Todo programador devia escrever ao menos um software inútil de propósito.

Inútil aqui no melhor sentido. Não serve para empresa nenhuma, não vai parar numa reunião de produto e não tem chance de algum gerente pedir integração com webhook. Mesmo assim obriga você a lidar com problemas reais. Tela, input, tempo, sprite, som, janela, sistema operacional. Um brinquedo desses ensina mais sobre software interativo do que muito CRUD com cara de demo corporativa.

trigger no SQLite

crg@crg.eti.br (Cesar Gimenes) — Fri, 03 Oct 2025 23:57:24 -0300

O SQLite não suporta stored procedure diretamente, mas suporta triggers o que é um recurso muito útil para automatizar algumas ações.

Por exemplo, atualizar automaticamente o campo updated_at.

CREATE TABLE users (
 id INTEGER PRIMARY KEY AUTOINCREMENT,
 nome TEXT,
 updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
);

CREATE TRIGGER update_timestamp
BEFORE UPDATE ON users
FOR EACH ROW
BEGIN
 UPDATE users SET updated_at = CURRENT_TIMESTAMP WHERE id = OLD.id;
END;

Agora, quando você atualizar um registro na tabela users, o campo updated_at será atualizado automaticamente para o timestamp atual.

Função recursiva em Go para acessar valores em mapas aninhados

crg@crg.eti.br (Cesar Gimenes) — Mon, 22 Sep 2025 17:33:43 -0300

Recentemente, recebi um retorno de uma API que continha um JSON com uma estrutura complexa, grande e aninhada. Eu precisava acessar um valor específico dentro dessa estrutura, mas o caminho para esse valor poderia variar.

A ideia então foi criar uma função recursiva que recebesse uma lista com o caminho (path) para o valor desejado e a estrutura de dados (um mapa aninhado) e retornasse o valor correspondente, se encontrado.

Subindo serviços com /etc/rc.local como nos anos 80

crg@crg.eti.br (Cesar Gimenes) — Sun, 20 Jul 2025 14:19:38 -0300

Costumo usar o script /etc/rc.local para subir serviços rapidamente durante o boot. É conveniente, simples e funciona bem no Debian e em outras distribuições Linux. Basicamente, é apenas um script sh (ou o shell que você preferir) que é executado durante o boot.

Curiosamente, o rc.local é considerado obsoleto desde o lançamento do UNIX System III, em 1983!

Desde então, diversas tentativas foram feitas para descontinuar esse arquivo. Ele não é recomendado há muito tempo em favor de soluções mais modernas para iniciar serviços durante o boot, mas ainda persiste. Se o arquivo /etc/rc.local não existir no seu sistema, tente criá-lo e dar permissão de execução. Existe uma boa chance de o systemd reconhecer que você é totalmente old school e executar o rc.local normalmente durante o boot, inclusive esperando educadamente a rede ser ativada antes de rodá-lo (testado no Debian e no Ubuntu).

sftpdav: Acesso Remoto via SSH com WebDAV

crg@crg.eti.br (Cesar Gimenes) — Sat, 15 Mar 2025 18:11:26 -0300

Recentemente, enfrentei um desafio ao tentar acessar arquivos de uma máquina que só permite conexão via SSH. Abrir portas adicionais ou instalar extensões de terceiros não eram opções viáveis por questões de segurança e compatibilidade, especialmente no macOS.

Foi assim que surgiu a ideia de criar o sftpdav, um programa que combina um cliente SFTP com um servidor WebDAV, permitindo acessar um diretório remoto via SSH e montá-lo localmente como se fosse um compartilhamento WebDAV.

Protegendo credenciais e configurações com contêiner criptografado.

crg@crg.eti.br (Cesar Gimenes) — Thu, 20 Feb 2025 22:43:56 -0300

Eu uso um pequeno computador de bolso na mochila. Esse dispositivo serve para testes e desenvolvimento, e armazena informações sensíveis como credenciais, senhas e chaves de acesso. Eu não quero que esses dados caiam em mãos erradas. Diferentemente do notebook, que tem o HD criptografado, meu computador de bolso não usa criptografia no HD. A criptografia consome muito processamento e requer desativar o TRIM do SSD, o que prejudica o desempenho.

LQS: Uma Ferramenta Prática para Testar e Debugar SQL

crg@crg.eti.br (Cesar Gimenes) — Sat, 15 Feb 2025 18:31:26 -0300

É muito comum precisarmos inserir strings com código SQL no fonte de outras linguagens, o problema desse SQL é uma linguagem interpretada e portanto só pode conter erros que só vamos perceber em tempo de execução.

Testando SQL

O LQS foi criado para trabalhar junto com o Neovim e permitir testar o SQL durante a edição, sem copiar e colar para outro arquivo ou cliente SQL.

Testar SQL com metadados embutidos: Insira configurações direto no seu script SQL, como a string de conexão, opção de saída em JSON, ou até mesmo uma query extra para gerar parâmetros. Exemplo:

Ordenando e removendo linhas duplicadas com Neovim

crg@crg.eti.br (Cesar Gimenes) — Sun, 09 Feb 2025 14:32:33 -0300

Uma boa organização facilita a leitura do código. Listas desorganizadas dificultam a manutenção do projeto, sem falar que o código fica com um aspecto pouco profissional.

Estas duas funções ordenam e removem linhas duplicadas em blocos de texto selecionados no Neovim.

A função sort_lines ordena as linhas selecionadas:

function sort_lines()
 local start_pos = vim.fn.getpos("'<")
 local end_pos = vim.fn.getpos("'>")
 local start_line = start_pos[2] - 1
 local end_line = end_pos[2]
 local lines = vim.api.nvim_buf_get_lines(
 0,
 start_line,
 end_line,
 false
 )

 table.sort(lines)

 vim.api.nvim_buf_set_lines(
 0,
 start_line,
 end_line,
 false,
 lines
 )
end

A função sort_and_uniq_lines ordena e remove linhas duplicadas:

Bookmarks em Neovim

crg@crg.eti.br (Cesar Gimenes) — Sun, 09 Feb 2025 11:52:14 -0300

Eu percorro muitos arquivos quando trabalho, principalmente ao resolver bugs ou rastrear comportamentos. Eu criei um sistema de marcadores (bookmarks) no Neovim para navegar mais rápido entre arquivos. Esse sistema difere do sistema padrão do Neovim, pois foca em marcar arquivos e linhas, não apenas posições dentro do mesmo arquivo.

Funcionamento

O sistema registra o caminho do arquivo e a linha atual em um arquivo texto. Eu uso a tecla <leader>o para abrir todos os arquivos marcados. Eu uso a tecla <leader>m para marcar um arquivo. Eu também uso o comando :Clearmarks para limpar todos os marcadores quando termino um trabalho ou inicio outro.

GoScope Explorando e Navegando em Projetos Go

crg@crg.eti.br (Cesar Gimenes) — Sun, 09 Feb 2025 02:47:39 -0300

Muitas vezes, quero analisar rapidamente um projeto Go para entender onde funções, variáveis e tipos estão definidos ou chamados. Foi assim que criei duas ferramentas de linha de comando: GoScope e rgs. A primeira faz um escaneamento completo de todos os arquivos .go de um projeto, gerando uma lista de definições e chamadas de funções. A segunda usa essa lista para me permitir navegar de forma interativa até o ponto exato do código.

Executando Comandos Remotos de Forma Interativa com SSH

crg@crg.eti.br (Cesar Gimenes) — Sat, 08 Feb 2025 13:38:17 -0300

Muitas vezes, eu preciso executar um comando em um servidor remoto, mas não desejo iniciar uma sessão interativa completa. Quero que o programa mantenha todas as características de um processo local, porém seja executado no servidor remoto.

Inicialmente, eu apenas usava o comando ssh especificando o servidor e o comando que desejo executar:

ssh servidor comando

Esse método não funciona bem para programas que exigem um pseudo terminal, como o Neovim. Para resolver isso, eu tentei a opção -t para forçar a alocação de um pseudo terminal. Assim, programas como o ls exibem cores, mas o ambiente de usuário não é carregado. Nesse caso, eu preciso usar a opção --color no ls. Mesmo assim, programas como o Neovim falham porque o shell não se comporta como interativo e códigos ANSI não são processados corretamente.

Traceback em Go: Como Explorar a Pilha de Execução

crg@crg.eti.br (Cesar Gimenes) — Thu, 06 Feb 2025 02:12:46 -0300

Muitas linguagens de programação fornecem algum tipo de “stack trace” ou “backtrace”. Python usa o módulo traceback, C no Linux oferece a função backtrace() em execinfo.h (não faz parte do padrão do C) e Java inclui Thread.dumpStack() ou e.printStackTrace() para exceções.

Stack Trace em Go

O Go fornece a função runtime.Caller para obter informações sobre a pilha de execução. O exemplo a seguir exibe o arquivo, a linha e a função que chamaram info(). Observe que o argumento 1 passado para runtime.Caller indica que queremos informações sobre a função que chamou info():

Transmissão de Dados Usando Som: Uma Experiência com 'Telefone de Copos'

crg@crg.eti.br (Cesar Gimenes) — Sat, 25 Jan 2025 21:58:10 -0300

Quando comecei a brincar com computadores, a única forma de carregar um programa na máquina era digitando-o do zero. Meu computador antigo não tinha armazenamento; não havia HD, disquete ou qualquer outro meio de armazenar dados. Ao iniciar, a máquina carregava o BASIC diretamente da ROM e pronto. Com o tempo, consegui um gravador de fita, mas ele era terrível. Sem dinheiro para um gravador específico para computadores, usei um gravador doméstico. Demorou bastante ajustando o volume e outros parâmetros até conseguir carregar algo. O equipamento era tão delicado que prendi os controles com fita adesiva para evitar alterações porque qualquer coisa impedia o carregamento.

Compilação Estática do Interpretador Lua: Garantia de Consistência e Portabilidade

crg@crg.eti.br (Cesar Gimenes) — Sun, 19 Jan 2025 11:21:08 -0300

A linguagem Lua é minha favorita para desenvolver pequenos scripts e configurações. Ela é fácil de incluir em outros projetos e possui uma sintaxe limpa e simples. É fácil de estender e uma ótima linguagem para configurar sistemas.

Recentemente, iniciei um projeto que requer que o interpretador Lua esteja instalado. Isso normalmente não é um problema. Porém, para garantir total controle, decidi compilar minha própria versão do interpretador de forma estática. Isso assegura que diferenças na versão da libc ou em outras bibliotecas não interfiram no funcionamento do meu sistema. Já enfrentei muitos problemas com sistemas que não carregavam devido a versões diferentes da glibc. Além dos motivos práticos, acredito que todo software deve ser compilado estaticamente. O ganho de memória e a facilidade de atualização da compilação dinâmica não compensam os problemas que podem surgir.

Como Encontrar Caminhos de Programas no Sistema com exec.LookPath em Go

crg@crg.eti.br (Cesar Gimenes) — Sat, 18 Jan 2025 22:58:48 -0300

Comecei um novo projeto que precisa verificar se alguns programas estão instalados no sistema e obter seus caminhos completos. Para isso, utilizei a função exec.LookPath do pacote os/exec.

A função exec.LookPath busca um executável nos diretórios listados na variável de ambiente PATH. Se não encontrar, retorna um erro. Portanto, criei a função programPath que recebe o nome do programa e retorna o caminho do executável e um booleano indicando se o programa foi encontrado.

Otimizando a Verificação de Integridade de Mensagens com FNV-1a em Go

crg@crg.eti.br (Cesar Gimenes) — Sat, 18 Jan 2025 00:43:18 -0300

Vimos no artigo HMAC (Hash-based Message Authentication Code) como essa técnica garante que a mensagem não foi alterada durante o transporte e confirma a validade da assinatura.

No entanto, esse processo, embora seguro, é lento e consome muitos recursos. Quando precisamos apenas verificar a integridade da mensagem sem validar uma assinatura, podemos usar uma função de hash mais rápida. Para isso, utilizaremos o algoritmo FNV-1a (Fowler-Noll-Vo), conhecido por sua rapidez e baixa taxa de colisão.

mTLS: Implementando Autenticação Mútua entre Cliente e Servidor em Go

crg@crg.eti.br (Cesar Gimenes) — Sat, 11 Jan 2025 19:49:40 -0300

mTLS (Mutual TLS) autentica mutuamente cliente e servidor. Ambos apresentam certificados digitais assinados por uma autoridade certificadora confiável. Controlando a emissão dos certificados, você garante que apenas clientes autorizados acessem seu serviço. Além disso, identifica facilmente o cliente sem precisar de uma API Key ou Token. Também recomendo usar um cabeçalho HMAC (Hash-based Message Authentication Code) como camada adicional de segurança e integridade da mensagem.

Criando Certificados

Neste exemplo, criarei os certificados de forma simples para testes locais. Ao implementar em produção, tome cuidado com os parâmetros utilizados. É importante incluir Subject Alternative Names (SANs), pois apenas o CN (Common Name) não é mais recomendado.

HMAC (Hash-based Message Authentication Code) em Golang

crg@crg.eti.br (Cesar Gimenes) — Fri, 10 Jan 2025 23:33:11 -0300

Quando criamos APIs, é recomendável adicionar um cabeçalho de autenticação para garantir a integridade das mensagens. Por exemplo, quando seu servidor envia uma requisição ou um webhook, inclua um cabeçalho X-Signature com uma assinatura HMAC (Hash-based Message Authentication Code).

Para gerar a assinatura HMAC, você utiliza uma chave secreta e o conteúdo a ser assinado, como o body da requisição. E envia a assinatura no cabeçalho. É importante deixar claro o que está sendo assinado. Já enfrentei problemas com clientes que não conseguiam validar a assinatura porque usavam o body parseado como JSON em vez do body raw recebido na requisição.

Validação e Integração Segura de JSON em APIs Go com json.RawMessage

crg@crg.eti.br (Cesar Gimenes) — Thu, 09 Jan 2025 00:28:29 -0300

Recentemente, desenvolvi uma API onde o usuário envia um JSON em um dos campos. O requisito é registrar erros de JSON inválido nos logs, mas permitir que os demais dados continuem o fluxo normal do sistema.

Também era importante que, se o JSON recebido fosse válido, ele fosse integrado perfeitamente nas respostas da API. Como o JSON poderia variar e eu não conhecia sua estrutura, utilizei json.RawMessage no tipo do campo. Assim, ao usar a função json.Marshal, os dados são corretamente incorporados ao JSON principal.

Fork bomb: Do Código à Defesa

crg@crg.eti.br (Cesar Gimenes) — Sat, 04 Jan 2025 11:48:47 -0300

A primeira vez que ouvi falar de fork bomb foi há bastante tempo. Embora achasse fascinante um código que gera outros dois processos de si mesmo, causando crescimento exponencial de processos e eventualmente travando o sistema, eu não acreditava que fosse um ataque viável até descobrir quantos sistemas são vulneráveis à injeção de código.

O que é um fork bomb?

Em linhas gerais, um fork bomb é um código que gera processos recursivamente. O primeiro processo gera cópias de si mesmo, e essas cópias geram mais cópias, e assim por diante, até que o sistema fique sem recursos e trave. O resultado é um ataque DoS (Denial of Service).

Manipulando bits de permissão especiais

crg@crg.eti.br (Cesar Gimenes) — Sat, 04 Jan 2025 00:36:51 -0300

No artigo sobre Redução de Privilégios em Programas, utilizamos o comando sudo para executar um programa com privilégios de superusuário. No entanto, é possível realizar essa ação sem usar um comando externo.

Para isso, usamos permissões especiais de arquivos conhecidas como bit setuid e bit setgid. Esses atributos permitem que arquivos sejam executados com os privilégios do usuário ou do grupo proprietário.

Para ajustar os bits setuid e setgid, utilizamos o comando chmod com as opções u+s e g+s, respectivamente.

Redução de Privilégios em Programas Go para Aumentar a Segurança

crg@crg.eti.br (Cesar Gimenes) — Thu, 02 Jan 2025 22:43:45 -0300

Uma boa prática para aumentar a segurança de um sistema é reduzir os privilégios de execução de um programa. Idealmente, um programa deve rodar com o mínimo de privilégios possíveis.

Em sistemas UNIX-like, é possível alterar o usuário e o grupo em que um programa é executado. Vamos ver um passo a passo de como fazer isso em Golang.

Verificando se o Programa está Rodando como Root

Primeiro, verifique se o programa está sendo executado como root. Isso é importante porque usaremos chamadas de sistema que necessitam de privilégios de root. (Existem outras maneiras de conceder esses privilégios, mas abordaremos isso em outro artigo.)

Referências nos comentários com Golang

crg@crg.eti.br (Cesar Gimenes) — Wed, 01 Jan 2025 13:28:17 -0300

Uma dica rápida sobre comentários em Go é incluir referências neles. Coloque o elemento que deseja referenciar entre colchetes ([ e ]), funciona com tudo que pode ser referenciado, como variáveis, constantes, funções, etc.

Veja o exemplo:

package main

import (
 "fmt"
 "time"
)

// pi representa a constante matemática Pi
const pi = 3.14159

// CalcularArea calcula a área de um círculo dado o raio.
// Utiliza a constante [pi] para o cálculo.
func CalcularArea(raio float64) float64 {
 return pi * raio * raio
}

func main() {
 raio := 5.0
 area := CalcularArea(raio)
 fmt.Printf(
 "A área do círculo com raio %.2f é %.2f\n",
 raio,
 area,
 )

 /*
 Formatos úteis:
 [time.DateTime]
 [time.Kitchen]
 [time.RFC3339Nano]
 [time.RFC3339]
 */
 fmt.Println(time.Now().Format(time.DateTime))
}

No Neovim, coloque o cursor entre os colchetes e pressione Ctrl-] para ir até a definição do elemento referenciado. Para voltar, pressione Ctrl-t. No VSCode, use a extensão Go to Definition para realizar a mesma ação.

Efeito plasma no terminal com Golang

crg@crg.eti.br (Cesar Gimenes) — Tue, 31 Dec 2024 17:34:13 -0300

Um dos programas que sempre achei interessantes são as demos com efeitos gráficos atrativos e códigos que extraem cada grama de performance da máquina. O efeito plasma é um dos que considero mais legais, simulando um fluido em movimento.

Para criar o efeito plasma, utilizo várias funções trigonométricas para calcular a cor de fundo de cada caractere e passo o tempo para gerar a animação. O código é relativamente simples, mas a otimização é um pouco mais complexa.

Feliz 2025, fogos de artifício no terminal com Golang

crg@crg.eti.br (Cesar Gimenes) — Tue, 31 Dec 2024 13:09:42 -0300

Um pequeno programa comemora a chegada de 2025 com fogos de artifício no terminal. Com vários truques interessantes para você iniciar o ano com muito código.

Usamos os.Stdout.WriteString para escrever diretamente no descritor do stdout, ou seja, na saída padrão do terminal. Essa é a forma mais rápida de escrever no terminal, mas não é sincronizada. Isso significa que não há garantia de que a saída será escrita na ordem esperada. Mas no nosso caso isso é desejável porque permite que os fogos de artifício se sobreponham, dando a impressão de que estão explodindo simultaneamente.

Reescrevendo o velho TSR usando Bash

crg@crg.eti.br (Cesar Gimenes) — Sat, 21 Dec 2024 17:26:25 -0300

Quando comecei a programar, a computação era diferente de hoje. O sistema operacional era mono-tarefa; apenas um programa podia ser executado por vez. Não havia recursos modernos, como memória protegida e mapeada. Mesmo assim, era possível criar comportamentos concorrentes nos programas, mas era preciso cuidado para evitar que alguma parte bloqueasse o processamento. Por exemplo, não podia haver loops esperando entrada do teclado ou processos muito longos. Criar um programa sem bloqueios era complicado em linguagens como Clipper.

Subindo uma API via proxy reverso com Caddyserver e Go

crg@crg.eti.br (Cesar Gimenes) — Fri, 20 Dec 2024 01:34:17 -0300

Um amigo pediu um exemplo de como subir uma API usando proxy reverso com a linguagem Go. A seguir, apresento um pequeno roteiro.

Primeiro, suba um servidor e registre seu IP no provedor de DNS. Atribua o IP a um nome para criar um certificado HTTPS para a máquina.

Configure o firewall da máquina e abra apenas as portas 22 (SSH), 80 (HTTP) e 443 (HTTPS).

Caddy

Eu uso o servidor HTTP Caddy. Ele é prático e cria certificados HTTPS automaticamente. Por padrão, redireciona as requisições HTTP para HTTPS.

Benchmark Retornos Nomeados vs Explicitos em Go

crg@crg.eti.br (Cesar Gimenes) — Tue, 17 Dec 2024 03:00:24 -0300

No nosso grupo de estudos de Go, surgiu uma dúvida: retornos nomeados são mais rápidos que retornos explícitos? A hipótese é essa.

Felizmente, Go tem boas ferramentas para testar isso.

Vamos criar um código com duas funções de soma: uma com retornos nomeados e outra com retornos explícitos.

package main

import (
 "testing"
)

// Função com retornos nomeados
func somaNomeados(a, b int) (resultado int, err error) {
 resultado = a + b
 return
}

// Função com retornos explícitos
func somaExplicitos(a, b int) (int, error) {
 return a + b, nil
}

Depois, criamos as funções de benchmark. O nome dessas funções é importante. A ferramenta de testes do Go procura funções que começam com “Benchmark”.

Escrevendo Sobre Programação de Computadores

crg@crg.eti.br (Cesar Gimenes) — Sun, 15 Dec 2024 17:29:11 -0300

Escrever sobre programação e informática é desafiador. Esses temas são complexos e é difícil criar uma narrativa compreensível e interessante.

Além disso, o português é um idioma exigente. Tenho a tendência de escrever como falo, o que resulta em textos difíceis de ler.

Para facilitar, criei algumas regras que servem como guia. Elas não são rígidas, apenas orientações sem uma ordem específica.

Seja direto ao ponto. Evite floreios desnecessários e vá direto ao assunto.

Personalizando o Neovim: Ordenação e Remoção de Linhas Duplicadas com Lua

crg@crg.eti.br (Cesar Gimenes) — Fri, 29 Nov 2024 00:31:30 -0300

Continuando as personalizações do Neovim, apresento duas funções que uso frequentemente: sort_lines e sort_and_uniq_lines. Como o nome sugere, elas ordenam o conteúdo das linhas selecionadas e, no caso de sort_and_uniq_lines, também eliminam duplicatas.

function sort_lines()
 -- Obter a posição inicial e final da seleção
 local start_pos = vim.fn.getpos("'<")
 local end_pos = vim.fn.getpos("'>")

 -- Converter a posição para o índice da linha

 -- Ajuste start_pos porque as linhas no Lua começam do 0
 local start_line = start_pos[2] - 1
 -- Não precisa ajustar end_line
 local end_line = end_pos[2]

 -- Obter as linhas selecionadas
 local lines = vim.api.nvim_buf_get_lines(
 0,
 start_line,
 end_line,
 false
 )

 -- Ordenar as linhas
 table.sort(lines)

 -- Substituir as linhas originais
 vim.api.nvim_buf_set_lines(
 0,
 start_line,
 end_line,
 false,
 lines
 )
end

function sort_and_uniq_lines()
 local start_pos = vim.fn.getpos("'<")
 local end_pos = vim.fn.getpos("'>")

 local start_line = start_pos[2] - 1
 local end_line = end_pos[2]

 local lines = vim.api.nvim_buf_get_lines(
 0,
 start_line,
 end_line,
 false
 )

 table.sort(lines)

 -- Remover linhas duplicadas
 local uniq_lines = {}
 local last_line = nil
 for _, line in ipairs(lines) do
 if line ~= last_line then
 table.insert(uniq_lines, line)
 last_line = line
 end
 end

 vim.api.nvim_buf_set_lines(
 0,
 start_line,
 end_line,
 false,
 uniq_lines
 )
end

vim.api.nvim_set_keymap(
 'v',
 '<Leader>s',
 ':lua sort_lines()<CR>',
 { noremap = true, silent = true }
)
vim.api.nvim_set_keymap(
 'v',
 '<Leader>u',
 ':lua sort_and_uniq_lines()<CR>',
 { noremap = true, silent = true }
)

sort_lines.lua

Criando um Sistema de Bookmarks no Neovim com Lua

crg@crg.eti.br (Cesar Gimenes) — Mon, 25 Nov 2024 00:25:27 -0300

Continuando nossa série de artigos que visam diminuir o esforço cognitivo em tarefas de programação, apresento meu pequeno script de bookmarks para o Neovim.

O Neovim é incrivelmente personalizável. Sem a necessidade de criar plugins completos, você pode, com algumas funções Lua, adicionar muitas funcionalidades.

No meu dia a dia, frequentemente preciso retornar aos mesmos arquivos para corrigir e testar problemas. Abrir esses arquivos diretamente na linha correta, sem perder tempo navegando, é essencial.

Script para rápida navegação em diretórios usando fzf

crg@crg.eti.br (Cesar Gimenes) — Sun, 24 Nov 2024 15:43:50 -0300

Este artigo apresenta um script para tornar a navegação em diretórios mais rápida, continuando a série sobre redução da complexidade cognitiva.

Frequentemente, é necessário navegar entre vários diretórios de um ou múltiplos projetos. Lembrar os caminhos e localizar arquivos torna-se um esforço desnecessário.

Uma solução é manter uma lista dos últimos diretórios acessados para alternar rapidamente entre eles. Dave Eddy implementou essa ideia em seu cdstack.

Inspirado nessa abordagem, criei minha versão mais adequada ao meu modo de trabalho.

Diminuindo a Complexidade Cognitiva na Programação

crg@crg.eti.br (Cesar Gimenes) — Sat, 23 Nov 2024 21:28:27 -0300

Eu dedico muito tempo e esforço para diminuir a complexidade cognitiva ao programar.

Complexidade cognitiva é o quanto se precisa pensar para realizar uma tarefa. Pequenos detalhes podem tornar uma tarefa desnecessariamente complexa.

Por exemplo, encontrar um trecho de código escondido em muitos arquivos dentro de uma grande estrutura de diretórios exige esforço. Mesmo que a estrutura seja familiar e bem projetada, o objetivo não é navegar por ela abrindo arquivos até encontrar o código para editar; o objetivo é apenas editar o código. Qualquer coisa além disso é esforço cognitivo desperdiçado.

Reestruturando artigos para clareza e concisão

crg@crg.eti.br (Cesar Gimenes) — Sat, 23 Nov 2024 19:53:57 -0300

Estou reestruturando a forma dos artigos neste site.

Geralmente escrevo como falo, o que algumas pessoas acham agradável. No entanto, minha relação de amor e ódio com a língua portuguesa às vezes torna meus textos difíceis de entender. Também costumo me alongar demais ao explicar motivos e conceitos, deixando o texto maçante.

Como exercício de escrita, estou revisando meus textos. Corrigindo problemas de ortografia e gramática e tornando o conteúdo mais direto.

Virus no laboratório

crg@crg.eti.br (Cesar Gimenes) — Fri, 25 Oct 2024 22:43:08 -0300

Essa história é lá da primeira metade dos anos 2000, na época eu trabalhava em uma empresa que criava hardware para telefonia.

Era bem interessante, tive acesso a algumas maquinas NEC legais e escrevi alguns códigos bem interessantes.

Foi nessa época que eu escrevi um gravador para VoIP capturando diretamente os pacotes SIP da rede, menos de 100 linhas de código C, mas isso é história para outro dia.

Um dia um cliente ligou reclamando que o sistema dele estava muito lento, era um cliente grande, um laboratório farmacêutico aqui de São Paulo.

Programação como Arte

crg@crg.eti.br (Cesar Gimenes) — Sun, 29 Sep 2024 16:24:25 -0300

Considero programar computadores uma forma de expressão artística. Existem muitas maneiras de resolver problemas do dia a dia da programação, deixando muito espaço para criatividade.

Exemplos Clássicos de Arte Generativa

E existem muitos exemplos interessantes de arte gerada por computador. Os meus favoritos são os “one-liners”, programas de apenas uma linha que fazem coisas interessantes, como o famoso 10 PRINT CHR$ (205.5 + RND (1)); : GOTO 10 que desenha um labirinto usando BASIC, e o equivalente mais moderno yes yes 'c=(╱ ╲);printf ${c[RANDOM%2]}'|bash criado usando Bash. Uma rápida procura na internet vai trazer várias implementações em linguagens diferentes.

Arte generativa em JavaScript para as laterais do site

crg@crg.eti.br (Cesar Gimenes) — Sun, 25 Aug 2024 18:35:45 -0300

Após bastante tempo, finalmente inclui um JavaScript neste site.

Eu tenho um bloqueio enorme com relação ao uso de tecnologias para web, JavaScript, CSS e o próprio HTML parecem muito improvisadas para mim, principalmente a ideia de “single page application”.

Essa é uma limitação que eu tenho que superar. Mesmo porque, hoje em dia, a web é de fato a melhor e mais portável interface para a maioria dos programas. Apesar de ir contra muita coisa que acredito sobre minimalismo e economia de recursos.

Computação pós-apocalíptica

crg@crg.eti.br (Cesar Gimenes) — Sat, 13 Jul 2024 18:17:36 -0300

Computação pós-apocalíptica é uma brincadeira, um exercício interessante para sua imaginação. O cenário é o seguinte, aconteceu algo terrível e a sociedade em que você vive não existe mais. Como sobrevivente, cabe a você ajudar a reconstruir a sociedade moderna.

O motivo do apocalipse pode ser o que você preferir, guerra nuclear, praga, colapso econômico, tempestade solar, governo opressor que quer manter a tecnologia apenas para si, etc., a única constante é que nada que você tem como garantido está disponível. Toda a infraestrutura se foi, não temos mais água encanada, eletricidade, nem nenhuma das amenidades da vida moderna.

Criando o próprio sistema para contar o tempo

crg@crg.eti.br (Cesar Gimenes) — Thu, 16 May 2024 11:39:44 -0300

Medir o tempo é uma tarefa séria e mais complicada do que parece. Como bom nerd, sou fascinado pelos vários métodos de medir e contar o tempo. Um dos que mais me chama a atenção é o “tempo decimal”.

Existem várias implementações de tempo decimal, dividindo geralmente o dia em 10 horas de 100 minutos cada. Outra abordagem é ignorar as horas e usar apenas os minutos como um número contínuo. Se precisar de mais precisão, basta usar frações desse minuto, quantas casas decimais forem necessárias.

Deploy de aplicação usando curl

crg@crg.eti.br (Cesar Gimenes) — Sat, 09 Mar 2024 11:45:51 -0300

Existem vários desafios para pequenas equipes distribuírem binários atualmente. Se você simplesmente colocar um aplicativo para download em um site, imediatamente as ferramentas de busca vão marcar seu site como conteúdo suspeito. Os navegadores colocam um aviso assustador para o usuário e não existe como remover esse aviso, mesmo com o binário assinado. O aviso só é removido se houver usuários suficientes fazendo download do seu binário sem reportar problemas.

ps - hierarquia de processos

crg@crg.eti.br (Cesar Gimenes) — Sun, 11 Feb 2024 14:13:47 -0300

Quando comecei a usar o compterm um problema logo apareceu, às vezes eu esquecia que o compterm estava carregado. Daí a criei uma pequena função para detectar se eu estava em uma sessão carregada pelo compterm ou se era apenas uma sessão normal do zsh.

function is_parent_compterm {
 local pid=$$
 local parent_pid

 while [ "$pid" -ne 1 ]; do
 parent_pid=$(ps -p $pid -o ppid=)
 parent_pid=${parent_pid//[[:blank:]]/} # Remove espaços

 # Verifica se o nome do comando do processo pai é 'compterm'
 if ps -p $parent_pid -o comm= | grep -q "^compterm$"; then
 return 0 # Retorna true se encontrar 'compterm'
 fi

 pid=$parent_pid
 done

 return 1 # Retorna false se 'compterm' não for encontrado
}

Essa função verifica todos os processos parents do processo atual e se o nome de algum deles for compterm retorna true. Com isso consigo personalizar o prompt e assim sei se o compterm está carregado ou não.

Estudando Assembly

crg@crg.eti.br (Cesar Gimenes) — Sat, 22 Jul 2023 10:47:36 -0300

Quando eu comecei a programar, na era do 8bits, aprender um pouco de assembly era inevitável, as maquinas eram muito mais simples que os computadores atuais e geralmente nem mesmo tínhamos um compilador a mão, no lugar digitávamos pequenos trechos de opcodes diretamente em hexadecimal.

Isso era incrivelmente útil para contornar limitações do BASIC que servia tanto como linguagem de programação como sistema operacional. (diretamente gravado na ROM da máquina)

Arquivos ocultos no UNIX

crg@crg.eti.br (Cesar Gimenes) — Mon, 15 May 2023 06:21:48 -0300

Todos sabem como criar arquivos ocultos no mundo UNIX/Linux, basta que o nome do arquivo inicie com um ponto (.), mas esse recurso nem sempre existiu.

De acordo com Rob Pike em um post no Google+ que agora só está disponível em archive.org, lá pela versão 2 do UNIX, enquanto o design do sistema de arquivos Unix estava sendo trabalhado, surgiram as entradas “.” e “..” para facilitar a navegação em diretórios. Provavelmente isso aconteceu na versão 2 quando o sistema de arquivos se tornou hierárquico.

Por que meu site é tão feio?

crg@crg.eti.br (Cesar Gimenes) — Sun, 23 Apr 2023 10:29:39 -0300

Atualização

Recentemente fui convencido a experimentar um tema mais atual, então estou experimentando um novo tema, mas mantendo a mesma filosofia de acessibilidade e simplicidade. E para variar um tema claro. Além disso, adicionei algum JavaScript, por mais incrível que seja.

Tem sempre alguém perguntando o motivo do meu site ser tão feio, isso já rendeu boas risadas e geralmente serve de gancho para boas conversas. Mas, como já fui perguntado sobre isso várias vezes, é bom deixar uma resposta registrada para quem não tem tanta intimidade (ou falta de vergonha) para me perguntar isso.

Programação assistida por IA

crg@crg.eti.br (Cesar Gimenes) — Sat, 22 Apr 2023 09:33:12 -0300

Recentemente tivemos uma explosão no uso de inteligência artificial (IA) com produtos como o ChatGPT, Github Copilot, Tabnine, e tantos outros. São ferramentas muito úteis e interessantes, mas não é tanto quanto a mídia diz.

Pense nessas ferramentas como uma maquina que prevê qual a próxima palavra é a mais adequada e a coloca na sugestão e faz isso repetidamente em loop até atingir um número de palavras ou até a probabilidade de acerto cair abaixo de um valor aceitável, o que vier primeiro.

Escrevendo software para durar

crg@crg.eti.br (Cesar Gimenes) — Fri, 21 Apr 2023 16:28:48 -0300

Aqui apresentarei alguns tópicos que acredito serem importantes na hora de desenvolver um software de forma que ele seja bastante resiliente e que dure por vários anos. Os tópicos não estão em uma ordem particular e são a minha opinião embasada pela minha experiência como desenvolvedor.

Encare esse texto como um conjunto de ideias que coletei pelos anos, eu tentei deixar elas o mais genéricas possível, mas não tenho a pretensão de que elas se apliquem a qualquer cenário. Acredito que elas se encaixam melhor se sua equipe é pequena e você precisa entregar rápido.

Go e a promessa de retrocompatibilidade

crg@crg.eti.br (Cesar Gimenes) — Wed, 12 Apr 2023 09:24:13 -0300

Quando a versão 1.0 da linguagem Go foi lançada, os desenvolvedores assumiram um compromisso de manter retrocompatibilidade conforme novas versões fossem surgindo.

Esse compromisso traz vários resultados interessantes, por exemplo, o código que você aprender não fica desatualizado, além disso, manter a retrocompatibilidade da linguagem reforça outro compromisso importante, o que se refere a simplicidade e legibilidade do código. Aquele projeto que ficou esperando por meses, talvez anos continua compilando de primeira, eu experimentei isso pessoalmente com código que ficou na gaveta por três anos.

Go e erros de arredondamento

crg@crg.eti.br (Cesar Gimenes) — Wed, 12 Apr 2023 09:24:13 -0300

Quando criamos programas que vão lidar com dinheiro o ideal é sempre usar centavos, assim podemos ter variáveis do tipo inteiro e é bem mais simples prevenir erros causados pela forma como computadores armazenam números de ponto flutuante.

Mas nem sempre podemos escolher, quando consumimos APIs de terceiros, por exemplo, nem sempre as melhores praticas são observadas. Aliás, no dia a dia trabalhando condições ideais são uma raridade.

A pouco tempo passei por um problema como esse, uma API que meu sistema precisava consumir retornava um JSON e o campo com o valor além de ser string era também ponto flutuante.

CPBR14, Wardriving

crg@crg.eti.br (Cesar Gimenes) — Tue, 08 Nov 2022 08:55:30 -0300

Links úteis para o workshop “Wardriving - Breve introdução, equipamentos e softwares” para a Campus Party Brasil 2022.

Cesar Gimenes

GPS do celular na Raspberry Pi

crg@crg.eti.br (Cesar Gimenes) — Thu, 08 Sep 2022 01:46:48 -0300

Eu preciso que a Raspberry Pi que levo na mochila tenha acesso a coordenadas GPS, mas os GPS USB e outros modelos disponíveis para a Raspberry são muito ruins e caros.

A solução é usar o GPS do celular e compartilhar os dados com o resto do equipamento, isso tem várias vantagens, o GPS do celular é ótimo, geralmente ele já encontrou alguns satélites e, além disso, já tenho ele no celular evitando que eu tenha que fazer mais uma compra.

tr - Utilitário para substituição de caracteres

crg@crg.eti.br (Cesar Gimenes) — Sun, 28 Aug 2022 18:42:40 -0300

Este é um utilitário simples e muito útil, basicamente o tr filtra strings um carácter por vez e se usado corretamente é inclusive compatível com UTF-8.

O filtro dos caracteres é definido pelos parâmetros e para facilitar você pode usar classes de caracteres, por exemplo, [:upper:] para todas as letras maiúsculas ou [:cntrl:] para todos os caracteres de controle.

Parâmetros

Os parâmetros que mais uso são os seguintes:

-d delete para excluir caracteres.
-s squeeze que é bem interessante para excluir sequencias de caracteres duplicados.

Exemplos

Converte maiúsculo para minusculo, mas falha com caracteres UTF-8.

fmt - Utilitário simples para formatação de textos

crg@crg.eti.br (Cesar Gimenes) — Tue, 23 Aug 2022 01:04:14 -0300

O utilitário fmt é um formatador de texto simples e rápido. Seu objetivo é formatar arquivos texto ou strings via stdin para não ultrapassar o tamanho máximo de caracteres por linha definido pelo usuário.

Inicialmente foi pensado para seu usado em conjunto com o utilitário mail, mas pode ser útil em conjunto com outros programas como vim, por exemplo.

Principais parâmetros são:

-w que indica o número de caracteres desejado pro linha.
-t que indica o tamanho da tabulação.

Existem vários outros parâmetros úteis, consulte a manpage do seu sistema para saber mais.

Cliente e servidor socket em Golang, um exemplo de chat.

crg@crg.eti.br (Cesar Gimenes) — Sun, 21 Aug 2022 09:35:32 -0300

Esta é a quarta versão do nosso cliente e servidor socket. Nessa versão, fiz algumas melhorias interessantes. Agora, temos um sistema de chat completo com comandos úteis e algumas otimizações.

O objetivo desta versão é aprimorar o sistema. Removi um dos canais de escrita para enviar os dados diretamente, aumentando a eficiência. Também eliminei a reconexão automática para deixar o código mais limpo, já que adicionei várias novidades.

Servidor

Vamos às mudanças no servidor.

Assembly no macOS M1/ARM64.

crg@crg.eti.br (Cesar Gimenes) — Sun, 14 Aug 2022 11:26:49 -0300

A história é a seguinte, eu tinha encontrado uma ótima oferta de dois computadores do início dos anos 90 ainda usando processadores Zilog Z80, não estavam perfeitos, mas o valor estava ok.

Daí, um grande amigo, com muito mais bom senso, aconselhou que eu parasse de gastar energia e dinheiro com máquina velha e sugeriu que para aplacar essa febre de nerdisse eu estudasse assembly do ARM, que pelo menos pode ser útil.

Cliente e servidor socket em Golang com tratamento de sinais.

crg@crg.eti.br (Cesar Gimenes) — Fri, 12 Aug 2022 00:30:22 -0300

Continuando nossa série de artigos sobre cliente/servidor, adicionaremos um novo canal no exemplo anterior. Esse canal tratará sinais enviados pelo sistema operacional.

O sistema operacional envia sinais aos programas para gerenciar processos. Por exemplo, ao pressionar Ctrl+C, o sistema operacional envia o sinal SIGINT, informando o programa que o usuário deseja interrompê-lo.

Por padrão, o programa é fechado. Porém, podemos interceptar esse sinal e agir conforme necessário. Neste caso, apenas finalizaremos o programa. Em sistemas reais, esse recurso pode ser usado para salvar informações antes de fechar, encerrar outros processos, fechar conexões e arquivos, entre outros. Esse processo é conhecido como graceful shutdown.

Cliente e servidor socket em Golang com ping e pong.

crg@crg.eti.br (Cesar Gimenes) — Thu, 11 Aug 2022 00:55:54 -0300

Continuando o papo sobre cliente e servidor resiliente, é hora de aprimorar o servidor e adicionar o envio de mensagens de ping ou keep alive.

Além disso, fizemos melhorias no servidor. Agora, assim como o cliente, ele utiliza goroutines e canais.

Servidor

Lendo da Conexão

Nesta versão, o servidor utiliza uma goroutine para escrever e outra para ler os dados da conexão com o cliente. Ao usar goroutines e canais dessa forma, é essencial garantir que as goroutines sejam finalizadas corretamente.

Cliente e servidor socket em Golang com goroutines e canais.

crg@crg.eti.br (Cesar Gimenes) — Sun, 07 Aug 2022 23:47:50 -0300

Dando continuidade ao exemplo sobre cliente socket persistente em Golang, fiz algumas alterações no código-fonte para ilustrar como melhorar nosso código para torná-lo assíncrono. Para isso, usaremos goroutines e canais.

Goroutines e Canais

Goroutines e canais são recursos avançados da linguagem Go. Goroutines são threads leves gerenciadas pelo próprio runtime da linguagem, e canais permitem a comunicação entre goroutines.

No nosso caso, usaremos canais para a comunicação entre as goroutines do nosso programa.

Cliente e servidor socket em Golang.

crg@crg.eti.br (Cesar Gimenes) — Wed, 03 Aug 2022 07:36:17 -0300

No grupo de estudos de Go, surgiu uma dúvida sobre como escrever um cliente persistente que se reconecte a um servidor socket quando a conexão falhar.

A principal dificuldade das pessoas parece ser entender o conceito de máquina de estados. Por isso, criaremos alguns exemplos de um cliente persistente, começando por uma máquina de estados simples, sem goroutines nem canais.

Antes disso, criaremos um pequeno servidor socket para nosso cliente se conectar: o famoso echo server.

Torne seu Linux mais inseguro e ligeiramente mais rápido

crg@crg.eti.br (Cesar Gimenes) — Sun, 26 Jun 2022 17:07:57 -0300

Primeiro, é claro que não me responsabilize pelo que você fizer no seu sistema, lembre de que a responsabilidade é toda sua.

Existem várias estrategias de processamento que apesar de gerarem um ganho substancial de desempenho acabaram por incluir falhas de segurança, o que fiz foi pegar duas maquinas do meu cluster e configurar o kernel do Linux para não desativar esses recursos.

No meu caso que uso Debian eu editei o arquivo /etc/default/grub adicionando mitigations=off no final da variável GRUB_CMDLINE_LINUX_DEFAULT.

Area de transferência remota

crg@crg.eti.br (Cesar Gimenes) — Tue, 01 Mar 2022 10:36:45 -0300

Dica: O comando pbcopy no Mac é equivalente a xclip -selection clipboard no Linux. O comando pbpaste no Mac corresponde a xclip -selection clipboard -o no Linux. O comando xclip não funciona porque requer o X Window instalado.

Copiar e Colar

Eu edito muito código em servidores remotos via SSH, sem interface gráfica, geralmente uso o Neovim. Seria ótimo poder copiar e colar entre a máquina remota e a local. Colar da máquina local para a remota é simples, pois o terminal já faz isso. Porém, copiar da máquina remota para a local exige um pouco de código.

Acelerando o Site

crg@crg.eti.br (Cesar Gimenes) — Sun, 30 Jan 2022 16:00:03 -0300

Para compartilhar meus artigos usando IPFS é interessante fazer com que o CSS e as imagens fossem inseridas no HTML, dessa forma seria apenas um arquivo para compartilhar.

Inserir o CSS foi a parte mais simples, apenas coloquei o CSS diretamente no modelo do site usando a tag <style></style>, e apenas embute o CSS já gerou um ganho interessante de velocidade.

Eu uso o HUGO como framework para geração automática do site, o HUGO funciona convertendo páginas escritas em Markdown, mas a mesma ideia pode ser usada não importa como o site é feito, mesmo se escrito a mão, direto no HTML. Mas com o HUGO e um pouco de programação foi simples automatizar meu template e fazer com que as imagens fossem convertidas para Base64 e inseridas na página automaticamente.

Como estender o git

crg@crg.eti.br (Cesar Gimenes) — Mon, 25 Oct 2021 14:20:09 -0300

O git é uma ferramenta extremamente flexível e muito simples de se estender e criar funcionalidades. Para criar comandos basta criar um executável com o nome git-comando (git traço seguido pelo nome do comando).

Qualquer executável acessível no PATH com esse padrão de nome vai ser chamado pelo git. Para começar com um exemplo simplesi, vamos para o tradicional “hello world”, salve o exemplo abaixo com o nome git-hello em um diretório no PATH.

Headless VirtualBox

crg@crg.eti.br (Cesar Gimenes) — Sat, 02 Oct 2021 00:25:33 -0300

WIP - Este texto é um trabalho em progresso, ainda não registrei todos os exemplos que queria nem revi o texto. Contribuições são bem-vindas.

Continuando com o projeto de montar um cluster de máquinas, vou precisar de algum sistema de virtualização, porque nem todos os experimentos que quero fazer podem ser feitos apenas com containers. Fiz alguns testes com o QEMU, mas por enquanto é mais prático continuar com o VirtualBox.

Todo acesso no cluster é via ssh, então é necessário controlar o VirtualBox via linha de comando usando o utilitário VBoxManage.

Como diminuir o tamanho do container usando multi-stage builds.

crg@crg.eti.br (Cesar Gimenes) — Thu, 17 Jun 2021 20:52:35 -0300

De vez em quando esbarro com alguma imagem docker enorme em que 99% do tamanho é lixo deixado quando a imagem estava sendo construída. Isso é especialmente ruim quando estamos de executáveis Go que são autocontidos e geralmente não precisam de nenhum recurso externo, nem mesmo a libc.

multi-stage builds

A solução é usar multi-stage builds, dessa forma você pode ter duas etapas no seu Dockerfile, uma de compilação que baixa o que for necessário, compila o código, etc. e outra que apenas copia os executáveis e os recursos para os locais esperados e nem precisa ser baseada em alguma distribuição, pode ser uma imagem scretch que reduz ainda mais o tamanho final.

auto-cpufreq ajustando dinamicamente a frequência da CPU

crg@crg.eti.br (Cesar Gimenes) — Thu, 03 Jun 2021 21:24:42 -0300

O auto-cpufreq otimiza a frequência da CPU e reage bem rapidamente, é muito bom para esticar a carga da bateria para quem usa um notebook Linux.

No meu caso eu estou usando para manter meu pequeno servidor doméstico em uma temperatura mais amena e na prática não senti impacto, tem um pouco de latência quando a máquina está “fria” e do nada eu inicio algum processo pesado, como subir uma sessão SSH+mosh+zsh.

Primeiros passos na configuração de um novo servidor.

crg@crg.eti.br (Cesar Gimenes) — Mon, 03 May 2021 18:30:30 -0300

Quando subo uma máquina nova sempre executo alguns comandos e faço algumas configurações, muita coisa já esta pronta nos meus dotfiles mas sempre tem muita coisa personalizada para fazer.

A primeira coisa é obter acesso ssh, ter certeza que as senhas de root não são as default.

Em seguida dou acesso de sudo para meu usuário caso já não tenha.

usermod -aG sudo ${USER}

Se for uma máquina na rede local eu configuro ela para usar zero configuration network, uma forma muito mais conveniente de acessar a máquina principalmente em redes IPv6. caso contrário esse é um bom momento para adicionar a maquina em um domínio.

O manual do UNIX

crg@crg.eti.br (Cesar Gimenes) — Wed, 10 Feb 2021 06:45:14 +0000

Em 3 de novembro de 1971, foi lançada a primeira versão do Unix Programmer’s Manual, comumente conhecido como man pages.

Você pode baixar em PDF ou PostScript na página de Dennis Ritchie na Bell Labs, mantida pela Nokia por motivos históricos.

É interessante como os comandos do UNIX não mudaram muito ao longo dos anos. Se você é usuário de Linux ou BSD, certamente reconhecerá a maioria deles. Também é fantástico como uma ideia tão simples pode ser tão incrivelmente útil.

Dica do comando find

crg@crg.eti.br (Cesar Gimenes) — Wed, 14 Oct 2020 06:45:14 +0000

Eu uso bastante o comando find para procurar por arquivos, sejá em scripts bash seja na linha de comando.

Um truque interessante é excluir alguns arquivos da lista, por exemplo hoje eu precisei procurar por todos os arquivos “.md” mas queria excluir todos os iniciados com underline e também o arquivo “default.md”.

Para fazer isso usei o parametro -not antes do parametro -name como no exemplo abaixo.

find . \
 -type f \
 -name '*.md' \
 -not -name '_*md' \
 -not -name 'default.md'

Excluindo arquivos

No meu caso eu queria excluir os arquivos mantendo os arquivos todo o resto da estrutura então usei a linha de comando abaixo, com a unica substituição do comando echo por rm. Claro que eu deixei o comando echo no exemplo para deixar mais seguro para quem quer só copiar o comando e testar.

Configurando timeout para requisições HTTP em Golang

crg@crg.eti.br (Cesar Gimenes) — Sun, 04 Oct 2020 10:41:09 -0300

Por padrão Go não tem timeout para requisições HTTP, isso pode acarretar vários problemas e vulnerabilidades, por exemplo, um ataque DOS pode simplesmente abrir várias conexões com seu servidor.

Para resolver crie uma instancia da struct http.Server e preencha os campos WriteTimeout e ReadTimeout com os tempos que achar adequados.

Veja o exemplo de código.

func main() {
 r := mux.NewRouter().StrictSlash(true)
 r.HandleFunc("/", mainHandler)
 ...

 srv := &http.Server{
 Handler: r,
 Addr: ":8000",
 WriteTimeout: 15 * time.Second,
 ReadTimeout: 15 * time.Second,
 }

 log.Println("Listen at port :8000")
 log.Fatal(srv.ListenAndServe())
}

Isso vai definir os tempos de timeout default para todas as requisições HTTP.

Controle de sessão em Golang como Gorilla sessions

crg@crg.eti.br (Cesar Gimenes) — Sat, 03 Oct 2020 22:38:09 -0300

Controle de sessão é um conceito bastante antigo, basicamente se usa cookies para guardar alguns dados da sessão do usuário, por segurança geralmente só preservamos no cookie um UUID o mais aleatório possível, que o servidor usa para consultar outros dados, como por exemplo saber qual usuário esta logado.

O UUID precisa ser o mais aleatório possível porque se alguém conseguir prever qual será o próximo UUID é possível roubar a sessão de um usuário legitimo.

Descobrindo ip com Golang

crg@crg.eti.br (Cesar Gimenes) — Sat, 23 May 2020 10:45:43 -0300

Recentemente eu esbarrei com um problema interessante, eu precisava subir um pequeno serviço REST para gerenciar alguns hardwares, tudo sem contato humano e também com várias interfaces de rede.

Em um determinado momento meu sistema tem que subir um serviço auxiliar e informar o cliente em que ip e porta ele deveria acessar. Normalmente isso seria feito com um arquivo de configuração em algum lugar, mas um requisito é que eu não podia presumir meu ip porque ele poderia vir de qualquer uma das interfaces de rede e deixar tudo isso parametrizado ficaria complexo demais.

Diferenças entre slice e array em Go

crg@crg.eti.br (Cesar Gimenes) — Tue, 14 Apr 2020 11:11:33 -0300

Array

Array em Go sempre tem tamanho fixo.

Quando você adiciona um novo elemento em um array o que acontece internamente é que um novo array é criado e os itens antigos e novos são copiados para esse novo array. Eventualmente o espaço opupado pelo array antigo será liberado pelo garbage collector. Então é importante, sempre que possível, declarar o array com o tamanho máximo que ele vai precisar e evitar adicionar itens, principalmente em loop.

Os problemas programando em Golang

crg@crg.eti.br (Cesar Gimenes) — Sun, 01 Mar 2020 11:11:33 -0300

Eu amo Go. Escolho Go para muitos dos meus projetos. Ela é simples e robusta, com ampla documentação, diversos exemplos e uma biblioteca padrão extensa, focada em resolver problemas atuais. Sem dúvida, é uma excelente linguagem.

Entretanto, nada é perfeito. Golang tem seus problemas, assim como qualquer outra linguagem. Alguns serão resolvidos conforme o compilador evolui. Outros, o programador precisa estar atento. Vamos ver alguns dos mais comuns. Alguns problemas mencionados aqui não são exclusivos do Go, mas sim decorrentes de um design de código ruim, que já encontrei diversas vezes e vale a pena mencionar.

Shadow de variáveis em Golang

crg@crg.eti.br (Cesar Gimenes) — Sat, 15 Feb 2020 20:12:16 -0300

Golang é uma linguagem de programação fácil de usar e que ajuda a evitar muitos dos erros comuns.

Mas um erro que é fácil de cometer em Go e que ainda não gera warnings do compilador é shadow de variáveis.

Shadow é quando você declara uma variável em um bloco de código e em um bloco aninhado declara novamente a variável.

Daí você faz alterações no valor da variável acreditando que esta atualizando a variável do bloco de hierarquia superior mas na verdade esta alterando apenas a variável do bloco atual.

Primeiros passos com assembly

crg@crg.eti.br (Cesar Gimenes) — Sat, 08 Feb 2020 20:12:16 -0300

Toda quinta-feira, um grupo de programadores e eu nos reunimos para conversar sobre Golang no Grupo de Estudos de Go. Devemos mudar o nome para Grupo de Estudos de Tecnologia porque discutimos todos os assuntos relacionados.

Um tema recorrente é programação em assembly. Várias vezes, discutimos iniciar demonstrações e brincadeiras carregadas via setor de boot, conhecidas como “boot sector games”.

Além de ser divertido, é uma boa forma de ensinar como o computador funciona internamente. Conceitos como velocidade de acesso, cache Lx e outros são abstratos em linguagens de alto nível.

Web Scraping com Golang

crg@crg.eti.br (Cesar Gimenes) — Mon, 23 Sep 2019 08:16:28 -0300

Recentemente precisei extrair algumas informações de um site, meu plano era simples, verificar a URL que o formulário de pesquisa apontava e fazer a requisição diretamente pelo meu programa, daí usar o package goquery fazer parser dos resultados e pegar os dados que eu queria.

Claro que não foi fácil assim. O site que eu queria crawlear era repleto de JavaScripts que interferiam com o formulário, com os cookies e com basicamente tudo.

Um pequeno emulador da CPU 8086

crg@crg.eti.br (Cesar Gimenes) — Tue, 16 Jul 2019 08:16:28 -0300

Emulador 8086 escrito em C

A primeira coisa que é preciso deixar claro é que esse não é um emulador completo, o objetivo é apenas interpretar um hello world. Claro, é possível pegar esse esqueleto e expandir até se tornar um emulador completo.

Eu estava entediado esperando meus amigos aparecerem na Campus Party de 2016, encontrei a mesa que estava separada para a galera de hackerspace e fiquei esperando mas como não tinha nenhuma palestra aquele horário nem nada que eu quisesse participar eu precisava de algo para matar o tempo.

Home Office, Minha Experiencia Trabalhando em Casa

crg@crg.eti.br (Cesar Gimenes) — Tue, 09 Jul 2019 20:12:16 -0300

Aqui vamos ver algumas coisas da minha experiência trabalhando em home-office e vou dar algumas dicas de como eu resolvi problemas comuns que todo mundo que quer trabalhar com tecnologia longe do escritório vai enfrentar.

Eu sou um veterano quando o assunto é trabalho remoto. Comecei no fim dos anos 90, na época eu trabalhava em uma empresa com uma administração bastante arrojada e moderna principalmente para o Brasil da época. Na época eu era um jovem programador com muito para aprender ainda.

O BASIC ainda esta vivo e chutando

crg@crg.eti.br (Cesar Gimenes) — Mon, 08 Jul 2019 20:12:16 -0300

Em minha pesquisa sobre implementações em BASIC, encontrei algumas coisas interessantes. É incrível como uma linguagem antiga e com tantos problemas ainda existe. Ainda é possível encontrar compiladores comerciais sendo desenvolvidos para ela.

Sim, apesar de ser fã e adorar brincar com BASIC pela nostalgia e diversão, não dá para negar que BASIC causa mais problemas do que benefícios. (Na minha opinião)

Claro, fazia sentido ter uma linguagem extremamente simples quando o BASIC nasceu, em 1964. Máquinas com poucos recursos e o propósito de ser uma linguagem para iniciantes. BASIC significa Beginner’s All-Purpose Symbolic Instruction Code

Erro difícil com interfaces e switch case em Go

crg@crg.eti.br (Cesar Gimenes) — Sun, 24 Feb 2019 06:45:14 +0000

Veja o vídeo falando desse erro no Grupo de Estudos de Golang.

Golang é uma linguagem bem fácil de programar e que tem poucas armadilhas para o programador. A maioria das coisas que podem dar errado são pegas pelo compilador ou por alguma das muitas ferramentas de análise estática que ajudam a manter nosso código quase livre de bugs.

Mas existem situações em que mesmo essas ferramentas tem dificuldade nos alertar porque não da para saber o que o programador queria que fosse o resultado do programa. Isso geralmente acontece usando os recursos mais divertidos da linguagem como switch, interfaces, canais e goroutines.

Cobertura de testes unitários em Go

crg@crg.eti.br (Cesar Gimenes) — Wed, 13 Feb 2019 06:45:14 +0000

Testes unitários são incrivelmente importantes, mesmo para uma linguagem compilada como Golang eles são fundamentais.

Felizmente, hoje em dia, a maioria das linguagens de programação tem uma bela variedade de ferramentas para teste unitário. Go vem com algumas ferramentas surpreendentes, não apenas para fazer os testes mas também para analisar o código em busca de falhas na cobertura, etc.

Uma forma visual e rápida para analisar a cobertura de testes é fazer um script com go tool cover que pode ser colocado na carga do zsh ou no bash e torna muito simples fazer essa inspeção do código.

Quine implementado em Golang

crg@crg.eti.br (Cesar Gimenes) — Tue, 12 Feb 2019 06:45:14 +0000

Imprimindo seu próprio código-fonte

Quine é um programa que consegue imprimir seu código-fonte na saída padrão. O nome é em homenagem ao matemático e filosofo Willard Van Orman Quine.

Existem exemplos de Quine escritos para várias linguagens de programação, é um exercício interessante tentar escrever a sua versão e um belo desafio.

Veja bem, a regra é que não pode simplesmente abrir seu próprio código-fonte e imprimir, isso seria trapaça, o que precisa fazer é que seu código seja gere na saída padrão uma versão de si sem ler de lugar nenhum.

PostgreSQL via SSL com Golang

crg@crg.eti.br (Cesar Gimenes) — Fri, 04 Jan 2019 06:45:14 +0000

Criando o certificado

Primeiro vamos criar um certificado de testes, claro que quando for usar em produção você deve usar um certificado gerado por uma entidade certificadora reconhecida.

Com o comando abaixo vamos criar dois arquivos server.crt e server.key que vamos usar para configurar o PostgreSQL.

openssl req -new -x509 -days 365 -nodes -text -out server.crt \
 -keyout server.key -subj "/CN=example.com"

Configurando PostgreSQL

Edite o arquivo postgresql.conf para ativar o uso da chave SSL.

Unix Domain Socket com Golang

crg@crg.eti.br (Cesar Gimenes) — Thu, 06 Dec 2018 06:45:14 +0000

Unix Domain Sockets ou IPC Socket

Unix Domain Sockets é uma forma prática e segura de trocar informações entre processos. Essa forma de IPC (Inter-process communication) usa um arquivo como endereço em vez de um IP e uma porta, como na comunicação via rede.

É importante lembrar que o servidor gerencia o arquivo. Se o arquivo não existir, o servidor o cria automaticamente. Se o arquivo já existir, você receberá um erro como “bind: address already in use”. Isso significa que o servidor não pode reutilizar o arquivo existente. Portanto, é correto desligar o servidor de forma elegante, fechar e apagar o arquivo antes de finalizar o servidor. Dependendo do sistema, pode ser interessante verificar se o arquivo existe e apagá-lo antes de iniciar o servidor.

Um JSON lint em Golang

crg@crg.eti.br (Cesar Gimenes) — Fri, 30 Nov 2018 06:45:14 +0000

Veja o vídeo desse arquivo aqui.

Um JSON lint em Golang

Esse é um pequeno utilitário de linha de comando para validar e formatar JSON que também pode ser usado como pacote, a ideia inicial era criar um parser para validar o JSON mas não foi necessário, o próprio Golang traz todas as informações que precisamos no erro inclusive o offset do erro e dai foi simples mostrar os erros de forma mais completa inclusive indicando com uma seta exatamente onde esta o erro.

Trafegando dados entre middleware http usando contexto em Golang

crg@crg.eti.br (Cesar Gimenes) — Fri, 09 Nov 2018 06:45:14 +0000

Veja o vídeo desse arquivo aqui.

Trafegando dados entre middleware

Já vimos como funciona um middleware HTTP e agora vamos ver como passar informação entre os middlewares. Isso é usado por exemplo para passar as credenciais de um usuário para o próximo middleware e qualquer outra informação que seja coletada em algum dos middlewares e você queria passar para frente.

Antes de mais nada vamos fazer um exemplo para mostrar da forma mais clara possível quando os middlewares são executados, isso é muito importante porque erros no entendimento dessa ordem de execução é uma incrível fonte de bugs. No exemplo abaixo colocamos mensagens no terminal toda vez que um middleware é carregado e descarregado. E é sempre bom reforçar isso vai acontecer na mesma ordem em que eles foram registrados.

Como fazer HTTP middleware em Golang tanto usando Negroni como usando a biblioteca padrão

crg@crg.eti.br (Cesar Gimenes) — Fri, 02 Nov 2018 06:45:14 +0000

Veja o vídeo desse arquivo aqui.

Usar middleware HTTP são muito úteis para evitar duplicidade de código quando você tem vários endpoints na sua aplicação, por exemplo se você quiser ter certeza que as credenciais do usuário foram verificadas, ou que o conteúdo foi comprimido, e assim por diante.

A coisa mais importante que se deve lembrar é que cada middleware vai ser chamado na ordem que foi registrado, então por exemplo podemos ter um middleware que tem a responsabilidade de preparar o ambiente, como abrir o banco de dados ou preparar o controle de sessão que vem antes do middleware que valida as credenciais do usuário.

Usando goto e label em Go

crg@crg.eti.br (Cesar Gimenes) — Fri, 26 Oct 2018 06:45:14 +0000

A instrução goto tem fama negativa. No tempo do BASIC programadores não tinham muitas opções e abusavam do comando goto e criaram códigos confusos. Linguagens modernas, como Go, usam goto com critério e melhoram a clareza do código.

Go permite que os comandos break e continue usem labels. Use labels para sair de loops aninhados com break dar continue em um loop específico. Usar break ou continue com labels equivale a usar goto.

Um sistema de mensageria extremamente rápido com NATS e Golang

crg@crg.eti.br (Cesar Gimenes) — Fri, 19 Oct 2018 06:45:14 +0000

Veja o vídeo desse arquivo aqui.

mensageria com NATS

Para quem precisa que vários sistemas se comuniquem entre si e precisa de velocidade e simplicidade o NATS é uma grande ajuda. Uma das características mais interessantes é a incrível velocidade e um protocolo simples que pode ser facilmente implementado faz com que o NATS seja usado desde para IoT com bibliotecas cliente escritas até mesmo para Arduino quando para comunicação entre serviços muito maiores. Também é muito usado para aplicações mobile por pelo mesmo motivo, protocolo simples e rápido. É uma alternativa muito interessante ao MQTT e é implementado em Go. :D

Protocol Buffers

crg@crg.eti.br (Cesar Gimenes) — Thu, 20 Sep 2018 08:19:09 -0300

Veja o vídeo desse arquivo aqui.

Este é o primeiro de uma série de tutoriais rápidos onde planejo cobrir o uso de gRPC e vários aspectos como testes, TLS, boas práticas e muito mais.

Para iniciar com gRPC precisamos ir até a base então vamos primeiro falar de Protocol Buffers.

Protocol Buffers é uma forma simples e agnóstica com relação à linguagem de se definir uma estrutura de dados, como XML, só que melhor, mais simples e mais rápido, muito mais rápido.

ssh - Usando chaves de acesso

crg@crg.eti.br (Cesar Gimenes) — Sun, 09 Sep 2018 08:19:09 -0300

Veja o vídeo desse arquivo aqui.

Acessar servidores via SSH usando um conjunto de chaves publica/privada é mais seguro e prático, principalmente mais seguro, além de facilitar a automação de várias tarefas.

Criando as chaves

Primeiro crie as chaves com o seguinte comando:

mkdir ~/.ssh
ssh-keygen

Precisa fazer isso apenas uma vez na máquina cliente e um conjunto de chaves será gerado, você pode definir o nome do arquivo que por padrão seria id_rsa para a chave secreta e id_rsa.pub para a chave publica.

JSON, criando seu próprio Marshal e Unmarshal

crg@crg.eti.br (Cesar Gimenes) — Thu, 06 Sep 2018 08:19:09 -0300

Veja o vídeo desse arquivo aqui.

O formato de data padrão do Postgres é incompatível com o formato padrão do Golang e o nosso sistema usa muito JSON para tanto mandar como receber informações do banco de dados.

Ter que lembrar toda hora de fazer o parser da data para o formato correto simplesmente não é pratico, é muito melhor ensinar o Golang como lidar com data e hora no bom e velho formato ISO 8601.

Interface como um contrato

crg@crg.eti.br (Cesar Gimenes) — Thu, 30 Aug 2018 20:05:18 -0300

Veja o vídeo desse arquivo aqui.

Falamos desse mesmo tema na nossa lista de exemplos do grupo de estudos sobre interfaces mas vamos isso foi la no longínquo ano de 2016 então vamos tentar fazer um novo exemplo para mostrar como usar uma interface como um contrato que permite você passar tipos diferentes para uma função ou aceitar tipos diferentes em uma interface desde que ele aceite implemente o contrato que em outras palavras significa implementar as funções descritas na interface.

Usando VPN no macOS

crg@crg.eti.br (Cesar Gimenes) — Sat, 25 Aug 2018 20:05:18 -0300

Como qualquer ferramenta, usar uma VPN só será efetivo se você souber exatamente qual problema quer resolver com ela. Existem pessoas que querem manter seu trafego pela internet anônimo, outras querem proteger seus dados, e por aí vai. O meu uso é bem específico, alguns provedores de acesso à internet estão bloqueando portas importantes que uso para acessar serviços, por exemplo, um famoso provedor daqui de São Paulo esta bloqueando a porta TCP 22 que usamos para acessar o SSH, note que não é o caso do provedor bloquear conexões de entrada que já era comum, mas de saída, ou seja, usar qualquer serviço que dependa de SSH como o GitHub por exemplo ou acessar uma máquina hospedada na Computer Engine do Google Cloud Platform fica impossível.

Interface vazia

crg@crg.eti.br (Cesar Gimenes) — Thu, 23 Aug 2018 20:05:18 -0300

Veja o vídeo desse arquivo aqui.

Interface vazia é um tipo que aceita qualquer coisa, você pode passar o que quiser como parâmetros de função ou variáveis do tipo interface{}.

Parece muito pratico a primeira vista mas quando usamos interface{} estamos jogando pela janela a validação de tipos feita em tempo de compilação e perdemos uma das grandes vantagens de uma linguagem compilada de tipagem forte e estática.

E como a checagem de tipo não vai acontecer em tempo de compilação é sua responsabilidade checar se esta recebendo o tipo certo em tempo de execução.

JSON Dicas e Truques

crg@crg.eti.br (Cesar Gimenes) — Thu, 16 Aug 2018 20:05:18 -0300

Veja o vídeo desse arquivo aqui.

Convertendo e validando JSON

É sempre bom saber se o JSON é valido antes, isso poupa tempo de debug procurando um problema que não esta no seu código, para isso uma boa ferramenta on-line é o JSONLint

Outra ferramenta on-line muito boa é o JSON-to-Go para converter arquivos JSON em struct Go, ele não vai converter partes repetitivas em sub-structs mas ajuda muito, principalmente quando a estrutura é muito grande e complexa.

MS-DOS, APM com C e Assembly

crg@crg.eti.br (Cesar Gimenes) — Sun, 05 Aug 2018 20:05:18 -0300

Veja o vídeo deste arquivo aqui.

Para brincar de retrocomputação, eu uso o VirtualBox com o MS-DOS 6.22 e o DOSBox. Ambos funcionam muito bem, mas a tela fica um pouco melhor no VirtualBox, e o DOSBox é mais rápido e fácil para desenvolver e alternar rapidamente entre sistemas. Por isso, uso os dois.

No DOSBox, você pode fechar o simulador digitando o comando exit. Isso fecha uma sessão do interpretador de comandos e, se for a última sessão, fecha o próprio DOSBox. É conveniente porque não precisa usar o mouse e se comporta mais como um terminal.

Acessando Dropbox com Golang

crg@crg.eti.br (Cesar Gimenes) — Thu, 02 Aug 2018 20:05:18 -0300

Precisei de um pacote Golang para ao Dropbox e fazer algumas operações basicas, listar arquivos, upload e download, para isso usei o dropbox-sdk-go-unofficial.

Conectando Dropbox

Para conectar o dropbox precisamos das credenciais de acesso, a forma mais fácil é criar um token, para isso entre em Dropbox developers apps e crie uma aplicação, então dentro do painel da aplicação crie o token.

Configurando o sistema

Todas as funções precisam das configurações com as credenciais de acesso e outros parâmetros úteis como por exemplo o nível de log. Então criamos uma função para retornar uma instancia da struct config.

Editar linhas de comando no terminal

crg@crg.eti.br (Cesar Gimenes) — Sun, 08 Jul 2018 06:45:14 +0000

Eu uso muito o terminal, é incrível como a boa e velha interface de linha de comando cli continua relevante e simplesmente a forma mais rápida de comandar um computador apesar de tantos anos de evolução da informática.

Simplesmente ainda não descobrimos uma forma melhor de entrar comandos mas com o passar do tempo esses comandos foram crescendo e se tornando praticamente pequenos programas, as vezes com algumas linhas de código e até coisas difíceis de editar como expressões regulares por exemplo.

Compilação Estática Com Golang

crg@crg.eti.br (Cesar Gimenes) — Sat, 02 Dec 2017 16:57:41 -0200

Criando executáveis monolíticos

Veja o vídeo desse arquivo aqui.

Golang já faz um bom trabalho compilando estaticamente praticamente tudo, mas dependendo do seu código é necessário incluir mais alguns parâmetros para garantir que seu executável seja totalmente livre de dependências.

A primeira coisa é compilar o seu projeto e então inspecionar o binário para ver se ele tem alguma dependência.

Para fazer isso no macOS usamos o utilitário otool (object file displaying tool) passando o parâmetro -L (mostra as shared libraries usadas) como no exemplo:

Acessando a porta serial

crg@crg.eti.br (Cesar Gimenes) — Sat, 30 Sep 2017 21:22:29 -0300

Veja o vídeo desse arquivo aqui.

E para mim uma das coisas mais interessantes é que os desenvolvedores preferiram deixar de fora algumas coisas que tem no screen, como o suporte a telnet e a portas seriais, eles fizeram isso porque acreditam na filosofia UNIX de faça apenas uma coisa e faça bem feito. E na minha opinião eles estão muito certos.

Vamos ver algumas formas de acessar a serial

A única coisa que você tem que se lembrar não importa o modo que escolha para abrir a porta serial é que ela é feira para ser acessada apenas por um programa por vez, e para que outro programa consiga usar a mesma porta é necessário que o primeiro programa feche ela. Isso acontece muito por exemplo quando se esquece uma sessão do terminal serial do Arduino aberto.

Um conto de terror para programadores

crg@crg.eti.br (Cesar Gimenes) — Wed, 26 Jul 2017 10:56:00 -0300

Já tem muitos anos havia uma lista de discussão sobre Linux bem famosa, todo mundo se reunia por lá. Mas estávamos no início e as coisas não eram nem de perto tão robustas como são hoje, listas de e-mails ainda eram o principal meio para trocar informações porque ninguém tinha uma conexão 7x24 como as que temos hoje, você conectava, baixava seus e-mails, lia tudo off-line, respondia, conectava novamente e enviava suas respostas. Tudo muito rústico, mas funcionava.

Golang brincando com bits

crg@crg.eti.br (Cesar Gimenes) — Mon, 03 Apr 2017 18:39:50 -0300

Brincando com bits

A ideia é manipular a paleta de cores do CGA que armazena as cores em um unico byte, essa brincadeira parece complicada mas na verdade é muito simples, precisamos apenas aprender algumas poucas operações para poder manipular bits.

Antes de começarmos vamos combinar o seguinte, quando eu falar sobre a parte superior ou alta de um conjunto de bits estou me referindo aos bits mais a esquerda, e quando estiver falando da parte inferior ou parte baixa estou falando dos bits mais a direita. Nem sempre é assim, mas para efeito desse texto é assim que funciona é o que chamamos de lite-endian

Dicas de Golang defer

crg@crg.eti.br (Cesar Gimenes) — Fri, 24 Mar 2017 20:12:16 -0300

Usar defer para adiar um comando até a função terminar, independentemente de como ela termine, é uma excelente ideia. Imagine uma função com vários pontos de retorno, seja para erros ou para terminar corretamente. Gerenciar o fechamento de arquivos, conexões, mutexes e outros recursos em cada retorno torna-se entediante e inseguro. Você pode esquecer de fechar um recurso em algum retorno, e isso pode causar problemas sérios.

Contudo, o uso de defer tem um custo. O sistema empilha o comando adiado, e adiá-lo com defer é alguns nanossegundos mais lento do que uma chamada direta. Isso geralmente não é um problema no dia a dia, mas se você precisa maximizar a performance do seu código, pode ser algo a considerar.

Golang previnindo data race

crg@crg.eti.br (Cesar Gimenes) — Sat, 11 Mar 2017 18:11:14 -0300

No projeto do Ricardo Gomes onde ganhamos uma bela performace também acabamos acidentalmente incluindo uma bela data race.

Veja o vídeo desse arquivo aqui.

Data race acontece quando você tem acessos simultâneos a mesma variável por duas threads diferentes.

Mas Golang tem ferramentas para tudo, e nessa brincadeira eu aprendi sobre o parâmetro -race. Esse parâmetro faz com que o Golang procure por possíveis data races em seu código e pode ser usado com test, run, build e install.

Golang carregando arquivos Sped Fiscal 95% mais rápido

crg@crg.eti.br (Cesar Gimenes) — Mon, 06 Mar 2017 20:52:00 -0300

No ultimo domingo eu e o Ricardo Gomes da Fix Auditoria fizemos pair programming com a missão de melhorar o parse de EFD Fiscal que ele esta desenvolvendo em Golang.

Veja o vídeo desse arquivo aqui.

O nosso objetivo era fazer o parser ganhar alguma performace e também resolver alguns pequenos problemas na carga dos arquivos.

O que o sistema faz até o momento é o seguinte: Le vários arquivos texto contendo centenas de milhares de registros, parseia esse conteúdo linha a linha e por fim grava tudo no banco de dados.

Assembly 16Bits no macOS com NASM e DOSBox

crg@crg.eti.br (Cesar Gimenes) — Sat, 04 Mar 2017 18:16:31 -0300

Brincando com Assembly

Veja o vídeo desse arquivo aqui.

Brincar com assembly é divertido, só com asm você tem controle total da maquina e de cada aspecto do seu programa, não há nada escondido e o computador vai fazer exatamente o que você mandou (não necessariamente o que você quer).

Hoje me dia assembly para mim é um hobby, não estou mexendo com nada tão baixo nível que realmente precise descer até o asm mas como diversão NERD não tem igual e recentemente encontrei meus antigos guias de referencia rápida das interrupções da BIOS e do MS-DOS.

Golang percorrendo a árvore de diretórios

crg@crg.eti.br (Cesar Gimenes) — Tue, 28 Feb 2017 09:07:51 -0300

Eu enfrentava o problema de ter que digitar o caminho completo para acessar o diretório do projeto no qual queria trabalhar. Tudo está no GOPATH e os caminhos geralmente são longos. Embora digitar o caminho completo de vez em quando seja aceitável, trabalho diariamente com golang em vários projetos. Ter que digitar o caminho completo constantemente se torna entediante. Às vezes, eu nem sei exatamente onde o projeto está ou esqueço partes do caminho, como o nome do autor ou se está no GitHub ou em outro repositório.

go usando time e canais

crg@crg.eti.br (Cesar Gimenes) — Sun, 05 Feb 2017 19:19:29 -0200

Pacote time

Eu sou o primeiro a torcer o nariz para o pacote time, principalmente pela maneira como a formatação de datas é feita, mas um recurso muito interessante é poder criar um canal que retorna a cada X tempo e assim podemos executar ações periódicas.

Veja o vídeo desse arquivo aqui.

Veja como isso é feito

Primeiro criamos um canal que vai retornar a cada X tempo, no caso do exemplo 300 milissegundos.

Golang plugins

crg@crg.eti.br (Cesar Gimenes) — Sun, 05 Feb 2017 11:19:27 -0200

Plugins são um dos poucos recursos quase esquecidos do Go e, francamente, eu desaconselho seu uso. Ao contrário de outros recursos da linguagem, plugins funcionam apenas no Linux, BSD e macOS. Como são baseados no dlopen, você não pode descarregar nem substituir um plugin depois de carregá-lo. Além disso, é necessário usar CGO, o que pode trazer mais complicações.

Apesar dos problemas, plugins são recursos interessantes e podem ser úteis em alguns casos, como carregar um módulo de forma dinâmica.

GitHub a rede social do programador

crg@crg.eti.br (Cesar Gimenes) — Sat, 24 Dec 2016 14:25:19 -0200

Talk is cheap. Show me the code. - Linus Torvalds em uma mensagem para a linux-kernel mailing list em 25/08/2000

Lone Gunman

Durante a maior parte da minha carreira eu trabalhei sozinho ou em equipes muito pequenas, é fácil manter controle de versão quando se esta sozinho, qualquer sistema vai funcionar desde que ele não entre na sua frente e seja minimamente eficiente, eu programo desde os anos 90 e já passei por tudo, desde copiar todo o projeto para um outro diretório, ou zipar o projeto com a data da mudança, CVS, SVN, e agora Git. De todos esses o Git é sem duvida o melhor equilíbrio entre funcionalidade e praticidade, a curva de aprendizado é bastante suave com quatro ou cinco comandos você esta usando Git sem problemas. E hoje os tempos de pistoleiro solitário ficaram para traz, trabalho em uma equipe e não estamos juntos na mesma sala, trabalhamos de forma assíncrona e o controle de versão precisa absorver isso. A natureza descentralizada do Git ajuda muito a juntar varias partes do trabalho e montar o quebra-cabeça que é um software moderno.

Assembly, assembler e linguagem de maquina

crg@crg.eti.br (Cesar Gimenes) — Sun, 11 Sep 2016 08:16:28 -0300

São Coisas Diferentes

Existem três conceitos diferentes, mas relacionados, que as pessoas frequentemente confundem. Vamos esclarecer cada um deles.

Assembly

Assembly é uma linguagem de programação composta por mnemônicos simples. Ela corresponde diretamente às instruções da plataforma utilizada. Ao escrever código em Assembly, você sabe exatamente o que o processador está fazendo e tem acesso a recursos que podem não estar disponíveis em linguagens de alto nível. Podemos chamar Assembly de uma linguagem de baixo nível, o que significa que está mais próxima do hardware.

Zero Configuration Networking

crg@crg.eti.br (Cesar Gimenes) — Sun, 04 Sep 2016 11:11:33 -0300

Frequentemente adiciono novos dispositivos à minha rede para diferentes finalidades. Esses dispositivos podem ser qualquer coisa: um SBC para projetos de IoT, uma máquina virtual para testar software sem afetar os sistemas principais ou uma VM descartável para testes rápidos.

Isso gera um problema: como descobrir o IP para acessar esses recursos? Poderia verificar o DHCP, atribuir IPs fixos ou outras soluções, mas todas são pouco práticas. Preciso de uma solução fácil e rápida que funcione para mim e para scripts que precisam localizar recursos na rede, mesmo que o IP tenha mudado.

Tratando sinais com Go

crg@crg.eti.br (Cesar Gimenes) — Mon, 18 Jul 2016 16:36:22 -0300

Tratar sinais é uma boa prática. Dessa forma, você pode finalizar seu programa graciosamente, liberando recursos e fechando bancos de dados, em vez de simplesmente encerrar o programa. Tratar sinais do sistema operacional com Golang é simples, pois o sistema envia o sinal para um canal. Basta escutar esse canal.

Primeiro, criamos um canal:

sc := make(chan os.Signal, 1)

Em seguida, informamos o tipo de sinal que nos interessa. No caso, ^C, ou seja, SIGINT.

Usando diff e patch

crg@crg.eti.br (Cesar Gimenes) — Fri, 15 Jul 2016 23:30:17 -0300

Esses dois comandos são ferramentas extremamente úteis para o programador, com esses dois comandos fica fácil enviar patchs (remendos) de código para outros programadores sem precisar enviar o código todo.

diff

Digamos que você tem dois arquivos texto, um original e outro que é uma cópia do original com alguma modificação.

O comando diff procura por diferenças entre dois arquivos ou mesmo duas arvores de diretórios, a forma mais simples de usar esse comando é a seguinte:

HTTPS com Golang no Linux

crg@crg.eti.br (Cesar Gimenes) — Thu, 30 Jun 2016 09:37:25 -0300

Gerando as chaves com letsencrypt.org

Como eu mencionei no post sobre redirecionar tudo para HTTPS todas as comunicações entre cliente e servidor precisam ser criptografadas e com letsencrypt.org isso pode ser feito sem custo, com código aberto e muita documentação, o que no meu ponto de vista acaba com todas as desculpas para não usar HTTPS.

Uma ressalva importante é que podem haver razões legais para preferir usar outra entidade certificadora, por exemplo se eu não estou enganado para ter valor legal no Brasil a entidade precisa ser brasileira. Claro que isso só importa se você estiver querendo processar alguém, eu estou interessado apenas na segurança.

Redirect para HTTPS e proxy reverso

crg@crg.eti.br (Cesar Gimenes) — Tue, 28 Jun 2016 11:22:10 -0300

Tudo criptografado, Sem desculpas

Antigamente era caro e inconveniente exigir criptografia para servidores HTTP, você teria que no mínimo gastar alguns trocados com uma entidade certificadora. De um tempo para cá isso não é mais verdade, qualquer um pode usar os certificados da letsencrypt.org, é free, fácil de usar e as ferramentas são de código aberto, então não existe mais desculpa para não usar HTTPS nos seus servidores.

Além de poder usar os certificados diretamente várias ferramentas e serviços estão atualmente gerando o certificado do Let’s Encrypt para você, é o caso do Caddy que basta você fornecer um nome de domínio no seu arquivo de configuração e ele vai solicitar o certificado e usar tudo de forma transparente.

String aleatória segura em Golang usando crypto/rand

crg@crg.eti.br (Cesar Gimenes) — Wed, 13 Apr 2016 11:30:39 -0300

Gerar strings aleatórias é extremamente útil. Esse recurso é usado em muitos lugares, como criar chaves para registros em bancos de dados distribuídos sem risco de colisão entre registros, criar IDs de controle de sessão, gerar senhas e muito mais.

Apesar de ser uma tarefa simples, há alguns truques interessantes. Na verdade, computadores não são bons para criar coisas verdadeiramente aleatórias. Eles criam coisas previsíveis, o que não é desejável quando o objetivo é criptografia e segurança.