Qué es un LLM (Large Language Model) ?

Hasta ahora vimos que un modelo generativo aprende a predecir la siguiente palabra dentro de una secuencia.

Pero ¿cómo pasamos de un simple predictor de texto a sistemas capaces de mantener conversaciones, razonar o escribir código?

La respuesta está en una sigla que probablemente ya viste muchas veces: LLM, o Large Language Model —Modelo de Lenguaje Grande.

Un LLM es un modelo de inteligencia artificial entrenado con cantidades masivas de texto —libros, artículos, código, conversaciones, sitios web— con el objetivo de aprender cómo funciona el lenguaje humano.

No se trata solo de palabras: el modelo aprende relaciones semánticas, contexto, estilo y tono.

Por eso, puede no solo completar frases, sino también adaptarse al contexto de una pregunta o instrucción.

Por ejemplo:

“Escribí un poema sobre gatos como si fueras Borges.”

El modelo comprende la estructura poética, el tema (gatos) y el estilo solicitado (Borges), y genera un texto coherente con todo eso.

El adjetivo Large (grande) no es casual.

Un LLM tiene miles de millones de parámetros, que son los “pesos” ajustados durante el entrenamiento.

Cuantos más parámetros, mayor capacidad tiene el modelo para reconocer patrones complejos y producir respuestas matizadas.

Esto significa que el modelo tiene un “cerebro” enorme, con miles de millones de conexiones que representan lo que aprendió sobre el lenguaje.

El salto que permitió construir los LLM modernos vino de una arquitectura publicada por Google en 2017: “Attention is All You Need”

En ese paper se presentó el Transformer, una estructura basada en un concepto revolucionario: la autoatención (self-attention).

Permite que el modelo “mire” todas las palabras del contexto al mismo tiempo, y decida a cuáles prestar más atención.

Por ejemplo, en la frase:

“El perro que mordió al cartero corrió hacia la casa.”

Para entender quién corrió, el modelo necesita conectar corrió con perro, no con cartero.

La atención le permite establecer esas relaciones de dependencia sin importar la distancia entre palabras.

Esa capacidad para manejar contexto global es lo que hace que los transformers sean tan potentes.

Cuando escribís una pregunta o prompt, el texto se convierte en tokens numéricos.

El modelo procesa esos tokens capa por capa, cada una aplicando atención y transformaciones matemáticas.

Al final, predice la probabilidad de cada posible palabra siguiente.

Por ejemplo:

Entrada: "La inteligencia artificial generativa es"

Salida probable: "una", "capaz", "un", "la"

El modelo elige la palabra más coherente según el contexto.

Luego vuelve a predecir la siguiente… y así sucesivamente, construyendo la respuesta palabra por palabra.

Los LLM no “piensan” como los humanos, pero su entrenamiento masivo les permite capturar regularidades del lenguaje y del pensamiento humano.

En la práctica, eso les da la capacidad de:

• resumir textos,
• traducir idiomas,
• escribir código,
• razonar sobre información textual,
• y mantener conversaciones contextuales extensas.

Por eso, cuando hablamos con un modelo como ChatGPT, sentimos que hay comprensión real detrás —aunque lo que hay es una predicción probabilística extremadamente sofisticada.

Los LLM tienen límites: pueden inventar información (alucinaciones), carecen de comprensión profunda del mundo y dependen de los datos con los que fueron entrenados.

Sin embargo, su capacidad de generar texto coherente y útil en contextos muy variados los convierte en una de las herramientas más poderosas creadas hasta ahora.

Cómo resuelve Scala los parámetros implícitos

En Scala, los parámetros implícitos permiten que una función reciba argumentos sin que el programador los pase explícitamente.

El compilador se encarga de buscar un valor adecuado en el ámbito para completar la llamada.

Veamos un ejemplo simple:

def saludar(nombre: String)(implicit saludo: String): Unit =

  println(s"$saludo, $nombre!")

implicit val saludoPorDefecto: String = "Hola"

saludar("Emanuel") // Usa el valor implícito definido arriba

Cuando Scala ve que falta un argumento para un parámetro implicit, sigue este proceso:

1. Busca en el ámbito local: valores o funciones marcados como implicit del tipo requerido.
2. Si no encuentra ninguno, busca en el objeto compañero (companion object) del tipo esperado.
3. Si encuentra más de uno y no puede decidir cuál usar, el compilador lanza un error por ambigüedad.
4. Si no encuentra ninguno, lanza un error por parámetro implícito no encontrado.

Veamos un ejemplo de ambigüedad:

implicit val saludo1: String = "Hola"

implicit val saludo2: String = "Buenas"

saludar("Emanuel") // Error: ambiguous implicits

El compilador no puede elegir entre `saludo1` y `saludo2`.

Scala resuelve los parámetros implícitos buscando un valor del tipo adecuado en:

El ámbito local,

Los imports activos,

Y los companion objects relacionados.

Es un mecanismo potente que permite propagar contextos automáticamente (por ejemplo, ExecutionContext, Ordering, Numeric, etc.), reduciendo la necesidad de pasar dependencias manualmente.

Parámetros implícitos en Scala ¿y en otros languages?

Scala ofrece una poderosa característica llamada parámetros implícitos (implicit parameters), que permite pasar argumentos a funciones sin tener que especificarlos explícitamente cada vez. Esta capacidad se utiliza mucho para inyección de dependencias, contextos compartidos o type classes.

def saludar(nombre: String)(implicit saludo: String): Unit =

  println(s"$saludo, $nombre!")

implicit val saludoPorDefecto: String = "Hola"

saludar("Emanuel") // imprime "Hola, Emanuel!"

Aquí, el parámetro saludo se pasa de manera implícita gracias a la definición previa de un valor implicit.

Si se define otro valor implícito en el mismo alcance, ese será el utilizado, lo que permite una gran flexibilidad contextual.

Aunque el concepto de implícito es característico de Scala, existen ideas similares:

Haskell usa type classes, que se resuelven de forma implícita por el compilador.

Por ejemplo, la clase `Eq` o `Show` se comporta como una inyección automática de comportamientos según el tipo.

show 42 -- el compilador infiere automáticamente la instancia de Show Int

Rust usa traits y type inference, que cumplen un rol similar. Las implementaciones de traits se aplican automáticamente sin especificarlas cada vez.

println!("{}", 42); // Usa automáticamente el trait Display para i32

C# no tiene parámetros implícitos como tal, pero existen aproximaciones:

• Inyección de dependencias en frameworks como ASP.NET.
• Attributes y default parameters.
• Desde C# 12, Primary constructors y default interface methods permiten inyectar comportamientos contextuales, aunque no son implícitos en tiempo de compilación.

Python tampoco tiene parámetros implícitos, pero se puede emular con:

• Decoradores.
• Context managers (with).
• Argumentos por defecto o variables globales.

Los parámetros implícitos de Scala logran un equilibrio interesante entre claridad y potencia, especialmente en contextos funcionales.

Su uso debe ser cuidadoso, ya que abusar de ellos puede hacer que el flujo de datos sea menos evidente.

Sin embargo, cuando se aplican bien, son una herramienta que simplifica enormemente el código y reduce la verbosidad.

¿Cómo funciona realmente #include en C++?

Cuando escribimos algo como:

#include <iostream>

podría parecer que el compilador “importa” la librería, pero en realidad el #include no es parte del lenguaje, sino una instrucción del preprocesador.

Lo que hace es copiar literalmente el contenido del archivo incluido dentro del código antes de compilar.

Por ejemplo, si tenés:

#include "miarchivo.h"

el preprocesador reemplaza esa línea por el texto completo de miarchivo.h.

Así, el compilador ve un solo archivo unificado.

¿Y qué pasa con las librerías estándar? Cuando hacés #include <iostream>, el compilador busca ese archivo en los directorios del sistema  (por ejemplo, /usr/include/c++/ en Linux).

Ese archivo sí existe y contiene declaraciones, no implementaciones.

Por ejemplo:

namespace std {

  extern ostream cout;

}

El archivo de cabecera sólo declara las funciones y objetos que vas a usar. Las implementaciones están en archivos binarios precompilados (.a, .lib, .so, .dll), que se vinculan en la etapa de linking.

El proceso completo es así:

• Preprocesador: copia los headers (#include) y expande macros.
• Compilación: convierte cada .cpp en un archivo objeto.
• Linker: une esos objetos con las librerías que contienen las funciones reales.

Como los headers se copian literalmente, si se incluyen varias veces puede haber redefiniciones.

Por eso se usan las llamadas guardas de inclusión:

#ifndef MIARCHIVO_H

#define MIARCHIVO_H

// contenido

#endif

o la forma moderna:

#pragma once

En resumen, #include no importa código ejecutable:

• solo inserta declaraciones que el compilador necesita conocer.
• El código real vive en las librerías que se enlazan al final del proceso.

Cómo funciona un modelo generativo

En el post anterior vimos qué es la Inteligencia Artificial Generativa y cómo puede crear contenido nuevo a partir de patrones aprendidos.

Ahora vamos a mirar debajo del capó: ¿cómo hace realmente un modelo para “inventar” texto, imágenes o música?

La respuesta puede resumirse en una idea:

> Un modelo generativo aprende a predecir lo que viene después.

Sí, suena simple. Pero detrás de esa predicción hay millones (o billones) de parámetros, una enorme cantidad de datos y un entrenamiento matemático fascinante.

Imaginemos que queremos que una máquina aprenda a escribir frases en español.

Para eso le damos millones de ejemplos: libros, artículos, correos, conversaciones.

El modelo analiza esas frases y aprende cómo se relacionan las palabras entre sí.

Por ejemplo, si ve muchas veces frases como:

> “El gato duerme en el sofá.”

> “El perro duerme en la cama.”

entonces entiende que después de “El gato” o “El perro” es muy probable que aparezca un verbo como duerme, corre o come.

Así, el modelo no memoriza frases completas, sino que aprende distribuciones de probabilidad:

> Dado un contexto (por ejemplo, “El gato”), ¿cuál es la palabra más probable que sigue?

Ese es el corazón de un modelo generativo.

Para que una máquina pueda trabajar con texto, primero debe convertir las palabras en números.

Cada fragmento de texto (una palabra, una sílaba o incluso una letra) se transforma en un token.

Por ejemplo:

“El gato duerme” → [101, 45, 202]

Estos números no tienen significado por sí mismos, pero el modelo los usa para representar el texto de forma matemática.

Con el tiempo, aprende que ciertos tokens aparecen juntos y en qué contextos.

Durante el entrenamiento, el modelo se enfrenta a miles de millones de ejemplos donde debe predecir la siguiente palabra.

Por ejemplo:

Entrada: "El gato"

Salida esperada: "duerme"

Cada vez que acierta, refuerza sus conexiones internas.

Cada vez que se equivoca, ajusta sus parámetros para acercarse un poco más a la respuesta correcta.

Ese proceso se repite millones de veces.

Con el tiempo, el modelo aprende cómo suena el lenguaje humano, y puede generar texto fluido simplemente repitiendo el proceso de predicción: elige una palabra, la agrega, vuelve a predecir la siguiente, y así sucesivamente.

Un modelo generativo moderno está formado por capas de neuronas artificiales conectadas entre sí.

Cada capa transforma la información, detecta patrones y pasa resultados a la siguiente.

Los modelos actuales, como los basados en la arquitectura Transformer, utilizan un mecanismo llamado atención (attention), que les permite decidir qué partes del texto son más relevantes para generar la siguiente palabra.

Por ejemplo, si el texto dice:

> “El gato que persiguió al perro estaba cansado.”

El modelo necesita “prestar atención” a *gato* (y no a *perro*) para entender que quien estaba cansado era el gato.

Eso es exactamente lo que hace el mecanismo de atención: ponderar el contexto de manera inteligente.

Supongamos que el modelo ya aprendió.

Ahora escribimos el inicio de una frase:

"El sol se"

El modelo analiza ese contexto y calcula probabilidades:

pone 0.8 a “pone”

0.1 a “oculta”

0.05 a “refleja”

0.05 a “enciende”

Puede elegir la más probable (pone), o una al azar según la distribución.

Luego repite el proceso con el nuevo contexto:

> “El sol se pone”

Y así, palabra por palabra, va construyendo texto coherente.

Lo mismo ocurre con píxeles en imágenes, notas en música o fotogramas en video.

Cuando vemos a ChatGPT escribir poesía o a DALL·E inventar ilustraciones, parece magia.

Pero en realidad, la creatividad de un modelo generativo proviene de su capacidad estadística para combinar patrones conocidos de forma nueva y coherente.

En cierto sentido, es una mezcla entre:

• la memoria del lenguaje aprendido, y
• la improvisación probabilística en cada predicción.

Comportamiento especial según el tipo genérico en C#

En C# no se puede sobrescribir un método solo porque el parámetro genérico es un tipo particular. El lenguaje no admite la especialización de clases genéricas como en C++, y la herencia no distingue entre MiClase<int> y MiClase<IMiInterfaz>.

Aun así, hay formas de lograr un comportamiento distinto según el tipo.

Una opción simple es decidir el comportamiento dentro del propio método:

class MiClase<T>

{

    public void Procesar(T valor)

    {

        if (valor is IMiInterfaz especial)

            ProcesarEspecial(especial);

        else

            ProcesarNormal(valor);

    }

    void ProcesarEspecial(IMiInterfaz x) => Console.WriteLine("Especial!");

    void ProcesarNormal(T x) => Console.WriteLine("Normal");

}

Si querés un despacho más flexible, podés usar dynamic:

class MiClase<T>

{

    public void Procesar(T valor)

        => ProcesarInterno((dynamic)valor);

    void ProcesarInterno(object v) => Console.WriteLine("Normal");

    void ProcesarInterno(IMiInterfaz v) => Console.WriteLine("Especial!");

}

También podés crear una subclase que se active solo para tipos que implementen una interfaz:

class MiClase<T>

{

    public virtual void Procesar(T x) => Console.WriteLine("Normal");

}

class MiClaseEspecial<T> : MiClase<T> where T : IMiInterfaz

{

    public override void Procesar(T x) => Console.WriteLine("Especial!");

}

En resumen, C# no permite sobrescribir métodos genéricos por tipo, pero sí es posible lograr comportamiento especializado combinando pattern matching, dynamic o herencia con restricciones.

Elm vs Haskell: dos caminos del paradigma funcional

Haskell y Elm comparten una raíz común: ambos son lenguajes funcionales puros, con tipado estático, inferencia de tipos y un fuerte énfasis en la inmutabilidad.

Sin embargo, cada uno tomó un camino distinto.

Haskell apostó por la abstracción, la teoría de tipos avanzada y la expresividad; Elm, por la simplicidad, la seguridad y la experiencia del desarrollador.

Haskell nació en el ámbito académico, con el objetivo de ser un lenguaje funcional puro que sirviera como base de investigación.

Por eso prioriza la expresividad, la abstracción y la corrección formal.

Su lema podría ser: “todo puede expresarse en tipos”.

Elm, en cambio, nació del mundo web.

Su meta no es la investigación, sino la confiabilidad.

Fue diseñado para construir interfaces web sin errores en tiempo de ejecución.

Su lema podría ser: “ningún runtime exception, nunca”.

En resumen:

Haskell es una herramienta para explorar los límites del paradigma funcional.

Elm es una herramienta para aplicar ese paradigma con seguridad y pragmatismo.

Ambos tienen tipado estático e inferencia, pero el sistema de tipos de Haskell es mucho más poderoso.

Haskell permite type classes, kind polymorphism, type families, GADTs, monads, existentials y un sinfín de extensiones.

Elm tiene un sistema de tipos mucho más pequeño, pero más legible y predecible.

En Haskell, el tipo puede expresar conceptos avanzados:

fmap :: Functor f => (a -> b) -> f a -> f b

Mientras que en Elm, los tipos se mantienen simples y directos:

List.map : (a -> b) -> List a -> List b

En Haskell podés crear tus propias type classes (Eq, Ord, Monad, etc.).

En Elm no existen type classes: sólo hay un conjunto fijo de restricciones (number, comparable, appendable).

Haskell es un lenguaje donde los tipos son una herramienta de abstracción.

Elm los usa más bien como una herramienta de seguridad.

Tanto Haskell como Elm son lenguajes funcionales puros: ninguna función puede tener efectos secundarios sin declararlo explícitamente.

Pero los abordan de forma distinta.

Haskell utiliza el sistema de monads para modelar efectos: IO, Maybe, State, etc.

Cada efecto se encapsula en un tipo, y se encadenan usando do notation.

main :: IO ()

main = do

    name <- getLine

    putStrLn ("Hola, " ++ name)

Elm evita completamente las monads.

En su lugar, usa un modelo explícito de efectos: los Commands (Cmd) y Subscriptions (Sub), que forman parte del Elm Architecture.

Esto mantiene la pureza del lenguaje sin exponer al programador a conceptos teóricos complejos.

update : Msg -> Model -> (Model, Cmd Msg)

update msg model =

    case msg of

        CargarDatos ->

            ( model, Http.get {...} )

        DatosCargados datos ->

            ( { model | items = datos }, Cmd.none )

Haskell ofrece poder; Elm ofrece control.

En Haskell, el manejo de efectos es flexible y extensible.

En Elm, es seguro y predecible.

Elm está diseñado para ser simple y consistente.

La sintaxis es limpia, sin operadores ambiguos ni extensiones opcionales.

Haskell, en cambio, permite una gran expresividad, pero también puede resultar críptico.

En Elm:

sumar : Int -> Int -> Int

sumar x y =

    x + y

En Haskell:

sumar :: Int -> Int -> Int

sumar x y = x + y

Parecen casi iguales, pero Haskell permite redefinir operadores, crear infix personalizados o usar point-free style, lo que puede aumentar la complejidad.

Elm evita deliberadamente esa flexibilidad para mantener el código legible para todos.

Haskell es un lenguaje generalista: se usa en compiladores, sistemas financieros, backends web, análisis estático y más.

Su ecosistema es vasto y diverso, aunque muchas librerías varían en calidad y mantenimiento.

Elm se centra exclusivamente en el frontend web.

Todo su diseño gira en torno a construir aplicaciones en el navegador.

No hay ambigüedad: un proyecto Elm siempre es una aplicación web.

A cambio de esa limitación, ofrece una experiencia coherente, con un compilador extremadamente útil y mensajes de error ejemplares.

La diferencia más grande entre ambos lenguajes quizá sea emocional. Haskell a veces puede parecer un rompecabezas: poderoso, elegante, pero con una curva de aprendizaje pronunciada.

Elm, en cambio, busca que programar sea agradable, incluso para quienes no tienen experiencia previa en programación funcional.

El compilador de Elm no sólo te dice qué está mal, sino cómo arreglarlo.

El de Haskell, aunque más sofisticado, puede ser más críptico si no conocés sus fundamentos teóricos.

Haskell y Elm son dos lenguajes que muestran dos filosofías complementarias del mundo funcional.

Haskell te da un universo para explorar la abstracción.

Elm te da un terreno firme donde construir sin errores.

Type constraints en Elm

Elm es un lenguaje de tipado estático e inferencia fuerte: el compilador deduce los tipos automáticamente, pero también te permite declarar funciones genéricas que funcionan con más de un tipo.

Por ejemplo:

identity : a -> a

identity x = x

Esta función acepta cualquier tipo a.

Sin embargo, a veces queremos restringir qué tipos son válidos.

Ahí entran en juego los type constraints (restricciones de tipo).

En Elm, los type constraints permiten decir:

> “Este tipo genérico debe cumplir con ciertas propiedades (por ejemplo, ser comparable o numérico)”.

A diferencia de Haskell o Scala, Elm no tiene type classes, pero ofrece un pequeño conjunto de restricciones integradas que cubren los casos más comunes.

Elm define cuatro categorías de tipos con restricciones que podés usar en tus firmas de tipo:

• number: Tipos que soportan operaciones aritméticas como Int, Float
• comparable: Tipos que pueden ordenarse o compararse  como Int, Float, Char, String, tuples de comparables
• appendable: Tipos que pueden concatenarse como String, List a
• compappend:| Tipos que son a la vez comparable y appendable 

Podés restringir una función a operar solo sobre números:

sumar : number -> number -> number

sumar x y =

    x + y

Esto funciona con Int o Float, pero no con String.

Si necesitás ordenar o comparar valores:

menor : comparable -> comparable -> comparable

menor a b =

    if a < b then

        a

    else

        b

O incluso:

ordenar : List comparable -> List comparable

ordenar lista =

    List.sort lista

Cuando querés concatenar elementos:

concatenar : appendable -> appendable -> appendable

concatenar a b =

    a ++ b

Funciona con:

concatenar "Hola, " "mundo!"        -- "Hola, mundo!"

concatenar [1,2] [3,4]              -- [1,2,3,4]

En Elm no se pueden definir tipos personalizados que sean comparable o appendable.

Por ejemplo, este tipo:

type alias Persona =

    { nombre : String, edad : Int }

No puede usarse en una función List.sort directamente.

Pero podés ordenarlo con una clave usando List.sortBy:

ordenarPorEdad : List Persona -> List Persona

ordenarPorEdad personas =

    List.sortBy .edad personas

O definir un criterio personalizado:

ordenarPorNombreDesc : List Persona -> List Persona

ordenarPorNombreDesc personas =

    List.sortWith (\a b -> compare b.nombre a.nombre) personas

Elm mantiene su sistema de tipos simple pero poderoso: no hay typeclasses ni herencia, pero sí restricciones útiles y seguras para los casos más comunes.

¿Qué significa new en los métodos de C# ?

Cuando vemos la palabra clave new en C#, lo primero que pensamos es en crear objetos:

var persona = new Persona();

Pero cuando aparece en la declaración de un método, como:

public new static void Saludar() { ... }

…muchos se quedan con cara de 🤔.

Porque en ese contexto, new no crea nada.

Su función es ocultar un método heredado de la clase base.

Veamos qué significa y cuándo conviene usarlo.

En C#, cuando una clase hereda de otra, también hereda sus métodos.

Pero si en la clase hija declarás un método con el mismo nombre y firma, el compilador te lanza una advertencia:

> ⚠️ “El miembro X oculta el miembro heredado Y. Usá la palabra clave new si la ocultación es intencional.”

En ese caso, el compilador te está avisando:

“Estás tapando un método que ya existía en la clase base.”

Y si realmente querés hacerlo, usás el modificador new para decirle al compilador que es intencional.

Veamos un ejemplo: 

class Base

{

    public static void Saludar()

    {

        Console.WriteLine("Hola desde Base");

    }

}

class Derivada : Base

{

    public new static void Saludar()

    {

        Console.WriteLine("Hola desde Derivada");

    }

}

class Program

{

    static void Main()

    {

        Base.Saludar();     // Hola desde Base

        Derivada.Saludar(); // Hola desde Derivada

    }

}

Lo importante:

Derivada.Saludar() oculta el método Base.Saludar().

No hay “sobrescritura” real, porque los métodos estáticos no se pueden sobreescribir.

La palabra clave override sí sobrescribe un método de la clase base, pero solo se puede usar con métodos virtuales o abstractos.

Veamos la diferencia:

class Base

{

    public virtual void Hablar() => Console.WriteLine("Base habla");

}

class Derivada : Base

{

    public override void Hablar() => Console.WriteLine("Derivada habla");

}

Y si en lugar de override usás new:

class Derivada : Base

{

    public new void Hablar() => Console.WriteLine("Derivada habla (ocultando)");

}

Entonces ocurre esto:

Base b = new Derivada();

b.Hablar();

             // Si usás override → Derivada habla

             // Si usás new → Base habla

En otras palabras:

• override reemplaza el comportamiento de la base.
• new simplemente lo oculta (pero el de la base sigue existiendo y puede usarse).

Casos comunes donde aparece new

1. En métodos estáticos, donde override no está permitido:

   public new static void Mostrar() => Console.WriteLine("Versión nueva");

2. Para redefinir métodos heredados no virtuales (por ejemplo, ToString() o Equals() de object, aunque no es habitual usar `new` allí).

3. Cuando querés evitar advertencias del compilador si tu método accidentalmente tiene el mismo nombre que uno de la base.

El modificador new en un método no tiene nada que ver con crear objetos.

Sirve para decirle al compilador:

> “Sí, sé que hay un método igual en la clase base, pero quiero ocultarlo y definir el mío propio.”

Sutil, pero importante:

no estás reemplazando comportamiento, estás escondiendo uno.

Estado del Octoverso

Github publicó el informe anual Octoverse, en el cual se pueden ver datos interesantes de los proyectos. El informe es grande y tiene muchos detalles.

En especial me intereso los lenguajes más utilizados:

Pero a partir de 2025, la curva de crecimiento de Python comenzó a seguir una trayectoria casi idéntica en paralelo con JavaScript y TypeScript, lo que sugiere que la adopción de la IA está influyendo en la elección del lenguaje en estos ecosistemas.

Dejo link: https://octoverse.github.com/

¿Qué es la Inteligencia Artificial Generativa?

En los últimos años, la Inteligencia Artificial Generativa (o Generative AI) pasó de ser un concepto académico a convertirse en una tecnología que usamos todos los días. Herramientas como ChatGPT, DALL·E o Gemini son ejemplos de cómo las máquinas no solo procesan información, sino que ahora también crean contenido nuevo: textos, imágenes, código, música o incluso videos.

Pero ¿qué significa exactamente que una inteligencia artificial sea “generativa”?

Y más importante: ¿cómo logra generar algo que parece hecho por una persona?

Tradicionalmente, la Inteligencia Artificial se enfocaba en reconocer patrones: identificar un objeto en una foto, predecir el precio de una casa o clasificar un correo como spam.

Es decir, la IA analizaba datos para tomar decisiones o realizar predicciones.

La IA generativa, en cambio, usa los mismos principios de aprendizaje automático, pero con un objetivo distinto: crear nuevas muestras que se parezcan a los datos con los que fue entrenada.

Por ejemplo:

• Si aprende del texto de millones de libros, puede escribir frases coherentes y originales.
• Si aprende de imágenes, puede dibujar nuevas combinaciones visuales.
• Si aprende de sonidos, puede componer melodías o voces humanas.

No “copia”, sino que aprende patrones estadísticos del lenguaje, la imagen o el sonido, y luego los usa para generar algo nuevo dentro de esos patrones.

Todo comienza con el entrenamiento. Un modelo generativo se alimenta con grandes cantidades de datos: textos, fotos, grabaciones, código fuente, etc.

Durante este proceso, el modelo aprende cómo se estructura ese contenido, encontrando relaciones, estilos y secuencias probables.

En el caso de los modelos de texto (como ChatGPT), el principio es simple pero poderoso:

> “Dado un conjunto de palabras, predecir cuál es la palabra más probable que sigue.”

Repitiendo ese proceso miles de millones de veces, el modelo aprende las reglas implícitas del lenguaje: gramática, contexto, tono, coherencia.

Eso le permite luego generar textos originales, sin necesidad de tener una “base de datos” de frases guardadas.

La mayoría de los sistemas generativos modernos se basan en una arquitectura llamada transformer, que revolucionó la forma en que las máquinas procesan secuencias como el lenguaje.

Los transformers permiten entender el contexto y generar contenido coherente a lo largo de párrafos o incluso conversaciones completas.

Estos modelos, cuando alcanzan un tamaño y entrenamiento suficientes, se denominan LLM (Large Language Models), y son la base de las IAs conversacionales actuales.

La IA generativa no solo automatiza tareas: amplía la creatividad humana. Permite a programadores escribir código más rápido, a artistas explorar nuevos estilos, y a científicos analizar datos con una comprensión semántica mucho más rica.

Su impacto se siente en educación, diseño, comunicación y desarrollo de software.

Y lo más interesante es que todavía estamos viendo solo el principio.

Diseñando interfaces declarativas con Elm UI

Elm es conocido por su modelo funcional puro y su arquitectura confiable (el Elm Architecture).

Sin embargo, muchos desarrolladores se frustran al escribir HTML y CSS en el código de Elm tradicional.

Ahí entra Elm UI, una librería creada por Matthew Griffith que propone algo radical:

“Construir interfaces sin HTML ni CSS.”

mdgriffith/elm-ui reemplaza los módulos Html y Html.Attributes por un conjunto de tipos y funciones que representan elementos visuales y propiedades de diseño.

En vez de mezclar markup y estilo, describís la interfaz de forma estructurada y tipada.

Por ejemplo:

import Element exposing (..)

import Element.Font as Font

main =

    layout [] <|

        column [ spacing 20, centerX, centerY ]

            [ el [ Font.bold ] (text "Hola Elm UI!")

            , el [] (text "Una forma diferente de pensar las interfaces.")

            ]

Este código produce una interfaz centrada con dos textos.

Sin CSS, sin HTML — todo se define a través de funciones puras.

Elm UI se basa en unos pocos conceptos muy consistentes:

Element: Unidad visual principal, equivalente a un “nodo” del DOM

layout: Punto de entrada para renderizar la interfaz 

row, column: Contenedores para alinear elementos horizontal o verticalmente 

el: Envuelve un elemento simple (por ejemplo, texto o imagen) 

text: Muestra texto

Attribute msg: Propiedad de estilo o comportamiento (como `spacing`, `padding`, `centerX`, `Font.size`, etc.)

Veamos un ejemplo más completo: una pequeña tarjeta de usuario.

import Element exposing (..)

import Element.Background as Background

import Element.Border as Border

import Element.Font as Font

viewUser : Element msg

viewUser =

    el

        [ Background.color (rgb255 240 240 255)

        , Border.rounded 12

        , padding 16

        , width (px 250)

        , centerX

        ]

    <|

        column [ spacing 8 ]

            [ el [ Font.bold, Font.size 20 ] (text "Emanuel Goette")

            , el [ Font.color (rgb255 100 100 100) ] (text "Desarrollador de software")

            , el [] (text "🌎 Argentina")

            ]

Y en el main:

main =

    layout [] viewUser

El resultado: una tarjeta limpia, centrada, con esquinas redondeadas y colores suaves.

Todo expresado como funciones y tipos, sin estilos externos.

Elm UI funciona perfectamente dentro del patrón clásico Model, Update, View.

Ejemplo simple:

import Browser

import Element exposing (..)

import Element.Font as Font

type alias Model =

    { counter : Int }

init : Model

init =

    { counter = 0 }

type Msg

    = Increment

    | Decrement

update msg model =

    case msg of

        Increment ->

            { model | counter = model.counter + 1 }

        Decrement ->

            { model | counter = model.counter - 1 }

view model =

    layout []

        (column [ spacing 16, centerX, centerY ]

            [ el [ Font.size 24 ] (text ("Contador: " ++ String.fromInt model.counter))

            , row [ spacing 10 ]

                [ button "-" Decrement

                , button "+" Increment

                ]

            ]

        )

button label msg =

    el

        [ Background.color (rgb255 100 149 237)

        , Font.color (rgb255 255 255 255)

        , Border.rounded 6

        , paddingXY 16 8

        , mouseDown [ onClick msg ]

        ]

        (text label)

main =

    Browser.sandbox { init = init, update = update, view = view }

Un pequeño contador con estilo nativo y sin HTML.

Elm UI lleva la programación declarativa al diseño visual.

En lugar de pensar en “cómo” maquetar una interfaz, pensás en qué representa cada parte de ella.

“Elm UI te obliga a pensar en tu interfaz como un modelo de datos, no como una plantilla.”

Ideal para quienes buscan precisión, seguridad y coherencia en sus diseños.

Dejo link: 

https://package.elm-lang.org/packages/mdgriffith/elm-ui/latest/

https://ellie-app.com