Newsletter 30 – 08/2022


Redis Explained – Nowadays Redis is almost mandatory for software engineers, this post is fantastic to understand it better. It explains Redis internals, deploy types, and many interesting distributed systems concepts.

WHY YOUR WEBSITE SHOULD BE UNDER 14KB IN SIZE – A website with under 14kb loads much faster than a website with 15KB, and the reason is on TCP specification.

Performance comparison: counting words in Python, Go, C++, C, AWK, Forth, and Rust – Count words from a given input looks like a easy programming problem, but this post goes beyond and solves this problem in many programming languages not only in the easy way, but in the optimized way! Explaining why of these optimizations for each language. Fascinating!


How to interrogate unfamiliar code – Deal with unknown code is a task that scares many developers, how do you understand what’s going on? This post gives excellent tricks to understanding codebases.

How to Choose the Right Python Concurrency API – Choose which concurrency API has become common in a developer’s life, this post gives help choosing it in Python.

Easy memory-saving tricks in Go – Three easy memory savings tricks to start doing in Go, and start doing your premature optimizations.

How I Found a Go Issue on ARM that Crashed the Database Server – A simple and objective walkthrough on figuring out and reporting a issue on Go.

Newsletter 29 – 07/2022


How “let it fail” leads to simpler code – Let it fail is one of the main mindsets behind Erlang, but it can be useful in all languages. This post explains this concept, and how to apply it.

Monitoring tiny web services – Everybody knows how to monitor services, but sometimes the monitoring stack can sound too much for tiny services, this short post explains nice ways to monitor this specific kind of service.

Modernizing Einhorn – Mike Perham, well known for his work on Sidekiq, took the ownership of a gem that already exists and has users! This post describes its first steps on the codebase, and how to deal with this scenario.

A Guide to the Go Garbage Collector – A complete guide to Go GC. This is very useful, not only for go developers but for every engineer that wants to understand more about GC.


DNS Esoterica – Why you can’t dig Switzerland – The name already explains this fun post 🙂

Why DRY is the most over-rated programming principle – Controversial post that brings a good question… Is DRY the most over-rated programming principle? IMO every programming principle and pattern needs to be used carefully because sometimes they can lead to unnecessary complexity.

10 tips for new Elixir developers – 10 simple and useful tips for new Elixir developers.

An Overview of Kandria’s Development with Lisp – Kandria is an open-world action RPG, being developed in common LISP, using Trial engine. Posts about game development are always fun (and unfortunately I almost never read about it), this post takes a brief look at the development of this game using LISP as the main language.

Newsletter 28 – 06/2022


Data Race Patterns in Go – Uber’s engineers analyzed over 1000 dataraces at its codebase and found a few patterns that usually happen. In this post, they show and talk about this.

Get paid to contribute to urllib3 – urllib3 team has launched its bounty program, which pays up to $100 for an issue done (an average $300), this is interesting news.

The computers are fast, but you don’t know it – A beautiful post about code optimization in Python, in the end, it was ~596915% faster than de initial one.

Things You Should Know About Databases – As the name already says, this post talks about things that you should know about databases, taking a brief look at two important concepts, indexes and transactions.

Fallacies of Distributed Systems – It’s always nice to remember (or learn) the basics.


Using Golang stdlib interfaces – Go has a powerful standard library, but knowing how to use the interfaces, can give you incredible powers.

Why We’re Sticking with Ruby on Rails at GitLab – Gitlab still using Rails, in this short post you can understand why.

Don’t Use Kubernetes, Yet – Kubernetes is a powerful tool to have at your company, but is It the right choice for small startup teams?

Engineering Levels at Honeycomb: Avoiding the Scope Trap – The engineering ladder is a common topic of discussion among managers and engineers, at this post from Honeycomb, they talk about their old ladder and the newer one.

Readability: The Optimal Line Length – This post is worth not only for UX/Copywriting but also for developers that are continuously writing documentation, guides, and playbooks.

To Thread or Not to Thread: An In-Depth Look at Ruby’s Execution Models – Ultimately choosing between process versus thread-based servers involves many trade-offs, this post from Shopify engineering explains, the differences and how they work.

Understading why attr_accessor in Ruby is faster than a regular method – Ruby attrs methods are very different from regular methods, they’re faster and with different implementation, this post explains what is different.

Newsletter 27 – 05/2022


Lisp interpreter in Rust – A guide about How to write our own Lisp interpreter in Rust.

Programming languages are platforms, not products – Have you ever thought about how often programming languages need to ship new features?

Breaking the Monolith at Twitch: Part One – Histories about large migrations and technical decisions are always worth reading. This is no exception! Twitch broke its Rails monolith into Go microservices some time ago, and this post talks about it. Part two you find here.

Founding Uber SRE – History about the foundation of the first Uber SRE team.

Our Experience Porting the YJIT Ruby Compiler to Rust – Shopify engineers ported their YJIT compiler from C to Rust, a fascinating post describing their experience doing it.


8 best practices for optimizing Lambda functions – Optimize your lambda functions cost, can save you good money at the end of the month.

Changing one character wildly improved our application’s performance – Engineers from Segment changed one character at a sorting algorithm and increased the performance of their trace system by 3.3x.

Learnings from 5 years of tech startup code audits – This post describes learnings (especially code security ones) about 5 years of audits in startup code.

An Introduction to Polymorphism in Ruby on Rails – Polymorphism is a difficult concept, mostly in dynamically typed languages, this post explains this concept in Ruby, and Rails.

Memory Management in Python – Part 1: What Are Pointers? – When you start to code dynamically typed languages is difficult to understand and see what is happening behind the scenes with your data, and where are the pointers working. This post explains it.

Newsletter 26 – 04/2022


What I learned from making a DNS client in Rust – We can learn a lot from building small toy projects, this inspiring post describes the great experience of building a DNS client from skatch.

Why Ruby has Symbols – Most of the newcomers to the Ruby world doesn’t understand why Ruby has symbols, how It works or when use It. This tutorial goes deep explaining them.

Code Ranges: A Deeper Look at Ruby Strings – A deeper look at how Ruby deals with so much string encondings.

When To Use Generics – Go has released its generics support, but you may wonder, when use It? This guide is for you.


A Deep Dive Into the Four Types of Prometheus Metrics – Know how to use and when to use each type of Prometheus metrics can be useful.

Go Developer Survey 2021 Results – Go developer survey 2021 results.

Writing for Engineers – Tips to write better, note only for engineers, but some tricks described xan help tou write everything.

The complete guide to protecting your APIs with OAuth2 (part 1) – OAuth2 its a important specification used worldwide to authenticate APIS. This initial guide describes the concept behind It.

How SHA-256 Works Step-By-Step – Posts describing how famous algorithms works are always interesting. This post is no exception, let’s code it after!