This post describes a way to organize your programs to make them easily testable and decoupled from libraries. The main objective of this framework is to empower the developers by reducing the complexity of the programs and delaying technical decisions as much as possible. Decoupling libraries from business logic, and by doing so, creating more maintainable and straight forward implementations of services, systems and applications. It borrows concepts and inspiration from the Hexagonal Architecture.

There is a very easy way to know know which Github user is associated with your SSH key.

A while back I had to generate an image with the normals of a spheroid.

A couple of weeks ago, searching for links to one of my projects, I stumbled upon an interesting GitHub profile. It was full of repositories named dc-###########.[domain.com] and with a CNAME file to them. And my domain was present in there, and it was working.

Working with several workstations and shared dot-files with lots of credentials and configurations doesn't feel very secure nowadays. There have been libraries that steal your credentials and environment variables during the installation process. No bueno.

Somehow I thought building a custom record player from scratch would be a good idea. It ended up taking 7 years in the building and many many iterations. Here is a photographic record of the process.

Self hosting a compiler may be the ultimate goal of every new language.

Simple personal rules to avoid common mistakes and foster consistency while designing HTTP APIs.

Lys compiler CLI, playground and roadmap.

Back in 2017, I wanted to learn WebAssembly, so I started investigating about it. The lack of good material led me to learning "the hard way", breaking every repository I found.

Having spent hundreds of hours behind the keyboard, flights, trains, and endless toilet-hours thinking about this project, it is difficult to start writing about it.

The purpose of this article is to serve as an introduction to understand what Neural Networks are and how they work, without all the heavy math.

In the journey to build a good useful language, we decided to enforce consistency wherever we can. To achieve this, one of the fundamental steps was to get rid of the hardcoded operators.

Thanks to [head ~ tail] in DataWeave 2.0 we can easily create infinite sequence generators.

Here is a brief list of engineering principles that guide my work

TL;DR: It is an argument of an automatic function injection