Programming on Commentary of Takao

Agentes de IA para refactorización de código

Sun, 05 Jul 2026 00:00:00 +0900

Los agentes de IA como Cursor, Copilot Workspace y Claude pueden refactorizar código base de forma autónoma. El futuro del desarrollo incluye colaboración humano-agente.

Capacidades actuales

Refactorización de nombres, extracción de funciones, división de módulos, migración de APIs. Los agentes entienden el contexto del proyecto y aplican cambios.

Límites

Los agentes pueden introducir bugs sutiles. No entienden completamente la intención del negocio. La revisión humana sigue siendo necesaria.

Flujo de trabajo

Describe el refactor. 2. El agente analiza el código. 3. Propone cambios. 4. Revisas y apruebas. 5. El agente aplica. 6. Pruebas automáticas.

Futuro

Agentes especializados por dominio, integración con CI/CD, aprendizaje del estilo del equipo, refactorizaciones multi-repositorio.

Tipos no mapeados y utilidades avanzadas de TypeScript

Wed, 10 Jun 2026 00:00:00 +0900

Más allá de los mapped types, TypeScript ofrece patrones avanzados como tipos condicionales distributivos, tipos recursivos y operaciones sobre uniones y e intersecciones.

Tipos condicionales distributivos

Cuando un tipo condicional recibe un tipo unión, la condición se aplica a cada miembro individualmente: T extends U ? X : Y con T = A | B produce (A extends U ? X : Y) | (B extends U ? X : Y).

Parsers a nivel de tipos con Template Literal Types

Fri, 10 Apr 2026 00:00:00 +0900

Los template literal types combinados con inferencia condicional permiten construir parsers que operan exclusivamente en tiempo de compilación, analizando cadenas como rutas, formatos y DSLs.

Conceptos básicos

Usar T extends ${pattern}${infer Rest} ? ... : never para extraer partes de una cadena recursivamente. Cada paso consume un token.

Parseo de rutas

type ParseRoute<T> =
 T extends `${infer Segment}/${infer Rest}`
 ? [Segment, ...ParseRoute<Rest>]
 : [T];

Validación de formatos

Validar UUIDs, fechas ISO, versiones semver, rutas de archivos. Los errores se detectan en tiempo de compilación con mensajes claros.

Ramas en el sistema de tipos de TypeScript: Introducción a Conditional Types

Thu, 15 Jan 2026 00:00:00 +0900

Introducción

Los conditional types permiten lógica a nivel de tipos: T extends U ? X : Y. Esto permite resolución de tipos dinámica y consciente del contexto.

Sintaxis básica

type IsString<T> = T extends string ? true : false; La condición pregunta: “¿Es T asignable a U?”

La palabra clave infer

Extrae un tipo desde dentro de una condición: type ReturnType<T> = T extends (...args: any[]) => infer R ? R : never;

Tipos mapeados en TypeScript: Transformación de tipos

Mon, 10 Nov 2025 00:00:00 +0900

Los tipos mapeados transforman un tipo existente iterando sobre sus propiedades. Son la base de utilidades como Partial<T>, Readonly<T>, Pick<T, K> y Record<K, V>.

Sintaxis básica

type Nullable<T> = { [P in keyof T]: T[P] | null };

Itera sobre keyof T y aplica una transformación a cada propiedad.

Modificadores

Añadir o remover readonly y ? con prefijos + y -: { -readonly [P in keyof T]-?: T[P] }.

Reasignación de claves (TS 4.1+)

as clause para renombrar propiedades: { [P in keyof T as get${Capitalize<string & P>}]: () => T[P] }.

Uniones discriminadas en TypeScript: Patrón switch exhaustivo

Wed, 10 Sep 2025 00:00:00 +0900

Las uniones discriminadas (tagged unions) son la forma principal de modelar datos que pueden ser una de varias variantes. Usan una propiedad literal común (discriminante) para diferenciar los miembros.

Sintaxis básica

type Shape =
 | { kind: 'circle'; radius: number }
 | { kind: 'square'; side: number }
 | { kind: 'triangle'; base: number; height: number };

Estrechamiento (narrowing)

TypeScript reduce automáticamente el tipo basado en el discriminante. Usar switch con discriminante para manejar cada variante con seguridad de tipos.

Exhaustividad

Combinar con never para garantizar que todos los casos se manejan: default: const _exhaustive: never = value;.

Template Literal Types en TypeScript: Manipulación de tipos de cadenas

Tue, 10 Jun 2025 00:00:00 +0900

Los Template Literal Types (TS 4.1+) permiten manipular tipos de cadenas en tiempo de compilación. Usan la misma sintaxis que los template literals de JavaScript pero con tipos.

Sintaxis

type EventName = `on${Capitalize<string>}`;
// 'onChange' | 'onClick' | 'onSubmit' ...

Tipos de manipulación de cadenas

Uppercase<T>, Lowercase<T>, Capitalize<T>, Uncapitalize<T>. Combinables para crear patrones de nomenclatura.

Inferencia en template literals

type ExtractRoute<T> = T extends `/api/${infer R}` ? R : never;
type R = ExtractRoute<'/api/users'>; // 'users'

Casos de uso avanzados

Mapeo evento-manejador, tipado de rutas de API, traducciones tipadas, CSS-in-JS con props de tema, generación de tipos a partir de recursos.

El operador satisfies en TypeScript: Tipado flexible y seguro

Mon, 10 Mar 2025 00:00:00 +0900

El operador satisfies (TS 4.9+) verifica que una expresión cumple un tipo sin cambiar su tipo inferido. Permite tipado estricto en valores complejos como records y tuplas.

El problema

const x: Record<string, number> = { a: 1, b: 2 } pierde las claves específicas al acceder. Sin anotación, el tipo es demasiado amplio.

Solución con satisfies

const palette = {
 red: [255, 0, 0],
 green: "#00ff00",
} satisfies Record<string, string | number[]>;

El tipo inferido conserva las propiedades específicas, pero se valida contra el constraint.

Patrones a evitar con async/await en JavaScript

Sat, 15 Feb 2025 00:00:00 +0900

Introducción

async/await hizo la programación asíncrona más intuitiva, pero puede ocultar problemas de rendimiento y errores.

Antipatrón 1: Serialización innecesaria

No uses await secuencial para tareas independientes. Usa Promise.all para ejecución en paralelo.

Antipatrón 2: Bloques try-catch anidados

El anidamiento profundo derrota el propósito de async/await. Usa un solo bloque try-catch al más alto nivel.

Antipatrón 3: async callbacks en forEach

forEach con async callback ejecuta los callbacks síncronamente. Usa for...of para secuencial o Promise.all con map para paralelo.

Restricciones genéricas en TypeScript: Construyendo APIs type-safe

Tue, 05 Mar 2024 00:00:00 +0900

Los genéricos permiten código reutilizable type-safe. La palabra clave extends restringe parámetros de tipo a formas con propiedades específicas.

La restricción extends

function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] garantiza que key sea una propiedad válida de obj.

Conditional Types

Usan extends para verificar relaciones de tipo: type IsString<T> = T extends string ? true : false;

Mapped Types con keyof

Transforman cada propiedad de un tipo existente. Partial<T>, Required<T>, Readonly<T>, Pick<T, K>. Desde TS 4.1, remapeo de claves con template literal types.

Utility Types de TypeScript: Tu caja de herramientas de tipos

Sun, 10 Dec 2023 00:00:00 +0900

TypeScript incluye utility types globales para transformaciones comunes de tipos. Conocerlos evita reinventar la rueda y hace el código más legible.

Básicos

Partial<T>: todas las propiedades opcionales. Required<T>: todas obligatorias. Readonly<T>: todas de solo lectura. Record<K, V>: objeto con claves K y valores V.

Para unión e intersección

Pick<T, K>: seleccionar propiedades. Omit<T, K>: excluir propiedades. Extract<T, U>: extraer miembros de unión. Exclude<T, U>: excluir miembros de unión.

Para funciones

Parameters<T>: tipos de parámetros. ReturnType<T>: tipo de retorno. ConstructorParameters<T>: parámetros de constructor. InstanceType<T>: tipo de instancia.