DEV Community: Alex Escalante

Proyecto base para construir una aplicación con NestJS + Astro + Prisma + PG Por si a alguien le sirve, utilicé este repo para un taller de programación que di hace algunas semanas https://github.com/Audelabs/nodejs-workshop

Alex Escalante — Fri, 17 Oct 2025 20:18:49 +0000

GitHub - Audelabs/nodejs-workshop: Proyecto base para construir una aplicación con NestJS + Astro + Prisma + PG · GitHub

Proyecto base para construir una aplicación con NestJS + Astro + Prisma + PG - Audelabs/nodejs-workshop

github.com

I am very happy for being here for 8 years. Not only have I read and learned many interesting things, I have also seldomly used this place to share some of my own experiences and thinking. Thanks to all for this journey!

Alex Escalante — Fri, 30 May 2025 02:15:45 +0000

My honest and minimal review of Leonardo.AI

Alex Escalante — Sun, 09 Mar 2025 20:26:43 +0000

I just canceled my subscription to LeonardoAI. It wasn’t much since I was on the cheaper plan. I subscribed with the intention of using it to generate assets for the websites I build.

To be honest, I found very few of the images actually useful. No matter the model, most looked too artificial to me. Some were beautiful, artistic, and interesting—but none had real business value beyond maybe blog illustrations. Definitely not for landing pages, or at least not for most of my clients.

For example, one day I tried using LeonardoAI to create images of people in everyday office interactions. Some were nice, even usable—except the meetings looked more like a UNESCO conference than a regular office day. The photos felt unnecessarily inclusive, to put it bluntly.

On the other hand, when I tried to nudge LeonardoAI into generating more Latin-looking people, they all came out looking the same, with a sad mojado expression. Maybe the AI read the inner Mexican in me—I really don’t know. The best I got from this experiment was a batch of bearded guys in an office. I assure you, this time the AI wasn’t reading my mind.

So I started using it for memes, beautiful faces, and creative images to share on social media. It’s an okay tool for that, if you see my point.

But nowadays, there’s lots of competition.

Today, I tried using LeonardoAI for something the competition is starting to make very easy: creating consistent characters.

I took one of my images from LeonardoAI and asked it to generate a new one using it as a reference. It was a woman sitting at her desk—I just wanted her laughing and stretching her back.

And what did I get? One of those ugly, multi-limbed monstrosities with extra hands. In 2025, seriously? That’s when I decided to close that little $10 monthly leak.

Then, as a final insult, they told me I’d lose all my unused credits! I had no idea, and I found that pretty abusive. But if I wasn’t going to use it anyway, and on top of that, they’re pushy and greedy… well, I’d rather lose my credits and move on to greener pastures.

From Prisma to Drizzle: Shedding the Magic, Embracing SQL

Alex Escalante — Wed, 05 Mar 2025 01:00:34 +0000

When we first decided to use Prisma ORM for one of our Node.js services, I was genuinely happy with the choice. It offers a very ergonomic API—“friendly” at first glance, though you still have to figure it out—and it allowed my team to work without deep SQL knowledge.

But then, things changed.

As we got deeper into SQL, started using stored procedures, and explored more of PostgreSQL’s powerful features, Prisma began to feel more like an obstacle than a solution. Instead of facilitating our workflow, it made working with these advanced SQL features more cumbersome.

One thing that really started to bother me was the way Prisma applies magic to return types. It makes them practically impossible to share seamlessly, for instance, with my React clients. I still had to manually define all my DTOs, which felt like a step backwards. Maybe I was naive to expect otherwise, but for a while, I even considered writing my own Prisma plugin to generate DTOs—an overly complex path, to say the least.

So, when the time came to build a new service backed by PostgreSQL, we decided to take a different approach. Enter Drizzle ORM.

Drizzle is simpler. It feels more like writing SQL. There’s no overwhelming magic, just solid TypeScript support that actually helps rather than gets in the way. Sure, I still have to write my DTOs by hand when needed, but at least I’m not stumbling through Prisma’s enchanted forest of abstractions.

In the end, I’d rather have control than illusions.

PD: Did I mention Drizzle is waaay more performant than Prisma?

A glimpse into the algebra of type systems

Alex Escalante — Thu, 04 Apr 2024 18:40:00 +0000

I just saw this very interesting video about writing programs which inherently make invalid state unrepresentable. This might be a very important concept to understand, specially if you are still learning or you have a background in languages which do not provide strong typing.

An "algebraic type system" in computer programming refers to a system that allows the construction of complex types from simple types using algebraic operations. These operations typically include sum (union) and product (combination) of types. Algebraic type systems are a powerful tool for modeling data in a way that leverages the type system of a programming language to enforce constraints and invariants about the data, thus making programs more robust and easier to reason about. Rust and TypeScript are two languages that utilize algebraic type systems in different ways.

Sum Types (Union Types)

Sum types, also known as union types or variants, allow a value to be one of several different types. This is analogous to an "or" operation in algebra. In programming, this is useful for modeling situations where a value can come from disparate types and the program needs to handle each type differently.

Rust: Rust uses enum to define sum types. An enum in Rust can have variants, and each variant can optionally carry data of different types. This allows Rust to model complex data structures and patterns like state machines or optional values (e.g., the Option<T> type) in a type-safe manner.
TypeScript: TypeScript has union types that are denoted by the | operator. This allows a variable to hold a value of one of several types, enabling the programmer to write flexible code while still maintaining type safety. For example, a variable could be defined to hold either a string or a number.

Product Types (Structural Types)

Product types allow the combination of several values into one compound value, where the "product" part comes from the idea of multiplying the possibilities of each component type to get the total possibilities for the compound type. This is useful for bundling related data together.

Rust: Rust has structs that are used to create complex data types by combining values of multiple types. Each field of a struct can have a different type, allowing for the construction of rich, typed data structures.
TypeScript: TypeScript uses interfaces and classes as its primary means of creating compound types. Interfaces in TypeScript are used to define the shape that objects should conform to, including the types of their properties and methods. Classes can implement interfaces and provide concrete implementations.

Algebraic Data Types in Programming

Algebraic Data Types (ADTs) in programming languages like Rust and TypeScript enhance type safety and expressiveness. They allow developers to model data in a way that makes invalid states unrepresentable, significantly reducing runtime errors. For example, in Rust, the compiler checks match expressions for exhaustiveness, ensuring that all possible variants of an enum are handled. In TypeScript, union types and type guards can be used to ensure that code correctly handles different types at runtime.

Both Rust and TypeScript leverage their type systems to provide compile-time guarantees about the behavior of the code, making the software development process more reliable and efficient. While the specifics of how they implement these features differ, the underlying principle of using types to enforce constraints and model complex data is a shared strength of both languages.

Let's go through an example that showcases the use of TypeScript's union types along with type guards to handle different types at runtime safely.

Example: Handling Different Shapes

Imagine you are working on a graphics application that can render different kinds of shapes. Each shape type (like Circle, Square) has its own set of properties. We want to write a function that takes a shape and prints its area, using union types for the shapes and type guards to distinguish between them at runtime.

Step 1: Define Shape Types with Union

First, we define the types for the shapes we are handling: Circle and Square. We then define a Shape type that is a union of these types.

type Circle = {
    kind: 'circle';
    radius: number;
};

type Square = {
    kind: 'square';
    sideLength: number;
};

// Union type for any shape
type Shape = Circle | Square;

Step 2: Implement Type Guards

TypeScript allows us to use user-defined type guards to check the type of a union type at runtime. A type guard is a function that returns a boolean and has a type predicate as the return type (arg is Type).

For our shapes, we can use the kind property to distinguish between them:

function isCircle(shape: Shape): shape is Circle {
    return shape.kind === 'circle';
}

function isSquare(shape: Shape): shape is Square {
    return shape.kind === 'square';
}

Step 3: Write a Function to Handle Shapes

Now, we write a function that takes a Shape and prints its area. We'll use the type guards to safely access the properties specific to each shape type.

function printArea(shape: Shape) {
    if (isCircle(shape)) {
        // TypeScript knows `shape` is a Circle here
        const area = Math.PI * shape.radius ** 2;
        console.log(`Area of the circle: ${area}`);
    } else if (isSquare(shape)) {
        // TypeScript knows `shape` is a Square here
        const area = shape.sideLength ** 2;
        console.log(`Area of the square: ${area}`);
    }
}

// Example usage
const circle: Circle = { kind: 'circle', radius: 2 };
const square: Square = { kind: 'square', sideLength: 3 };

printArea(circle); // Area of the circle: 12.566370614359172
printArea(square); // Area of the square: 9

This example shows how TypeScript's union types and type guards can be used to write safe, type-checked code that handles multiple types at runtime. By checking the kind property, we can tell TypeScript which type we are dealing with inside the if blocks, allowing us to access the properties unique to each type without risking a runtime error.

Un vistazo al álgebra de sistemas de tipos

Alex Escalante — Thu, 04 Apr 2024 18:24:00 +0000

Esta nota es una traducción de la nota original que publiqué más temprano. No estoy seguro si hoy en día tiene sentido seguir traduciendo, díganmelo en los comentarios, por favor…

Acabo de ver este video muy interesante sobre cómo escribir programas que inherentemente hacen que el estado no válido sea irrepresentable. Este podría ser un concepto muy importante de entender, especialmente si todavía estás aprendiendo o tu experiencia está basada en lenguajes que no cuentan con un sistema estricto de tipos.

Un "sistema de tipos algebraicos" en programación de computadoras se refiere a un sistema que permite la construcción de tipos complejos a partir de tipos simples mediante operaciones algebraicas. Estas operaciones suelen incluir suma (unión) y producto (combinación) de tipos. Los lenguajes con tipos algebraicos presentan oportunidades únicas para modelar datos imponiendo restricciones e invariantes sobre sus tipos, haciendo así que los programas sean más robustos y más fáciles de entender.

Rust y TypeScript son dos lenguajes que utilizan sistemas de tipos algebraicos de diferentes maneras.

Suma de tipos (union types)

Los union types permiten que un valor sea uno de varios tipos diferentes. Esto es análogo a una operación "or" en álgebra booleana. En programación, esto es útil para modelar situaciones en las que un valor puede provenir de tipos dispares y el programa necesita manejar cada tipo de manera diferente.

Rust: Rust usa enum para definir tipos de suma. Una enumeración en Rust puede tener variantes y cada variante puede, opcionalmente, contener datos de diferentes tipos. Esto permite a Rust modelar estructuras y patrones de datos complejos, como máquinas de estado o valores opcionales (por ejemplo, el tipo Option<T>) de forma segura.
TypeScript: TypeScript tiene tipos de unión que se indican mediante el operador |. Esto permite que una variable contenga un valor de uno de varios tipos, lo que permite al programador escribir código flexible manteniendo la seguridad de tipos. Por ejemplo, se podría definir una variable para contener un string o un number.

Producto de tipos (structs)

Un “tipos producto” permite la combinación de varios valores en un valor compuesto, donde la parte "producto" surge de la idea de multiplicar las posibilidades de cada tipo de componente para obtener las posibilidades totales del tipo compuesto. Esto es útil para agrupar datos relacionados.

Rust: Rust tiene struct que se utiliza para crear tipos de datos complejos combinando valores de múltiples tipos. Cada campo de una estructura puede tener un tipo diferente, lo que permite la construcción de estructuras de datos ricas y tipificadas.
TypeScript: TypeScript utiliza interfaces y clases como su medio principal para crear tipos compuestos. Las interfaces en TypeScript se utilizan para definir la forma que deben adoptar los objetos, incluidos los tipos de sus propiedades y métodos. Las clases pueden implementar interfaces y proporcionar implementaciones concretas.

Tipos de datos algebraicos en programación

Los tipos de datos algebraicos (ADT) en lenguajes de programación como Rust y TypeScript mejoran la seguridad y la expresividad de los tipos. Permiten a los desarrolladores modelar datos de una manera que hace que los estados no válidos sean irrepresentables, lo que reduce significativamente los errores de tiempo de ejecución. Por ejemplo, en Rust, el compilador verifica que las expresiones coincidentes sean exhaustivas, asegurando que se manejen todas las variantes posibles de una enumeración. En TypeScript, se pueden utilizar tipos de unión y protecciones de tipos para garantizar que el código maneje correctamente diferentes tipos en tiempo de ejecución.

Tanto Rust como TypeScript aprovechan sus sistemas de tipos para brindar garantías en tiempo de compilación sobre el comportamiento del código, lo que hace que el proceso de desarrollo de software sea más confiable y eficiente. Si bien los detalles de cómo implementan estas características difieren, el principio subyacente de usar tipos para imponer restricciones y modelar datos complejos es una fortaleza compartida de ambos lenguajes.

Veamos un ejemplo que muestra el uso de los tipos de unión de TypeScript junto con las protecciones de tipos para manejar diferentes tipos en tiempo de ejecución de forma segura.

Ejemplo: Distinguiendo entre diferentes figuras

Imagine que está trabajando en una aplicación de gráficos que puede representar diferentes tipos de figuras. Cada figura (como círculo, cuadrado) tiene su propio conjunto de propiedades. Queremos escribir una función que tome una figura e imprima su área, usando union types para las figuras y type guards para distinguirlas en tiempo de ejecución.

Paso 1: Definir tipos de formas con unión

Primero, definimos las figuras que estamos manejando: Círculo y Cuadrado. Luego definimos un tipo Shape que es una unión de estos tipos.

type Circle = {
    kind: 'circle';
    radius: number;
};

type Square = {
    kind: 'square';
    sideLength: number;
};

// Union type for any shape
type Shape = Circle | Square;

Paso 2: Implementar type guards

TypeScript nos permite usar “protectores de tipo” definidos por el usuario para verificar el tipo de un union type en tiempo de ejecución. Un type guard es una función que devuelve un valor booleano y tiene un predicado de tipo como tipo de retorno (arg is Type).

Para nuestras formas, podemos usar la propiedad kind para distinguirlas:

function isCircle(shape: Shape): shape is Circle {
    return shape.kind === 'circle';
}

function isSquare(shape: Shape): shape is Square {
    return shape.kind === 'square';
}

Paso 3: Escribir una función para manejar figuras

Ahora, escribimos una función que toma una figura e imprime su área. Usaremos los type guards para acceder de forma segura a las propiedades específicas de cada tipo.

function printArea(shape: Shape) {
    if (isCircle(shape)) {
        // TypeScript knows `shape` is a Circle here
        const area = Math.PI * shape.radius ** 2;
        console.log(`Area of the circle: ${area}`);
    } else if (isSquare(shape)) {
        // TypeScript knows `shape` is a Square here
        const area = shape.sideLength ** 2;
        console.log(`Area of the square: ${area}`);
    }
}

// Example usage
const circle: Circle = { kind: 'circle', radius: 2 };
const square: Square = { kind: 'square', sideLength: 3 };

printArea(circle); // Area of the circle: 12.566370614359172
printArea(square); // Area of the square: 9

Este ejemplo muestra cómo los union types y las type guards de TypeScript se pueden usar para escribir código seguro con verificación de tipos que maneje múltiples tipos en tiempo de ejecución. Al verificar la propiedad kind, podemos decirle a TypeScript con qué tipo estamos tratando dentro de los bloques if, lo que nos permite acceder a las propiedades únicas de cada tipo sin correr el riesgo de un error de tiempo de ejecución.

Why Linux 6.8 Networking Updates are a Big Deal

Alex Escalante — Tue, 05 Mar 2024 18:44:28 +0000

I came across this article and it surprised me. They say this could improve performance by 40%. Wow!

https://www.phoronix.com/news/Linux-6.8-Networking

The recent Linux kernel 6.8 release brings some major networking improvements that could have a significant impact on performance, especially for servers handling high volumes of network traffic. Here's why these updates are generating a lot of excitement:

Game-Changing XDP Enhancements

One of the headliners is the introduction of XDP (eXpress Data Path) routing and AF_XDP sockets. XDP allows packets to be processed and routed entirely at the driver level, bypassing the traditional kernel network stack. This can unlock substantial performance gains for use cases like load balancing, DDoS protection, and high-frequency trading systems.

The new AF_XDP socket type takes this a step further, enabling userspace applications to directly access XDP for ultra-high packet processing rates. These XDP enhancements open up exciting possibilities for applications requiring extreme networking performance.

Better Packet Processing

But the benefits aren't limited to specialized scenarios. Improvements to Generic Receive Offload (GRO), which combines multiple incoming packets into larger chunks for more efficient processing, can boost performance for workloads involving many small packets – a common characteristic of REST APIs and microservices.

Additionally, better integration of hardware offload capabilities for TCP receive processing can further reduce CPU overhead and improve throughput for TCP-based network traffic.

Monitoring and Optimization

The Linux 6.8 kernel also enhances various network performance counters and monitoring capabilities. This can help identify bottlenecks and fine-tune network performance, benefiting a wide range of applications and services.

Real-World Benefits

While the actual performance impact will depend on factors like hardware capabilities and workload characteristics, the networking updates in Linux 6.8 hold great promise for improving throughput, reducing latency, and optimizing CPU usage – especially for servers handling high volumes of network requests.

From cloud computing to content delivery networks, from real-time trading systems to microservices architectures, the Linux 6.8 networking improvements have the potential to unlock new levels of performance and efficiency across diverse domains.

As the world becomes increasingly interconnected and network-intensive, these advancements in the Linux kernel couldn't have come at a better time. It's an exciting step forward for the open-source community and a testament to the ongoing innovation in the Linux ecosystem.

Terraform is making my day impossible

Alex Escalante — Tue, 12 Dec 2023 03:41:39 +0000

The more I use HashiCorp's Terraform, the more I get convinced this is a half-baked product with more resources dedicated to developing the business model rather than the actual product.

Connecting to an external resource, like my Godaddy DNS records, turned out to be impossible. If I try to update just one IP for my app, I would lose all my other unrelated DNS records. It's all or nothing for Terraform: either you manage all your records or you don't. Import doesn't work, even when advertised, and I tried two providers for this, the second one supposedly adding import capabilities. It didn't work.

I had to use a null_resource and an external shell script that issues HTTP requests against the GoDaddy API to update my IPs. And Terraform can't query the state of this resource of course, so this is just half a solution.

Today, I am trying to get it to track my provisioning (done with Ansible) using a null_resource and md5 checks of local files (using data local_file). If the state is clean, terraform apply might or might not work. After hanging for a while on some operation, it gets killed by the OS.

If the first time works, the second time terraform apply is run, it gets killed for sure. Everything comes to ashes and I sometime can't even terraform destroy the damn thing again. The whole thing feels strange and random.

Anyway… this is just a rant, sorry. I might go back to my way of calling Ansible after Terraform is done with creating the droplets only but… what's the point? I could get Ansible to do the whole thing by itself.

The idea was to tie everything together in a way that I could just call Terraform and have my infra recreated every time, only if needed, but today, Terraform is failing me at this.

I am formally a Typescript programmer!

Alex Escalante — Thu, 11 Jun 2020 21:12:07 +0000

I just migrated my current React project, which is not yet that big, just over a hundred files, and it was actually very easy because I used create-react-app and it offers great support for the language.

It took me like 5 days to rewrite my components and data layer. There were some challenges, specially a couple of React contexts, but here I am!

It feels like my browser got more intelligent. It's way easier to make a big refactoring, which usually happens a lot in the early stages of a project.

If you struggle with complex projects in ES6, I commend you to try Typescript (or you could actually also try Flow). Static types can give you a lot of confidence and make your work more easy.

But please, be sure to understand how the type system works in Typescript. It's very nice and flexible but different if you come from other languages with static typing. For instance, I work with C# on the backend and it's just not the same thing: Typescript mounts a static type system over a dynamic language. It's very nice, and more flexible, but different.

What languages are you currently enjoying? I would like to know!

A dive into testing Styled Components and React HOCs

Alex Escalante — Thu, 24 Aug 2017 03:40:02 +0000

For my latest project, it made sense to use the very nice CSS in JS solution called styled-components, along with snapshot testing, which is a way to save and compare snapshots of your component's rendering (HTML and CSS) in order to prevent unintended changes. One of this tests can replace several others checking for particular attributes of the rendering.

Be noted that, in order to have nice snapshots using Jest and Styled Components, you have to install this additional package. Just read the docs and be sure to do the configuration required in case you use Enzyme, like me.

Finally, when I went ahead using shallow() by the book to test my button component, I wrote this:

it("renders correctly", () => {
  const renderedComponent = shallow(<Button {...props}>Click me!</Button>);
  expect(renderedComponent).toMatchSnapshot();
});

The output of the snapshot didn't look like the HTML or CSS I expected:

<Styled(styled.button)
  theme={
    Object {
      "bg": "white",
      "fg": "black",
    }
  }
>
  Click me!
</Styled(styled.button)>

This initially puzzled me but then I realized that our Button component is a stateless functional higher order component (HOC) that works like this:

export const Button = props => {
  // assemble some props
  // decide which button to create
  return props.primary
    ? <PrimaryButton {...ourProps}>
        {props.children}
      </PrimaryButton>
    : <RegularButton {...ourProps}>
        {props.children}
      </RegularButton>;
};

Since we are using shallow() rendering, we won't get to the second level of components! So, this is where dive() comes in. This function:

"Shallow render the one non-DOM child of the current wrapper, and return a wrapper around the result."

Turns out that we have two layers under our Button component, one for primary, icon buttons and so, and a "base class" for all of them. This means that we ended up having to do a double dive, so we called it a deepDive():

const deepDive = c => shallow(c).dive().dive();

it("renders correctly", () => {
  const renderedComponent = deepDive(<Button {...props}>Click me!</Button>);
  expect(renderedComponent).toMatchSnapshot();
});

In fact, if you don't know how many layers your component will wrap, you can generalize the idea using recursion:

const dd = w => (typeof w.type() === "function" ? dd(w.dive()) : w); // recursive diving
const deepDive = c => dd(shallow(c));

Look at how the type()function on the ShallowWrappertells us if we have reached the DOM level or we can still dive()again.

After deep diving, snapshots came out containing only CSS and basic HTML. We now have the liberty to work at ease with the component or any of its subcomponents knowing that no visual alteration will pass unnoticed by our tests.

Interaction tests work (we're only doing basic ones, clicks and disabled and so) and we got 100% coverage because every component layer goes exercised.

react-select + allOption

Alex Escalante — Sat, 19 Aug 2017 02:22:11 +0000

If you are using the React library react-select, you will find it doesn’t implement a “select all” option. It’s not difficult to implement this feature by yourself, just have a look at the following gist. You will even find how to make a localization wrapper on top of your control, in case you need it.

Take a look at the relevant stuff:

// specify props.allowSelectAll = true to enable!
const Select = props => {
  if (props.allowSelectAll) {
    if (props.value.length === props.options.length) {
      return (
        <ReactSelect
          {...props}
          value={[props.allOption]}
          onChange={selected => props.onChange(selected.slice(1))}
        />
      );
    }

    return (
      <ReactSelect
        {...props}
        options={[props.allOption, ...props.options]}
        onChange={selected => {
          if (
            selected.length > 0 &&
            selected[selected.length - 1].value === props.allOption.value
          ) {
            return props.onChange(props.options);
          }
          return props.onChange(selected);
        }}
      />
    );
  }

  return <ReactSelect {...props} />;
};

You will find the full gist at:

https://gist.github.com/AlexEscalante/251032be95767366742fce75bdfa269b

Please drop a line if you find this useful or have any comment!