Articles and programming tutorials on Cesar Gimenes

Kutta in the Browser: Same Code, a Different Frame Budget

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

Kutta now runs inside a browser tab. Same source as the desktop build, GOOS=js GOARCH=wasm, no fork, no duplicated file holding a “web” version of the solver.

Speed is what you pay. A solver step costs 6.1 ms under wasm against 2.3 ms native, measured on the 360x200 grid the app runs, on an M4 Mac, same solver compiled for both targets on the same machine. Factor of 2.6.

Kutta, a Tiny Wind Tunnel in Go

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

You can explain lift with a diagram and an equation. It rarely sticks. Watch a wake peel off the back of a wing while you turn the angle of attack, and it sticks immediately. That gap is the whole reason Kutta exists.

It is a small 2D wind tunnel written in Go, rendered with Ebitengine, running as a single desktop app.

The idea never grew past the first sketch: stream air past an airfoil and make the flow visible. Change the angle of attack and the field reacts. Toggle between speed, vorticity and a pressure-like field. Draw your own shape. Cut a wing into a wing and a flap, animate the flap, and watch the wake go unstable when the geometry or the angle gets greedy.

Glaze, a Desktop WebView in Go Without CGO

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

Opening a window with HTML in Go almost always charges a toll in C.

Either you turn on cgo and drag a C toolchain into the project, or someone embeds a compiled .dll/.so/.dylib in the binary and extracts it to disk on first run. Both work. And both take away exactly what I like about the ecosystem: the go build that cross-compiles to three systems without a second thought, the reproducible build, the go install that works for anyone who cloned the repo. It’s the first thing that goes the moment C enters the picture.

singleflight in Go

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

You have an expensive, heavy function. During a traffic spike, six requests arrive at the same time asking for exactly the same thing. With no precautions, you run that function six times to get six identical results.

singleflight is a pattern that collapses those calls. The first call for a key does the real work. Every other call that arrives while it’s in progress waits and gets the same result. One execution, many consumers.

Overlapping text chunker for RAG pipelines

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

In a RAG (Retrieval-Augmented Generation) pipeline the first step is almost always the same: take a large text and break it into pieces before vectorizing. The pieces can’t be too big, because the model has a context limit, nor too small, because then the embedding loses semantics. And neighbors need to overlap, otherwise an answer that lands right on the boundary gets squeezed between two chunks and the retriever misses.

An encrypted vault in Go

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

Let’s put together the three previous pieces:

A SQLite database that lives in RAM and, on disk, exists only as an encrypted blob.

The database runs in :memory:. On exit, we take a snapshot of the database bytes, encrypt it with the password, and write it out. On startup, we read the blob, decrypt it with the password, and deserialize it back into RAM.

SQLite in RAM: serialize and deserialize in Go

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

SQLite can run entirely in memory, without ever touching disk. And there is a little-known trick: you can take a snapshot of the database bytes and load them back later, with no INSERT, no rebuilding anything. The functions are sqlite3_serialize and sqlite3_deserialize.

I will use the modernc.org/sqlite driver, which is pure Go, no CGo.

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

The catch is in SetMaxOpenConns(1). A :memory: database belongs to the connection that opened it. Without limiting it to one connection, the database/sql pool could open another one, and that one would see a different, empty database.

Encryption at rest with Go's stdlib

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

I want to store a piece of data on disk so that, even if the file leaks, it is only readable with the password and any tampering is detected.

To do this we protect the data by encrypting it “at rest”, which basically means the data is protected while it sits on disk and can only be accessed by whoever has the right password.

You can do this with the standard library alone:

Capturing Passwords in the Terminal with Go

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

Reading a password in the terminal looks trivial, but it has two pitfalls: the password shows up on screen if you use ordinary input, and you need to make sure you’re really dealing with a terminal and not a redirection. Let’s solve both with the golang.org/x/term package.

If you read with bufio.Scanner or fmt.Scanln, every keystroke shows up on screen. That won’t do for a password. term.ReadPassword reads straight from the terminal, without echo:

Neko, a cat chasing the mouse with Go and Ebitengine

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

Every programmer should write at least one useless piece of software on purpose.

Useless here in the best sense. It serves no business, will never show up in a product meeting, and stands no chance of some manager asking for webhook integration. Even so, it forces you to deal with real problems. Screen, input, timing, sprites, sound, window, operating system. A toy like that teaches more about interactive software than a pile of CRUD apps dressed up as corporate demos.

Triggers in SQLite

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

SQLite does not support stored procedures directly, but it does support triggers, which is a very useful feature for automating certain actions.

For example, automatically updating the updated_at field.

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;

Now, whenever you update a record in the users table, the updated_at field will be automatically set to the current timestamp.

Recursive Go function to access values in nested maps

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

Recently, I received a response from an API that contained a JSON with a complex, large, and nested structure. I needed to access a specific value inside that structure, but the path to that value could vary.

The idea was to create a recursive function that takes a list with the path to the desired value and the data structure (a nested map) and returns the corresponding value, if found.

Starting services with /etc/rc.local like in the 80s

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

I often use the /etc/rc.local script to quickly start services during boot. It is convenient, simple, and works well on Debian and other Linux distributions. It is essentially just an sh script (or whichever shell you prefer) that runs during boot.

Interestingly, rc.local has been considered obsolete since the release of UNIX System III in 1983!

Since then, several attempts have been made to retire this file. It has not been recommended for a long time in favor of more modern solutions for starting services during boot, but it still persists. If the /etc/rc.local file does not exist on your system, try creating it and giving it execute permission. There is a good chance systemd will recognize that you are fully old school and run rc.local normally during boot, even politely waiting for the network to come up before running it (tested on Debian and Ubuntu).

sftpdav: Remote Access via SSH with WebDAV

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

Recently, I faced a challenge when trying to access files on a machine that only allows SSH connections. Opening additional ports or installing third-party extensions wasn’t feasible due to security and compatibility issues, especially on macOS.

That’s how the idea for sftpdav came about: a program that combines an SFTP client with a WebDAV server, allowing you to access a remote directory via SSH and mount it locally as a WebDAV share.

Protecting Credentials and Configurations with an Encrypted Container.

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

I use a small pocket computer in my backpack. This device is used for testing and development, and it stores sensitive information such as credentials, passwords, and access keys. I don’t want this data to fall into the wrong hands. Unlike my laptop, which has an encrypted drive, my pocket computer’s drive isn’t encrypted. Drive-wide encryption consumes a lot of processing power and usually requires disabling SSD TRIM, which hurts performance.

LQS: A Practical Tool for Testing and Debugging SQL

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

It’s very common to need to embed SQL code strings in the source of other languages. The problem is that SQL is an interpreted language, so it can contain errors that we only notice at runtime.

Testing SQL

LQS was created to work together with Neovim and allow you to test SQL while editing, without having to copy and paste into another file or SQL client.

Test SQL with embedded metadata: Insert configurations directly in your SQL script, such as the connection string, JSON output option, or even an extra query to generate parameters. Example:

Sorting and Removing Duplicate Lines with Neovim

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

Good organization makes code easier to read. Disorganized lists make it difficult to maintain a project, and they also give your code an unprofessional look.

These two functions sort and remove duplicate lines in selected text blocks in Neovim.

The sort_lines function sorts the selected lines:

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

The sort_and_uniq_lines function sorts and removes duplicate lines:

Bookmarks in Neovim

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

I go through many files when I work, especially when debugging or tracing behaviors. I created a bookmark system in Neovim to quickly jump between files. This system differs from the default Neovim system because it focuses on marking files and lines, not just positions within the same file.

How It Works

The system records the file path and the current line in a text file. I use the <leader>o key to open all marked files. I use the <leader>m key to mark a file. I also use the :Clearmarks command to clear all bookmarks when I finish a task or start a new one.

GoScope: Exploring and Navigating Go Projects

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

I often want to quickly analyze a Go project to understand where functions, variables, and types are defined or called. That’s why I created two command-line tools: GoScope and rgs. The first scans every .go file in a project, producing a list of definitions and function calls. The second uses that list to let me navigate interactively to the exact spot in the code.

GoScope

GoScope walks through all .go files recursively starting from the current directory. It prints:

Running Remote Commands Interactively with SSH

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

I often need to run a command on a remote server without starting a full interactive session. I want the program to keep all the characteristics of a local process while running on the remote server.

At first, I just used the ssh command, specifying the server and the command to run:

ssh server command

This method doesn’t work well for programs that require a pseudo terminal, like Neovim. To fix that, I tried the -t option to force pseudo terminal allocation. With it, programs like ls display colors, but the user environment isn’t loaded. In that case, I need to pass the --color option to ls. Even so, programs like Neovim fail because the shell doesn’t behave as interactive and ANSI codes aren’t processed correctly.

Traceback in Go: How to Explore the Call Stack

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

Many programming languages provide some kind of “stack trace” or “backtrace”. Python has the traceback module, C on Linux offers the backtrace() function in execinfo.h (not part of the C standard), and Java includes Thread.dumpStack() or e.printStackTrace() for exceptions.

Stack Trace in Go

Go provides the runtime.Caller function to get information about the call stack. The following example prints the file, line, and function that called info(). Note that the argument 1 passed to runtime.Caller means we want information about the function that called info():

Data Transmission Using Sound: An Experiment with a 'Cup Telephone'

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

When I started playing with computers, the only way to load a program into the machine was to type it from scratch. My old computer had no storage; there was no hard drive, floppy disk, or any other way to store data. At startup, the machine loaded BASIC straight from ROM and that was it. Eventually I got a tape recorder, but it was terrible. With no money for a recorder made for computers, I used a household one. It took a long time adjusting the volume and other settings before I could load anything. The equipment was so finicky that I taped the controls down to keep them from moving, because the slightest change would prevent loading.

Static Compilation of the Lua Interpreter: Consistency and Portability

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

Lua is my favorite language for writing small scripts and configurations. It is easy to embed in other projects and has a clean, simple syntax. It is easy to extend and a great language for configuring systems.

I recently started a project that requires the Lua interpreter to be installed. That is usually not a problem. But to have full control, I decided to compile my own statically linked version of the interpreter. This ensures that differences in the libc version or other libraries won’t interfere with my system. I’ve run into plenty of problems with systems that failed to load because of mismatched glibc versions. Beyond the practical reasons, I believe all software should be statically compiled. The memory savings and easier updates of dynamic linking don’t make up for the problems it can cause.

Finding Program Paths on the System with exec.LookPath in Go

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

I started a new project that needs to check whether certain programs are installed on the system and get their full paths. For that, I used the exec.LookPath function from the os/exec package.

The exec.LookPath function searches for an executable in the directories listed in the PATH environment variable. If it doesn’t find one, it returns an error. So I created the programPath function, which takes the program name and returns the executable’s path and a boolean indicating whether the program was found.

Optimizing Message Integrity Checks with FNV-1a in Go

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

In the article HMAC (Hash-based Message Authentication Code), we saw how that technique ensures a message was not altered in transit and confirms the validity of the signature.

However, while secure, that process is slow and resource-intensive. When we only need to verify message integrity without validating a signature, we can use a faster hash function. For that, we will use the FNV-1a (Fowler-Noll-Vo) algorithm, known for its speed and low collision rate.

mTLS: Implementing Mutual Authentication Between Client and Server in Go

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

mTLS (Mutual TLS) authenticates both client and server. Each one presents a digital certificate signed by a trusted certificate authority. By controlling certificate issuance, you ensure that only authorized clients access your service. It also makes it easy to identify the client without needing an API Key or Token. I also recommend using an HMAC (Hash-based Message Authentication Code) header as an additional layer of security and message integrity.

Creating Certificates

In this example, I’ll create the certificates in a simple way for local testing. When deploying to production, be careful with the parameters you use. It’s important to include Subject Alternative Names (SANs), since relying on the CN (Common Name) alone is no longer recommended.

HMAC (Hash-based Message Authentication Code) in Golang

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

When building APIs, it’s a good idea to add an authentication header to guarantee message integrity. For example, when your server sends a request or a webhook, include an X-Signature header with an HMAC (Hash-based Message Authentication Code) signature.

To generate the HMAC signature, you use a secret key and the content to be signed, such as the request body, and send the signature in the header. It’s important to make clear exactly what is being signed. I’ve run into problems with clients who couldn’t validate the signature because they used the body parsed as JSON instead of the raw body received in the request.

Safe JSON Validation and Integration in Go APIs with json.RawMessage

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

I recently built an API where the user sends a JSON value in one of the fields. The requirement was to log invalid JSON errors but let the rest of the data continue through the system’s normal flow.

It was also important that, if the received JSON was valid, it would be integrated seamlessly into the API responses. Since the JSON could vary and I didn’t know its structure, I used json.RawMessage as the field type. That way, when calling json.Marshal, the data is correctly embedded into the main JSON.

Fork Bomb: From Code to Defense

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

The first time I heard about fork bombs was a long time ago. Although I found it fascinating that a piece of code could spawn two more processes of itself, causing exponential process growth and eventually freezing the system, I didn’t believe it was a viable attack until I discovered how many systems are vulnerable to code injection.

What is a fork bomb?

In general terms, a fork bomb is code that spawns processes recursively. The first process spawns copies of itself, those copies spawn more copies, and so on, until the system runs out of resources and freezes. The result is a DoS (Denial of Service) attack.

Manipulating Special Permission Bits

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

In the article on Privilege Reduction in Programs, we used the sudo command to run a program with superuser privileges. However, it’s possible to do this without an external command.

For that, we use special file permissions known as the setuid bit and the setgid bit. These attributes allow files to be executed with the privileges of the owning user or group.

To set the setuid and setgid bits, we use the chmod command with the u+s and g+s options, respectively.

Dropping Privileges in Go Programs to Improve Security

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

A good practice for improving the security of a system is to drop a program’s execution privileges. Ideally, a program should run with the fewest privileges possible.

On UNIX-like systems, you can change the user and group a program runs as. Let’s walk through how to do that in Go.

Checking Whether the Program Is Running as Root

First, check whether the program is running as root. This matters because we’ll use system calls that require root privileges. (There are other ways to grant these privileges, but we’ll cover that in another article.)

References in Comments with Golang

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

A quick tip about comments in Go: include references in them. Put the element you want to reference between brackets ([ and ]). It works with anything that can be referenced, such as variables, constants, functions, and so on.

Here is an example:

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))
}

In Neovim, place the cursor between the brackets and press Ctrl-] to jump to the definition of the referenced element. To go back, press Ctrl-t. In VSCode, use the Go to Definition extension to do the same thing.

Plasma Effect in the Terminal with Golang

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

One kind of program I’ve always found interesting is the demo: eye-catching graphical effects with code that squeezes every ounce of performance out of the machine. The plasma effect is one of my favorites, simulating a fluid in motion.

To create the plasma effect, I use several trigonometric functions to calculate the background color of each character, passing time as a parameter to generate the animation. The code is relatively simple, but the optimization is a bit more complex.

Happy 2025, Fireworks in the Terminal with Golang

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

A small program celebrates the arrival of 2025 with fireworks in the terminal. It includes several interesting tricks to start your year with plenty of code.

We use os.Stdout.WriteString to write directly to the stdout descriptor, that is, the terminal’s standard output. This is the fastest way to write to the terminal, but it is not synchronized. That means there is no guarantee the output will be written in the expected order. In our case, though, this is desirable because it lets the fireworks overlap, giving the impression that they are exploding simultaneously.

Rewriting the Old TSR Using Bash

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

When I started programming, computing was different from today. The operating system was single-tasking; only one program could run at a time. There were no modern features like protected and mapped memory. Even so, it was possible to create concurrent behavior in programs, but you had to be careful to keep any part from blocking execution. For example, there could be no loops waiting for keyboard input or very long processes. Writing a non-blocking program was tricky in languages like Clipper.

Deploying an API Behind a Reverse Proxy with Caddyserver and Go

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

A friend asked me for an example of how to deploy an API behind a reverse proxy using Go. Here is a short walkthrough.

First, set up a server and register its IP with your DNS provider. Assign the IP to a name so you can create an HTTPS certificate for the machine.

Configure the machine’s firewall and open only ports 22 (SSH), 80 (HTTP), and 443 (HTTPS).

Caddy

I use the Caddy HTTP server. It is practical and creates HTTPS certificates automatically. By default, it redirects HTTP requests to HTTPS.

Benchmark: Named vs Explicit Returns in Go

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

A question came up in our Go study group: are named returns faster than explicit returns? That was the hypothesis.

Fortunately, Go has good tools to test this.

Let’s write some code with two sum functions: one with named returns and one with explicit returns.

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
}

Next, we create the benchmark functions. The names of these functions matter. Go’s testing tool looks for functions that start with “Benchmark”.

Writing About Computer Programming

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

Writing about programming and computing is challenging. These topics are complex, and it is hard to build a narrative that is both understandable and interesting.

On top of that, Portuguese is a demanding language. I tend to write the way I speak, which results in texts that are hard to read.

To make things easier, I created a few rules that serve as a guide. They are not strict, just guidelines in no particular order.

Customizing Neovim: Sorting and Removing Duplicate Lines with Lua

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

Continuing my Neovim customizations, here are two functions I use frequently: sort_lines and sort_and_uniq_lines. As the names suggest, they sort the content of the selected lines and, in the case of sort_and_uniq_lines, also remove duplicates.

function sort_lines()
 -- Get the start and end position of the selection
 local start_pos = vim.fn.getpos("'<")
 local end_pos = vim.fn.getpos("'>")

 -- Convert the position to the line index

 -- Adjust start_pos because lines in Lua start at 0
 local start_line = start_pos[2] - 1
 -- No need to adjust end_line
 local end_line = end_pos[2]

 -- Get the selected lines
 local lines = vim.api.nvim_buf_get_lines(
 0,
 start_line,
 end_line,
 false
 )

 -- Sort the lines
 table.sort(lines)

 -- Replace the original lines
 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)

 -- Remove duplicate lines
 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

Building a Bookmark System in Neovim with Lua

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

Continuing our series of articles aimed at reducing the cognitive effort involved in programming tasks, here is my small bookmark script for Neovim.

Neovim is incredibly customizable. Without having to build full plugins, you can add a lot of functionality with just a few Lua functions.

In my day-to-day work, I often need to return to the same files to fix and test problems. Opening those files directly at the right line, without wasting time navigating, is essential.

A Script for Fast Directory Navigation Using fzf

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

This article presents a script to make directory navigation faster, continuing the series on reducing cognitive complexity.

You often need to move between several directories in one or many projects. Remembering paths and locating files becomes an unnecessary effort.

One solution is to keep a list of the most recently visited directories so you can switch between them quickly. Dave Eddy implemented this idea in his cdstack.

Inspired by that approach, I built my own version, better suited to the way I work.

Reducing Cognitive Complexity in Programming

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

I spend a lot of time and effort reducing cognitive complexity when I program.

Cognitive complexity is how much you have to think to get a task done. Small details can make a task unnecessarily complex.

For example, finding a snippet of code hidden among many files inside a large directory structure takes effort. Even if the structure is familiar and well designed, the goal is not to navigate through it opening files until you find the code to edit; the goal is simply to edit the code. Anything beyond that is wasted cognitive effort.

Restructuring Articles for Clarity and Concision

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

I’m restructuring how the articles on this site are written.

I usually write the way I speak, which some people find pleasant. That said, my love-hate relationship with the Portuguese language sometimes makes my texts hard to follow. I also tend to go on too long when explaining reasons and concepts, which makes the text dull.

As a writing exercise, I’m reviewing my texts. I’m fixing spelling and grammar problems and making the content more direct.

A Virus in the Lab

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

This story goes back to the first half of the 2000s. At the time I worked at a company that built hardware for telephony.

It was a lot of fun. I had access to some nice NEC machines and wrote some really interesting code.

That was when I wrote a VoIP recorder that captured SIP packets directly off the network, in less than 100 lines of C, but that’s a story for another day.

Programming as Art

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

I consider programming computers a form of artistic expression. There are many ways to solve everyday programming problems, which leaves plenty of room for creativity.

Classic Examples of Generative Art

And there are many interesting examples of computer-generated art. My favorites are the “one-liners”, programs of just a single line that do interesting things, like the famous 10 PRINT CHR$ (205.5 + RND (1)); : GOTO 10 that draws a maze using BASIC, and the more modern equivalent yes 'c=(╱ ╲);printf ${c[RANDOM%2]}'|bash written in Bash. A quick search on the internet will turn up several implementations in different languages.

Generative Art in JavaScript for the Sides of the Site

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

After a long time, I finally added some JavaScript to this site.

I have a huge mental block when it comes to web technologies. JavaScript, CSS, and even HTML itself feel very improvised to me, especially the whole idea of the “single page application”.

This is a limitation I need to get over. After all, these days the web really is the best and most portable interface for most programs, even though it goes against a lot of what I believe about minimalism and saving resources.

Post-Apocalyptic Computing

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

Post-apocalyptic computing is a game, an interesting exercise for your imagination. The scenario goes like this: something terrible has happened and the society you live in no longer exists. As a survivor, it’s up to you to help rebuild modern society.

The cause of the apocalypse can be whatever you like: nuclear war, plague, economic collapse, a solar storm, an oppressive government that wants to keep technology to itself, and so on. The only constant is that nothing you take for granted is available. All the infrastructure is gone. There’s no more running water, no electricity, none of the amenities of modern life.

Building My Own System to Tell Time

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

Measuring time is a serious task, and more complicated than it seems. Like any good nerd, I’m fascinated by the many ways of measuring and counting time. One that really catches my attention is “decimal time”.

There are several implementations of decimal time, usually dividing the day into 10 hours of 100 minutes each. Another approach is to ignore hours altogether and use only minutes as a continuous number. If you need more precision, you just use fractions of that minute, with as many decimal places as you need.

Deploying Applications Using curl

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

Small teams face several challenges when distributing binaries these days. If you simply put an application up for download on a website, search tools will immediately flag your site as suspicious content. Browsers show the user a scary warning, and there is no way to remove it, even with a signed binary. The warning only goes away once enough users have downloaded your binary without reporting problems.

Letting the user download the binary from some already well-known site, even GitHub, isn’t ideal, especially for closed-source applications.

ps - process hierarchy

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

When I started using compterm, a problem soon appeared: sometimes I forgot that compterm was loaded. So I wrote a small function to detect whether I was in a session started by compterm or just a regular zsh session.

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
}

This function walks through all the parent processes of the current process, and if any of them is named compterm, it returns true. With that I can customize the prompt and tell whether compterm is loaded or not.

Studying Assembly

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

When I started programming, back in the 8-bit era, learning a bit of assembly was unavoidable. The machines were far simpler than today’s computers, and we often didn’t even have a compiler at hand. Instead, we typed small chunks of opcodes directly in hexadecimal.

This was incredibly useful for working around the limitations of the BASIC that served both as a programming language and as the operating system (burned straight into the machine’s ROM).

Hidden Files on UNIX

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

Everyone knows how to create hidden files in the UNIX/Linux world: just start the file name with a dot (.). But this feature wasn’t always there.

According to Rob Pike in a Google+ post that is now only available on archive.org, around version 2 of UNIX, while the Unix file system design was being worked on, the “.” and “..” entries appeared to make directory navigation easier. This probably happened in version 2, when the file system became hierarchical.

Why Is My Site So Ugly?

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

Update

I was recently convinced to try a more modern theme, so I’m experimenting with a new one while keeping the same philosophy of accessibility and simplicity. And, for a change, a light theme. On top of that, I added some JavaScript, as incredible as that may sound.

There’s always someone asking why my site is so ugly. It has sparked plenty of laughs and usually serves as a hook for good conversations. But since I’ve been asked about it so many times, it’s worth leaving a written answer for anyone who isn’t close enough (or shameless enough) to ask me directly.

AI-Assisted Programming

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

We have recently seen an explosion in the use of artificial intelligence (AI), with products like ChatGPT, GitHub Copilot, Tabnine, and many others. They are very useful and interesting tools, but not as much as the media claims.

Think of these tools as a machine that predicts which word is most likely to come next, adds it to the suggestion, and does this repeatedly in a loop until it reaches a certain number of words or until the probability of a good guess drops below an acceptable threshold, whichever comes first.

Writing Software That Lasts

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

Here I’ll present some topics that I believe are important when developing software so that it’s highly resilient and lasts for many years. The topics are in no particular order and reflect my opinion, grounded in my experience as a developer.

Treat this text as a collection of ideas I’ve gathered over the years. I tried to keep them as generic as possible, but I don’t claim they apply to every scenario. I think they fit best if your team is small and you need to ship fast.

Go and Rounding Errors

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

When we write programs that deal with money, the ideal approach is to always use cents. That way we can use integer variables, and it’s much easier to prevent errors caused by how computers store floating-point numbers.

But we don’t always get to choose. When we consume third-party APIs, for example, best practices aren’t always followed. In fact, in day-to-day work, ideal conditions are a rarity.

Not long ago I ran into a problem like this: an API my system needed to consume returned a JSON where the value field was not only a string but also a floating-point number.

Go and the promise of backward compatibility

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

When version 1.0 of the Go language was released, its developers made a commitment to maintain backward compatibility as new versions came out.

This commitment brings several interesting results. For example, the code you learn doesn’t become outdated. On top of that, keeping the language backward compatible reinforces another important commitment: simplicity and readability of code. That project that sat untouched for months, maybe years, still compiles on the first try. I experienced this personally with code that sat in a drawer for three years.

CPBR14, Wardriving

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

Useful links for the workshop “Wardriving - A brief introduction, equipment, and software” at Campus Party Brazil 2022.

Cesar Gimenes

Phone GPS on the Raspberry Pi

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

I need the Raspberry Pi I carry in my backpack to have access to GPS coordinates, but the USB GPS units and other models available for the Raspberry are too unreliable and expensive.

The solution is to use the phone’s GPS and share the data with the rest of the gear. This has several advantages: the phone’s GPS is excellent, it has usually already locked onto a few satellites, and on top of that I already have it on me, so I don’t have to buy anything extra.

tr - A Utility for Replacing Characters

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

This is a simple and very useful utility. Basically, tr filters strings one character at a time, and when used correctly it is even UTF-8 compatible.

Character filtering is defined by the parameters, and to make things easier you can use character classes, for example [:upper:] for all uppercase letters or [:cntrl:] for all control characters.

Parameters

The parameters I use most are the following:

-d delete to remove characters.
-s squeeze, which is quite handy for collapsing sequences of repeated characters.

Examples

Converts uppercase to lowercase, but fails with UTF-8 characters.

fmt - A Simple Text Formatting Utility

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

The fmt utility is a simple, fast text formatter. Its purpose is to format text files or strings received via stdin so that lines don’t exceed the maximum number of characters per line defined by the user.

It was originally intended to be used together with the mail utility, but it can be useful alongside other programs such as vim, for example.

The main parameters are:

-w, which sets the desired number of characters per line.
-t, which sets the tab width.

There are several other useful parameters; check your system’s manpage to learn more.

Socket Client and Server in Golang: A Chat Example

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

This is the fourth version of our socket client and server. In this version, I made some interesting improvements. We now have a complete chat system with useful commands and a few optimizations.

The goal of this version is to refine the system. I removed one of the write channels to send data directly, increasing efficiency. I also dropped the automatic reconnection to keep the code cleaner, since I added several new features.

Assembly on macOS M1/ARM64.

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

Here is the story. I had found a great deal on two early-90s computers still running Zilog Z80 processors. They weren’t in perfect shape, but the price was fine.

Then a good friend, with far more common sense than me, advised me to stop wasting energy and money on old hardware. To cool down this nerd fever, he suggested I study ARM assembly instead, since it could at least be useful.

Socket client and server in Golang with signal handling.

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

Continuing our series of articles about client/server, we will add a new channel to the previous example. This channel will handle signals sent by the operating system.

The operating system sends signals to programs to manage processes. For example, when you press Ctrl+C, the operating system sends the SIGINT signal, telling the program that the user wants to interrupt it.

By default, the program is closed. However, we can intercept this signal and act accordingly. In this case, we will simply terminate the program. In real systems, this feature can be used to save information before closing, stop other processes, close connections and files, and so on. This process is known as graceful shutdown.

Socket Client and Server in Golang with Ping and Pong.

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

Continuing the conversation about a resilient client and server, it’s time to improve the server and add the sending of ping or keep alive messages.

We also made improvements to the server. Now, just like the client, it uses goroutines and channels.

Server

Reading from the Connection

In this version, the server uses one goroutine to write and another to read the data from the client connection. When using goroutines and channels this way, it’s essential to make sure the goroutines are properly terminated.

Socket client and server in Golang with goroutines and channels.

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

Continuing the example about a persistent socket client in Golang, I made a few changes to the source code to show how to improve our code and make it asynchronous. To do that, we’ll use goroutines and channels.

Goroutines and Channels

Goroutines and channels are advanced features of the Go language. Goroutines are lightweight threads managed by the language runtime itself, and channels allow communication between goroutines.

In our case, we’ll use channels for communication between the goroutines in our program.

Socket Client and Server in Golang.

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

In the Go study group, a question came up about how to write a persistent client that reconnects to a socket server whenever the connection fails.

The main difficulty people seem to have is understanding the concept of a state machine. So we’ll build a few examples of a persistent client, starting with a simple state machine, without goroutines or channels.

Before that, we’ll create a small socket server for our client to connect to: the famous echo server.

Make Your Linux Less Secure and Slightly Faster

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

First, of course, don’t hold me responsible for what you do to your system — the responsibility is entirely yours.

There are several processing strategies that, despite producing a substantial performance gain, ended up introducing security flaws. What I did was take two machines from my cluster and configure the Linux kernel not to disable those features.

In my case, since I use Debian, I edited the file /etc/default/grub and added mitigations=off at the end of the GRUB_CMDLINE_LINUX_DEFAULT variable.

Remote Clipboard

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

Tip: The pbcopy command on the Mac is equivalent to xclip -selection clipboard on Linux. The pbpaste command on the Mac matches xclip -selection clipboard -o on Linux. The xclip command doesn’t work because it requires X Window installed.

Copy and Paste

I edit a lot of code on remote servers over SSH, with no graphical interface, usually with Neovim. It would be great to copy and paste between the remote machine and the local one. Pasting from the local machine to the remote one is simple, since the terminal already handles it. Copying from the remote machine to the local one, however, takes a bit of code.

Speeding Up the Site

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

To share my articles over IPFS, it made sense to embed the CSS and images directly into the HTML so that there would be a single file to share.

Embedding the CSS was the simplest part: I just placed the CSS directly into the site template using the <style></style> tag, and embedding the CSS alone already produced a nice speed gain.

I use HUGO as the framework to generate the site automatically. HUGO works by converting pages written in Markdown, but the same idea applies no matter how the site is built, even if it is written by hand, directly in HTML. With HUGO and a bit of programming, though, it was easy to automate my template and have the images converted to Base64 and inserted into the page automatically.

How to Extend Git

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

Git is an extremely flexible tool and very simple to extend and build features on. To create a command, you just need an executable named git-command (git dash followed by the command name).

Any executable on the PATH that follows this naming pattern will be called by git. To start with a simple example, let’s do the traditional “hello world”. Save the example below as git-hello in a directory on the PATH.

Headless VirtualBox

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

WIP - This text is a work in progress. I haven’t documented all the examples I wanted to yet, nor have I reviewed the text. Contributions are welcome.

Continuing with the project of building a machine cluster, I’m going to need some kind of virtualization system, because not all of the experiments I want to run can be done with containers alone. I did a few tests with QEMU, but for now it’s more practical to stick with VirtualBox.

How to Shrink Your Container Using Multi-Stage Builds

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

Every now and then I run into some huge Docker image where 99% of the size is junk left behind while the image was being built. This is especially bad when we’re dealing with Go executables, which are self-contained and usually don’t need any external resources, not even libc.

multi-stage builds

The solution is to use multi-stage builds. This way you can have two stages in your Dockerfile: a build stage that downloads whatever is needed, compiles the code, and so on, and another that just copies the executables and resources to their expected locations. This second stage doesn’t even need to be based on a distribution; it can be a scratch image, which shrinks the final size even further.

auto-cpufreq: dynamically adjusting CPU frequency

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

auto-cpufreq optimizes CPU frequency and reacts quite fast. It’s great for stretching battery life on a Linux laptop.

In my case, I use it to keep my small home server at a milder temperature, and in practice I haven’t noticed any real impact. There’s a bit of latency when the machine is “cold” and I suddenly start some heavy process, like opening an SSH+mosh+zsh session.

Installation

git clone https://github.com/AdnanHodzic/auto-cpufreq.git
cd auto-cpufreq
sudo ./auto-cpufreq-installer

Track CPU core frequency and temperature with the following command

First steps when setting up a new server

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

Whenever I bring up a new machine I always run a few commands and set up some configuration. A lot of it is already handled by my dotfiles, but there’s always plenty of custom work left to do.

The first thing is to get SSH access and make sure the root password isn’t the default one.

Next I give my user sudo access, in case it doesn’t have it already.

usermod -aG sudo ${USER}

If it’s a machine on the local network, I set it up to use zero configuration network, a much more convenient way to reach the machine, especially on IPv6 networks. Otherwise, this is a good time to add the machine to a domain.

The UNIX Manual

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

On November 3, 1971, the first version of the Unix Programmer’s Manual was released, commonly known as man pages.

You can download it as PDF or PostScript from Dennis Ritchie’s page at Bell Labs, maintained by Nokia for historical reasons.

It’s interesting how UNIX commands haven’t changed much over the years. If you’re a Linux or BSD user, you’ll certainly recognize most of them. It’s also remarkable how such a simple idea can be so incredibly useful.

A find command tip

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

I use the find command a lot to look for files, whether in bash scripts or straight from the command line.

An interesting trick is excluding some files from the list. For example, I recently needed to look for all “.md” files but wanted to exclude everything starting with an underscore, as well as the “default.md” file.

To do that I used the -not parameter before the -name parameter, as in the example below.

Setting HTTP Request Timeouts in Golang

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

By default, Go doesn’t set timeouts for HTTP requests, which can cause a number of problems and vulnerabilities. A DOS attack, for example, could simply open a large number of connections to your server.

To fix this, create an instance of the http.Server struct and fill in the WriteTimeout and ReadTimeout fields with values you consider appropriate.

Here’s an example:

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())
}

This sets the default timeout values for all HTTP requests.

Session Control in Golang with Gorilla Sessions

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

Session control is a fairly old concept: cookies hold some data about the user’s session. For security, we usually only keep a UUID in the cookie, as random as possible, which the server then uses to look up other data, such as which user is logged in.

The UUID needs to be as random as possible, because if someone can predict the next UUID, they can hijack a legitimate user’s session.

Finding the IP with Golang

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

I recently ran into an interesting problem: I needed to stand up a small REST service to manage some hardware, all without human intervention and with multiple network interfaces involved.

At some point my system has to bring up an auxiliary service and tell the client which IP and port to connect to. Normally you’d handle this with a config file somewhere, but one requirement was that I couldn’t assume my own IP, since it could come from any of the network interfaces, and making all of that configurable would get too complex.

Differences Between Slice and Array in Go

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

Array

Arrays in Go always have a fixed size.

When you add a new element to an array, what happens internally is that a new array is created and the old and new items are copied into it. Eventually the space occupied by the old array gets freed by the garbage collector. So it’s important, whenever possible, to declare the array with the maximum size it will need and avoid appending items, especially inside a loop.

The Problems with Programming in Golang

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

I love Go. I choose Go for many of my projects. It’s simple and robust, with extensive documentation, plenty of examples, and a rich standard library focused on solving today’s problems. It’s without a doubt an excellent language.

However, nothing is perfect. Golang has its problems, like any other language. Some will be solved as the compiler evolves. Others, the programmer needs to watch out for. Let’s look at some of the most common ones. Some of the issues mentioned here aren’t exclusive to Go, but rather the result of bad code design that I’ve run into many times and that’s worth mentioning.

Variable Shadowing in Golang

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

Go is an easy language to work with, and it helps you avoid a lot of common mistakes.

But one mistake that’s easy to make in Go, and that the compiler still doesn’t warn you about, is variable shadowing.

Shadowing happens when you declare a variable in one block and then declare it again, with the same name, in a nested block.

You then change the value of the variable believing you’re updating the one from the outer block, but you’re actually only changing the variable in the current block.

First steps with assembly

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

Every Thursday, a group of programmers and I get together to talk about Go in the Go Study Group. We should probably rename it Technology Study Group, since we end up discussing pretty much everything.

One topic that keeps coming back is assembly programming. We’ve talked several times about putting together demos and toy programs loaded from the boot sector, known as “boot sector games.”

Besides being fun, it’s a good way to teach how a computer works internally. Concepts like access speed, Lx cache, and others stay abstract in high-level languages.

Web Scraping with Golang

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

I recently needed to extract some information from a website. My plan was simple: find the URL the search form pointed to, make the request directly from my program, then use the goquery package to parse the results and pull out the data I wanted.

Of course it wasn’t that easy. The site I wanted to crawl was full of JavaScript that interfered with the form, with the cookies, and with basically everything.

A Small 8086 CPU Emulator

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

8086 Emulator Written in C

The first thing to make clear is that this is not a complete emulator. The goal is only to interpret a hello world. Of course, you can take this skeleton and expand it into a full emulator.

I was bored waiting for my friends to show up at Campus Party 2016. I found the table set aside for the hackerspace crowd and sat there waiting, but since there were no talks at that hour and nothing else I wanted to attend, I needed something to kill time.

Home Office, My Experience Working from Home

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

Here I’ll go over a few things from my experience working from home, along with some tips on how I solved the common problems that anyone who wants to work in tech away from the office will run into.

I’m a veteran when it comes to remote work. I started in the late 90s, back when I worked at a company with a bold, modern management style, especially for Brazil at the time. I was a young programmer with a lot still to learn.

BASIC Is Still Alive and Kicking

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

While researching BASIC implementations, I found some interesting things. It’s amazing that a language this old, and with this many problems, still exists. You can even find commercial compilers still under active development for it.

Yes, even though I’m a fan and love playing with BASIC for the nostalgia and the fun, there’s no denying that BASIC causes more problems than it solves. (In my opinion)

Of course, an extremely simple language made sense when BASIC was born, in 1964. Machines had few resources, and the goal was a language for beginners. BASIC stands for Beginner’s All-Purpose Symbolic Instruction Code

A Tricky Bug with Interfaces and Switch Cases in Go

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

Watch the video about this bug on the Golang Study Group channel (in Portuguese).

Golang is an easy language to program in, and it has few traps for the programmer. Most things that can go wrong are caught by the compiler or by one of the many static analysis tools that help keep our code almost bug free.

But there are situations where even those tools have a hard time warning us, because there is no way to know what the programmer expected the program to do. This usually happens when you use the more entertaining features of the language, such as switch, interfaces, channels, and goroutines.

Unit Test Coverage in Go

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

Unit tests are incredibly important, even for a compiled language like Golang.

Fortunately, most programming languages today have a good variety of unit testing tools. Go ships with some surprising ones, not just for running tests but also for analyzing code to find coverage gaps.

A quick, visual way to analyze test coverage is to write a script around go tool cover and load it in zsh or bash, which makes inspecting the code very simple.

A Quine Implemented in Golang

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

Printing your own source code

A quine is a program that prints its own source code to standard output. The name is a tribute to the mathematician and philosopher Willard Van Orman Quine.

There are quine examples written in many programming languages. Writing your own version is an interesting exercise and a nice challenge.

Keep in mind that the rule forbids simply opening your own source file and printing it — that would be cheating. Your code has to generate a copy of itself on standard output without reading it from anywhere.

PostgreSQL over SSL with Golang

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

Creating the certificate

First, let’s create a test certificate. Of course, in production you should use a certificate issued by a recognized certificate authority.

The command below creates two files, server.crt and server.key, which we will use to configure PostgreSQL.

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

Configuring PostgreSQL

Edit the postgresql.conf file to enable the SSL key.

ssl = on
ssl_cert_file = 'server.crt'
ssl_key_file = 'server.key'

Restart the service and test the connection with the following command:

Unix Domain Sockets with Golang

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

Unix Domain Sockets or IPC Sockets

Unix Domain Sockets are a practical and secure way to exchange information between processes. This form of IPC (Inter-process communication) uses a file as the address instead of an IP and a port, as network communication does.

Keep in mind that the server manages the file. If the file does not exist, the server creates it automatically. If the file already exists, you get an error such as “bind: address already in use”, meaning the server cannot reuse the existing file. So it is good practice to shut the server down gracefully, closing and deleting the file before the server exits. Depending on the system, it may also be worth checking whether the file exists and deleting it before starting the server.

A JSON Lint in Golang

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

Watch the video about this file here.

A JSON Lint in Golang

This is a small command line utility to validate and format JSON that can also be used as a package. The original idea was to write a parser to validate the JSON, but that turned out to be unnecessary: Golang itself gives us everything we need in the error, including the offset where it happened. From there it was simple to display errors in a more complete way, with an arrow pointing at exactly where the problem is.

Passing Data Between HTTP Middleware Using Context in Golang

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

Watch the video for this article here.

Passing data between middleware

We have already seen how HTTP middleware works, so now let’s look at how to pass information from one middleware to the next. This is used, for example, to hand a user’s credentials to the next middleware, or any other information collected in one middleware that you want to forward.

First, let’s write an example that shows as clearly as possible when the middleware run. This matters a lot, because misunderstanding the execution order is an incredible source of bugs. In the example below we print a message to the terminal every time a middleware is pushed and popped. And it’s worth stressing: this happens in the same order in which they were registered.

How to Write HTTP Middleware in Golang, Both with Negroni and with the Standard Library

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

You can watch the video version of this article here.

HTTP middleware is very useful for avoiding duplicated code when your application has several endpoints — for example, when you want to make sure the user’s credentials have been verified, or that the content has been compressed, and so on.

The most important thing to keep in mind is that each middleware runs in the order it was registered. So you can have a middleware responsible for setting up the environment, such as opening the database or preparing session handling, that runs before the middleware validating the user’s credentials.

Using goto and labels in Go

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

The goto statement has a bad reputation. Back in the BASIC days programmers did not have many options, so they abused goto and wrote confusing code. Modern languages like Go use goto with judgment and improve code clarity.

Go lets the break and continue statements use labels. Use labels to break out of nested loops or to continue a specific loop. Using break or continue with labels is equivalent to using goto.

An Extremely Fast Messaging System with NATS and Golang

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

Watch the video for this article here.

Messaging with NATS

If you need several systems talking to each other with speed and simplicity, NATS is a great help. One of its most interesting traits is its incredible speed, and its simple protocol is easy to implement, so NATS shows up everywhere from IoT — there are client libraries even for Arduino — to communication between much larger services. It is also widely used in mobile applications for the same reason: a simple, fast protocol. It is a very interesting alternative to MQTT, and it is implemented in Go. :D

Protocol Buffers

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

Watch the video for this article here.

This is the first in a series of quick tutorials where I plan to cover gRPC and various aspects of it, such as testing, TLS, best practices, and much more.

To get started with gRPC we need to go all the way down to the foundation, so let’s talk about Protocol Buffers first.

Protocol Buffers is a simple, language-agnostic way to define a data structure. Think XML, but better, simpler, and faster — much faster.

ssh - Using access keys

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

Watch the video for this article here.

Accessing servers over SSH with a public/private key pair is safer and more convenient — safer above all — and it also makes automating tasks much easier.

Creating the keys

First, generate the keys with the following command:

mkdir ~/.ssh
ssh-keygen

You only need to do this once on the client machine, and a key pair will be generated. You can choose the file name, which defaults to id_rsa for the private key and id_rsa.pub for the public key.

JSON, Writing Your Own Marshal and Unmarshal

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

Watch the video for this article here.

Postgres’s default date format is incompatible with Go’s default format, and our system uses JSON heavily to both send and receive information from the database.

Having to remember to parse the date into the correct format every single time simply isn’t practical. It’s much better to teach Go how to handle dates and times in good old ISO 8601.

By the way, I highly recommend always using ISO 8601 UTC for everything in the backend, and only switching to the local format and timezone when displaying it to the user. But that’s a story for another day.

Interfaces as contracts

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

Watch the video for this article here.

We covered this same topic in the example list of our study group on interfaces, but that was back in the distant year of 2016, so let’s build a new example showing how to use an interface as a contract. The contract lets you pass different types to a function, or accept different types through an interface, as long as they implement it — in other words, as long as they implement the functions described in the interface.

Using a VPN on macOS

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

Like any tool, a VPN is only effective if you know exactly which problem you want to solve with it. Some people want to keep their internet traffic anonymous, others want to protect their data, and so on. My own use is very specific: some internet providers are blocking important ports I need to reach certain services. For example, a well-known provider here in São Paulo is blocking TCP port 22, the one we use for SSH. Note that this is not the provider blocking incoming connections, which was already common, but outgoing ones — meaning that using any service that depends on SSH, like GitHub, or reaching a machine hosted on Google Cloud Platform’s Compute Engine becomes impossible.

The Empty Interface

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

Watch the video for this article here.

The empty interface is a type that accepts anything. You can pass whatever you want as a function parameter or store it in a variable of type interface{}.

At first glance this looks convenient, but when we use interface{} we throw away the type validation done at compile time and lose one of the great advantages of a compiled language with strong, static typing.

JSON Tips and Tricks

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

Watch the video for this article here.

Converting and validating JSON

It’s always good to check whether the JSON is valid first. That saves you debugging time chasing a problem that isn’t in your code. A good online tool for this is JSONLint.

Another great online tool is JSON-to-Go, which converts JSON files into Go structs. It won’t factor repeated parts into sub-structs, but it helps a lot, especially when the structure is large and complex.

MS-DOS, APM with C and Assembly

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

Watch the video of this article here.

For retrocomputing fun, I use VirtualBox with MS-DOS 6.22 and DOSBox. Both work very well, but the screen looks a bit better in VirtualBox, and DOSBox is faster and easier for developing and switching quickly between systems. So I use both.

In DOSBox, you can close the emulator by typing the exit command. That closes a command interpreter session and, if it is the last one, closes DOSBox itself. It is convenient because you do not need the mouse and it behaves more like a terminal.

Accessing Dropbox with Golang

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

I needed a Golang package to talk to Dropbox and perform a few basic operations — listing files, uploading, and downloading. For that I used dropbox-sdk-go-unofficial.

Connecting to Dropbox

To connect to Dropbox you need access credentials. The easiest way is to create a token: go to Dropbox developers apps, create an application, and then generate the token from the application’s panel.

Configuring the system

Every function needs the configuration with the access credentials and other useful parameters, such as the log level. So we create a function that returns an instance of the config struct.

Editing Command Lines in the Terminal

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

I use the terminal a lot. It is amazing how the good old command line interface cli is still relevant, and still simply the fastest way to command a computer despite so many years of progress in computing.

We just haven’t found a better way to enter commands yet. Over time, though, those commands have grown into what are practically small programs, sometimes several lines long, and sometimes containing things that are hard to edit, like regular expressions.

Static Compilation with Golang

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

Building monolithic executables

Watch the video for this article here.

Golang already does a good job of statically compiling almost everything, but depending on your code you may need a few extra flags to make sure your executable is completely free of dependencies.

The first step is to build your project and then inspect the binary to see whether it has any dependencies.

On macOS, use the otool utility (object file displaying tool) with the -L flag (which lists the shared libraries in use), like this:

Accessing the Serial Port

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

Watch the video for this article here.

To me, one of the most interesting things is that the developers deliberately left out some features that screen has, such as telnet and serial port support. They did it because they believe in the UNIX philosophy of doing one thing and doing it well. In my opinion, they are absolutely right.

A few ways to access the serial port

No matter which method you pick to open the serial port, remember that it is meant to be accessed by only one program at a time. For another program to use the same port, the first one has to close it. This happens a lot when you forget an Arduino serial terminal session open.

A horror story for programmers

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

Many years ago there was a very famous Linux mailing list where everybody hung out. But those were the early days and things were nowhere near as robust as they are today. Mailing lists were still the main way to exchange information because nobody had a 24/7 connection like we do now: you dialed in, downloaded your email, read everything offline, wrote your replies, dialed in again and sent them. Very rough around the edges, but it worked.

Golang: Playing with Bits

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

Playing with bits

The idea is to manipulate the CGA color palette, which stores colors in a single byte. This may look complicated, but it is actually very simple: we only need to learn a handful of operations to manipulate bits.

Before we start, let’s agree on the following: when I talk about the upper or high part of a set of bits, I mean the leftmost bits, and when I talk about the lower or low part, I mean the rightmost bits. It is not always like this, but for the purposes of this text that is how it works — this is what we call lite-endian

Golang defer tips

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

Using defer to postpone a command until the function returns, no matter how it returns, is an excellent idea. Imagine a function with several return points, either for errors or for a successful finish. Managing the closing of files, connections, mutexes, and other resources at each return becomes tedious and unsafe. You may forget to close a resource on some return path, and that can cause serious problems.

However, using defer has a cost. The runtime pushes the deferred command onto a stack, and deferring it is a few nanoseconds slower than a direct call. That is usually not a problem day to day, but if you need to squeeze the most performance out of your code, it may be worth considering.

Assembly, assembler, and machine language

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

They Are Different Things

There are three different but related concepts that people often confuse. Let’s clarify each one.

Assembly

Assembly is a programming language made up of simple mnemonics. It directly corresponds to the instructions of the platform you’re using. When writing Assembly code, you know exactly what the processor is doing and gain access to resources that might not be available in higher-level languages. We can call Assembly a low-level language, meaning it’s closer to the hardware.