Development 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.

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.

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:

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.

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.

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”.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.