TypeScript Supera Python y se Torna el Lenguaje Más Usado en GitHub en 2025

Hola HaWkers, agosto de 2025 marcó un momento histórico en la programación. Por primera vez en una década, JavaScript (y su extensión tipada) no solo se mantuvo relevante, como TypeScript superó Python para tornarse el lenguaje con más contribuidores activos en GitHub.

Este es un marco que refleja transformaciones profundas en cómo desarrollamos software. Vamos a entender lo que llevó a ese cambio.

Lo Que los Datos Muestran

El reporte Octoverse de GitHub reveló que en agosto de 2025, TypeScript superó Python por aproximadamente 42 mil contribuidores activos. Esto termina una secuencia donde Python había tomado el liderazgo en 2024, interrumpiendo 10 años de dominio de JavaScript.

Números del Ranking

Top lenguajes por contribuidores (Agosto 2025):

Posición	Lenguaje	Contribuidores	Variación
1	TypeScript	~2.8M	+15%
2	Python	~2.75M	+8%
3	JavaScript	~2.1M	-5%
4	Java	~1.5M	+2%
5	C#	~1.1M	+7%
6	Go	~950K	+12%
7	Rust	~750K	+25%

Contexto Histórico

Evolución del ranking (2015-2025):

2015-2023: JavaScript líder absoluto
2024: Python asume el liderazgo (boom de IA/ML)
2025: TypeScript supera ambos

El ascenso de TypeScript representa la madurez del ecosistema JavaScript. Desarrolladores quieren tipos, y finalmente los están consiguiendo de forma elegante.

Por Qué TypeScript Creció Tanto

La Influencia de la IA en el Desarrollo

Irónicamente, la misma ola de IA que impulsó Python ahora favorece TypeScript. Herramientas de IA como GitHub Copilot, Claude y ChatGPT funcionan mejor con código tipado.

Por qué IA prefiere TypeScript:

Tipos son contexto: LLMs entienden mejor código con tipos explícitos
Autocomplete superior: IA genera código más preciso con type hints
Menos ambigüedad: Tipos reducen errores de interpretación
Documentación implícita: Tipos sirven como documentación viva

Adopción Empresarial

Grandes empresas migraron masivamente para TypeScript en los últimos años.

Empresas que adoptaron TypeScript:

Microsoft: Creadora del lenguaje, usa en todos los productos
Google: Angular es completamente TypeScript
Meta: Migrando React ecosystem
Airbnb: 100% TypeScript en nuevos proyectos
Stripe: API y SDK en TypeScript
Slack: Aplicación desktop en TypeScript

Ecosistema Frontend Dominado

Todo framework frontend relevante ahora es TypeScript-first.

Frameworks y TypeScript:

Framework	TypeScript Status
Next.js	TypeScript-first
Nuxt 3	TypeScript-first
Angular	TypeScript obligatorio
SvelteKit	TypeScript-first
Remix	TypeScript-first
Astro	TypeScript-first

Lo Que Esto Significa Para Python

Python No Está Perdiendo

Es importante contextualizar: Python no está en declive. El crecimiento de 8% año a año es saludable. Lo que sucedió fue que TypeScript creció más rápido.

Donde Python continúa dominante:

Data Science: Pandas, NumPy, scikit-learn
Machine Learning: TensorFlow, PyTorch
Automatización: Scripts, DevOps
Backend APIs: Django, FastAPI
Investigación académica: Notebooks Jupyter

Nichos Diferentes

División de mercado:

TypeScript: Web frontend, Node.js backend, apps desktop
Python: IA/ML, datos, automatización, scripting

Los lenguajes no compiten directamente en la mayoría de los casos. Un desarrollador puede (y probablemente debería) conocer ambos.

Impacto Para Desarrolladores JavaScript

Migración Gradual

Si aún escribes JavaScript puro, el momento de aprender TypeScript es ahora. La buena noticia: la transición es suave.

Estrategia de migración:

Comienza con any: Convierte archivos .js a .ts gradualmente
Activa strict: Aumenta el rigor conforme aprendes
Usa inference: Deja TypeScript inferir tipos cuando posible
Agrega tipos poco a poco: No necesitas tipar todo de una vez

Ejemplo de Transición

// JavaScript original
function calculateDiscount(price, percentage) {
  return price - (price * percentage / 100);
}

// TypeScript básico (inference)
function calculateDiscount(price: number, percentage: number) {
  return price - (price * percentage / 100);
}

// TypeScript con retorno explícito
function calculateDiscount(price: number, percentage: number): number {
  return price - (price * percentage / 100);
}

// TypeScript con validación
function calculateDiscount(price: number, percentage: number): number {
  if (price < 0) throw new Error('Price must be positive');
  if (percentage < 0 || percentage > 100) {
    throw new Error('Percentage must be between 0 and 100');
  }
  return price - (price * percentage / 100);
}

Recursos Que Tornaron TypeScript Popular

Sistema de Tipos Avanzado

TypeScript ofrece recursos de tipo que pocas lenguajes tipadas tienen.

// Union Types - valor puede ser de múltiples tipos
type Status = 'pending' | 'approved' | 'rejected';

// Tipos condicionales
type NonNullable<T> = T extends null | undefined ? never : T;

// Template Literal Types
type Route = `/api/${string}`;

// Mapped Types
type Readonly<T> = {
  readonly [P in keyof T]: T[P];
};

// Utility Types nativos
type UserPreview = Pick<User, 'id' | 'name'>;
type UserUpdate = Partial<User>;
type UserRequired = Required<User>;

Inferencia Inteligente

// TypeScript infiere tipos automáticamente
const numbers = [1, 2, 3]; // number[]
const first = numbers[0];   // number

// Inferencia en funciones
const users = [
  { name: 'Alice', age: 30 },
  { name: 'Bob', age: 25 },
];

// TypeScript sabe que 'user' tiene name y age
const names = users.map(user => user.name); // string[]

// Narrowing automático
function printId(id: string | number) {
  if (typeof id === 'string') {
    // TypeScript sabe que 'id' es string aquí
    console.log(id.toUpperCase());
  } else {
    // TypeScript sabe que 'id' es number aquí
    console.log(id.toFixed(2));
  }
}

Generics Poderosos

// Función genérica
function getFirst<T>(array: T[]): T | undefined {
  return array[0];
}

const firstNumber = getFirst([1, 2, 3]);    // number | undefined
const firstString = getFirst(['a', 'b']);    // string | undefined

// Constraint en generics
interface HasId {
  id: number;
}

function findById<T extends HasId>(items: T[], id: number): T | undefined {
  return items.find(item => item.id === id);
}

// Generics en clases
class Repository<T extends HasId> {
  private items: T[] = [];

  add(item: T): void {
    this.items.push(item);
  }

  find(id: number): T | undefined {
    return this.items.find(item => item.id === id);
  }

  all(): T[] {
    return [...this.items];
  }
}

El Papel del Vibe Coding

GitHub destacó una tendencia llamada "vibe coding" que impulsó TypeScript.

Qué Es Vibe Coding

Definición:

Vibe coding es un flujo de trabajo donde desarrolladores comienzan con una idea y rápidamente crean un prototipo funcional, frecuentemente en una única sesión, usando IA para autocomplete y herramientas cloud listas para uso.

Por qué TypeScript se beneficia:

IA genera código mejor: Tipos ayudan IA a entender intención
Errores detectados temprano: Menos debugging manual
Refactorización segura: IDE puede renombrar/mover con confianza
Documentación automática: Tipos explican el código

Herramientas Que Impulsaron

Stack popular de vibe coding:

Editor: VS Code / Cursor
IA: GitHub Copilot / Claude
Framework: Next.js / Nuxt
Deploy: Vercel / Netlify
Database: Supabase / PlanetScale
Lenguaje: TypeScript

El Futuro de TypeScript

Tendencias Esperadas

Lo que viene por delante:

TypeScript 6.0: Mejoras de performance y nuevos features
Decorators estándar: Finalmente estable
Type-only imports: Optimización de bundle
Integración con AI: Types como prompt engineering

Node.js y Deno

Runtimes TypeScript-first:

Deno: TypeScript nativo sin compilación
Bun: Transpilación ultra-rápida
Node.js: Soporte experimental a TS nativo

// Deno - TypeScript nativo
// archivo: server.ts (corre directo, sin tsc)
import { serve } from "https://deno.land/std@0.200.0/http/server.ts";

serve((req: Request) => {
  return new Response("Hello TypeScript!");
}, { port: 8000 });

Conclusión

El ascenso de TypeScript al tope de GitHub no es accidente. Es el resultado de una década de evolución del ecosistema JavaScript, combinada con la necesidad de código más seguro y herramientas de IA que funcionan mejor con tipos.

Para desarrolladores JavaScript, el mensaje es claro: TypeScript no es más opcional, es la forma estándar de escribir JavaScript profesional en 2025. La buena noticia es que la transición es gradual y la inversión vale la pena.

Si quieres entender más sobre las tendencias del ecosistema JavaScript, te recomiendo echar un vistazo al artículo sobre State of JavaScript 2025 donde analizamos los datos de la investigación anual de la comunidad.