Translate

jueves, 19 de noviembre de 2026

Fundamentos de lenguajes de programación cuánticos parte 3



Seguimos con Q#

Podemos imaginar un lenguaje cuántico muy sencillo:

qubit q

H(q)

result = measure(q)

print(result)


El programa podría interpretarse así:

  1. Crear un qubit
  2. Aplicar Hadamard
  3. Obtener una superposición
  4. Medir el qubit
  5. Obtener 0 o 1
  6. Utilizar ese resultado clásicamente


El código parece sencillo.

Pero detrás de esas pocas líneas aparecen varios conceptos fundamentales:

  • Qubit
  • Superposición
  • Puertas cuánticas
  • Estado
  • Medición
  • Efectos
  • Recursos
  • Sistema de tipos
  • Compilación
  • Hardware

Y justamente ahí está la parte interesante de los lenguajes cuánticos.


¿Es simplemente otro lenguaje?

No exactamente.

Podríamos diseñar una sintaxis completamente nueva:


qubit q;

H(q);

measure(q);


pero el desafío real está debajo de la sintaxis.


Un lenguaje cuántico necesita expresar correctamente conceptos que no existen de la misma manera en la programación clásica.


Por ejemplo: ¿Qué es un valor?

¿Qué es un estado?

¿Qué significa copiar?

¿Qué significa consumir?

¿Qué operaciones tienen efectos?

¿Qué puede garantizar el sistema de tipos?

¿Cuándo ocurre una medición?

¿Qué parte del programa es clásica?

¿Qué parte es cuántica?

¿Cómo se compila un circuito?


Estas preguntas pertenecen directamente al campo de los fundamentos de los lenguajes de programación.


En la programación tradicional solemos imaginar:


entrada

  ↓

cálculo

  ↓

salida


En un programa cuántico podemos tener algo más parecido a:


estado inicial

      ↓

transformaciones

      ↓

superposición / entrelazamiento

      ↓

medición

      ↓

resultado clásico


El programa ya no solamente transforma valores.

Transforma estados cuánticos.

Y algunas operaciones tienen restricciones físicas que el lenguaje debe respetar.


La computación cuántica no solamente introduce un nuevo tipo de procesador.

También nos obliga a revisar algunas de las abstracciones fundamentales que utilizamos para diseñar lenguajes de programación.

Un qubit no es simplemente un Boolean con otro nombre.

La medición no es simplemente otra función.

Copiar un qubit no es equivalente a copiar un objeto.

Y un circuito cuántico no es simplemente una secuencia de instrucciones clásicas.

Por eso aparecen conceptos como:

  • Qubits
  • Estados cuánticos
  • Puertas
  • Medición
  • Circuitos
  • No-cloning
  • Tipos lineales
  • Recursos
  • Efectos
  • Compilación


Lo interesante es que muchas de estas ideas nos llevan directamente a problemas clásicos de los lenguajes de programación: tipos, semántica, recursos, efectos, optimización y compilación.


Quizás la pregunta más interesante no sea: ¿Cómo hacemos que un lenguaje tradicional pueda ejecutar código cuántico?

sino:

¿Qué debería ser un lenguaje de programación cuando el concepto de "valor" deja de ser suficiente para describir lo que estamos programando?

Patrón Mailbox: concurrencia sin compartir estado


Uno de los grandes desafíos de la programación concurrente es coordinar varios hilos que necesitan acceder al mismo estado.

La solución tradicional suele involucrar locks, mutexes o synchronized. Pero existe otra alternativa: el patrón Mailbox.

En lugar de permitir que múltiples hilos modifiquen directamente un objeto, hacemos que envíen mensajes a una cola (mailbox). Un consumidor procesa esos mensajes de manera secuencial y actualiza el estado.

Por ejemplo, imaginemos una cuenta bancaria:


sealed trait Mensaje

case class Depositar(monto: Int) extends Mensaje

case class Retirar(monto: Int) extends Mensaje


var saldo = 0


def procesar(mensaje: Mensaje): Unit =

  mensaje match

    case Depositar(monto) =>

      saldo += monto


    case Retirar(monto) =>

      if saldo >= monto then

        saldo -= monto


En una implementación basada en Mailbox, los mensajes se encolarían y un único consumidor ejecutaría procesar de forma secuencial.

Si llegan Depositar(100) y Retirar(30), el consumidor procesa ambas operaciones sin que dos hilos modifiquen simultáneamente el saldo.


¿Qué ventajas ofrece?

  • Reduce las condiciones de carrera sobre el estado del consumidor.
  • Desacopla a quienes envían mensajes de quienes los procesan.
  • Facilita la comunicación asíncrona.
  • Permite escalar mediante múltiples consumidores o actores independientes, cada uno con su propio estado.


¿Dónde encontramos este patrón?

En sistemas basados en actores, como Akka en Scala, y en entornos como Erlang y Elixir.

La idea fundamental: en lugar de compartir estado entre hilos, compartimos mensajes.


Porque muchas veces, la mejor forma de gestionar la concurrencia no es agregar más locks, sino cambiar la forma en que los componentes se comunican.

Estudio de Forrester: El Impacto Económico Total de Google Workspace con Gemini

sábado, 14 de noviembre de 2026

Records en Java: qué podemos hacer y cuáles son sus limitaciones


Los record llegaron en Java 16 para simplificar la creación de clases cuyo objetivo principal es representar datos. Evitan tener que escribir constructores, getters, equals(), hashCode() y toString() manualmente.


Pero ¿son simplemente clases más cortas? No exactamente. Tienen algunas restricciones importantes, especialmente cuando hablamos de herencia.

Supongamos que queremos representar un usuario:


public record Usuario(String nombre, int edad) {

}


Java genera automáticamente:

  • Un constructor con los componentes declarados.
  • Los métodos de acceso nombre() y edad().
  • Las implementaciones de equals(), hashCode() y toString().


Podemos utilizarlo así:


Usuario usuario = new Usuario("Ana", 30);

System.out.println(usuario.nombre());

System.out.println(usuario.edad());

System.out.println(usuario);


Observá que los métodos de acceso no siguen la convención tradicional de JavaBeans: se llaman nombre() y edad(), no getNombre() y getEdad().

Además, los componentes de un record son implícitamente final: no podemos reasignar sus valores después de construir la instancia.

¿Un record puede heredar de otra clase? No. Un record no puede extender una clase definida por nosotros.

En Java, los records heredan implícitamente de java.lang.Record. Por eso, esta declaración no es válida:


class Persona {

    String nombre;

}


record Usuario(String nombre, int edad)

        extends Persona { // Error de compilación

}


Tampoco podemos declarar explícitamente extends Record, porque esa herencia ya está definida por el lenguaje.

Esta restricción permite que los records tengan una estructura de datos bien definida y evita que se introduzca una jerarquía de clases que contradiga su modelo.

Por lo tanto, si necesitamos herencia de implementación entre clases, un record probablemente no sea la herramienta adecuada.

¿Un record puede implementar una interfaz? Sí. Un record puede implementar una o varias interfaces, igual que una clase convencional.


Por ejemplo:


interface Identificable {

    Long id();

}


public record Usuario(Long id, String nombre)

        implements Identificable {

}


El método id() exigido por la interfaz ya existe porque es un accesor generado automáticamente para el componente id.


También podemos implementar interfaces que requieran comportamiento:


interface Saludable {

    boolean estaActivo();

}


public record Usuario(String nombre, boolean activo)

        implements Saludable {


    @Override

    public boolean estaActivo() {

        return activo;

    }

}


Esto resulta especialmente útil cuando queremos aprovechar el polimorfismo sin necesitar herencia de clases.


¿Podemos agregar métodos a un record? Sí. Un record no se limita a almacenar datos: también puede contener lógica de negocio.


public record Rectangulo(double ancho, double alto) {


    public double area() {

        return ancho * alto;

    }

}

Podemos utilizarlo así:


Rectangulo rectangulo = new Rectangulo(5, 3);


System.out.println(rectangulo.area()); // 15.0


También podemos declarar métodos estáticos, constructores adicionales y constructores compactos para validar los datos.


Por ejemplo:


public record Usuario(String nombre, int edad) {


    public Usuario {

        if (nombre == null || nombre.isBlank()) {

            throw new IllegalArgumentException(

                "El nombre es obligatorio"

            );

        }


        if (edad < 0) {

            throw new IllegalArgumentException(

                "La edad no puede ser negativa"

            );

        }

    }

}


El constructor compacto permite validar los componentes sin tener que escribir las asignaciones correspondientes: Java las realiza automáticamente después de ejecutar su cuerpo.


¿Podemos modificar los componentes de un record?

No podemos reasignar directamente sus componentes una vez construida la instancia:


Usuario usuario = new Usuario("Ana", 30);

usuario.nombre = "María"; // Error


Sin embargo, hay una distinción importante: que los componentes sean final no significa que todos los objetos referenciados sean inmutables.


public record Grupo(List<String> integrantes) {

}


En este caso no podemos reasignar integrantes, pero sí podríamos modificar la lista si es mutable:


Grupo grupo = new Grupo(new ArrayList<>());

grupo.integrantes().add("Ana");


Si queremos proteger la colección, podemos realizar una copia defensiva:


public record Grupo(List<String> integrantes) {


    public Grupo {

        integrantes = List.copyOf(integrantes);

    }

}


Así evitamos que modificaciones posteriores sobre la lista original o sobre la lista devuelta alteren el contenido del grupo.


¿Podemos redefinir equals() y otros métodos?

Sí, aunque generalmente no es necesario. Java genera automáticamente equals(), hashCode() y toString() utilizando los componentes del record.

Podemos redefinir estos métodos si tenemos un motivo concreto. También podemos declarar constructores adicionales, siempre que respeten las reglas del lenguaje.

Lo que no podemos hacer es declarar instancias adicionales de campos de estado arbitrarios: los campos de instancia de un record corresponden a sus componentes. Sí podemos declarar campos estáticos.


¿Cuándo conviene usar records? 

Los records son una buena opción para:

  • DTOs utilizados en APIs REST.
  • Valores que se pasan entre capas de una aplicación.
  • Resultados de consultas.
  • Representar coordenadas, importes u otros valores.
  • Modelar datos que deben tener una estructura explícita y estable.


En cambio, una clase convencional puede ser más apropiada cuando necesitamos herencia de implementación, estado mutable o un ciclo de vida complejo.


Los records no son simplemente una forma abreviada de escribir clases. Son una característica del lenguaje diseñada para representar datos con una estructura explícita.

Podemos agregarles comportamiento e implementar interfaces, pero no podemos extender otras clases ni modificar la referencia de sus componentes.

lunes, 9 de noviembre de 2026

El 93% de los profesionales latinos afirman conocer o trabajar con Agentes de IA

Más resultados, menos instrucciones con la IA

miércoles, 4 de noviembre de 2026

Scala 3: entendiendo los implícitos desde cero parte 2


Ya sabemos que es implícitos ahora veamos un ejemplo más realista: dar formato a los precios.

Utilizar un String como idioma sirve para entender el mecanismo, pero no es una buena práctica para representar una configuración importante. Podríamos confundir el idioma con cualquier otra cadena de texto.


Vamos a crear un tipo específico.


case class Moneda(simbolo: String)

given monedaArgentina: Moneda = Moneda("$")


def mostrarPrecio(precio: Double)(using moneda: Moneda): String =

  s"${moneda.simbolo}$precio"


¿Qué significa cada parte?

case class Moneda define un tipo de dato para representar una moneda.

simbolo es el símbolo que queremos mostrar.

given monedaArgentina declara una moneda disponible para el compilador.

using moneda: Moneda indica que la función necesita una moneda para trabajar.


Ahora podemos ejecutar:


mostrarPrecio(1500)

mostrarPrecio(2500)


El resultado será:

$1500.0

$2500.0


La función no necesita recibir la moneda en cada llamada. Scala la encuentra en el contexto.

Este ejemplo es deliberadamente sencillo: en una aplicación real, el formato de los precios también debería contemplar separadores decimales, miles y otras reglas regionales.


¿Qué ocurre si tenemos dos monedas?

Supongamos que nuestra aplicación necesita trabajar tanto con pesos argentinos como con euros.


Podríamos declarar:

given pesos: Moneda = Moneda("$")

given euros: Moneda = Moneda("€")


Ahora tenemos dos valores del mismo tipo.


Si llamamos a:

mostrarPrecio(1500)


el compilador no tiene una única moneda que pueda elegir. Ambas coinciden con el tipo que necesita la función.

En este caso, la resolución del parámetro contextual es ambigua y el programa no compila.

¿Cómo lo resolvemos?

Podemos indicar explícitamente cuál queremos utilizar:


mostrarPrecio(1500)(using pesos)

mostrarPrecio(1500)(using euros)


También podemos organizar el código para que cada contexto tenga disponible solamente la moneda que corresponde.

La lección es importante: given no significa que Scala elige cualquier valor. El compilador debe encontrar un valor adecuado y una resolución válida.


A veces queremos pedirle al compilador que encuentre un valor contextual, sin estar dentro de una función que tenga un parámetro using.


Para eso existe summon.


case class Moneda(simbolo: String)

given monedaArgentina: Moneda = Moneda("$")

val monedaActual: Moneda = summon[Moneda]


println(monedaActual.simbolo)


El resultado es: $

La expresión: summon[Moneda] significa, aproximadamente: «Compilador, encontrá un valor contextual de tipo Moneda».


Si no existe un valor apropiado, el programa no compila.

No hay que confundir summon con una búsqueda que ocurre en cualquier momento mientras el programa se ejecuta. La resolución de estos valores es principalmente una tarea del compilador.


Hasta ahora vimos cómo proporcionar una configuración, pero los parámetros contextuales también permiten construir abstracciones más generales.

Imaginemos que queremos imprimir distintos tipos de valores. Para algunos tipos sabemos cómo convertirlos en texto; para otros, todavía no.


Podemos definir una abstracción:


trait Mostrar[A]:

  def mostrar(valor: A): String


Esta definición dice que Mostrar[A] representa una forma de mostrar valores de tipo A como texto.

Por ejemplo, podemos proporcionar una implementación para los enteros:


given mostrarEnteros: Mostrar[Int] with

  def mostrar(valor: Int): String =

    s"El número es $valor"


Y otra para las cadenas:


given mostrarTextos: Mostrar[String] with

  def mostrar(valor: String): String =

    s"El texto es '$valor'"


Ahora podemos definir una función genérica:


def imprimir[A](valor: A)(using m: Mostrar[A]): Unit =

  println(m.mostrar(valor))


¿Qué sucede cuando llamamos a la función?


imprimir(42)

imprimir("Hola")


En el primer caso, Scala busca un Mostrar[Int].

En el segundo, busca un Mostrar[String].


Como hemos declarado ambas implementaciones mediante given, el compilador puede seleccionar la correspondiente al tipo del argumento.


El resultado es:

El número es 42

El texto es 'Hola'


Este ejemplo muestra una de las ventajas más importantes del mecanismo: podemos definir una función general sin conocer de antemano cómo se representa cada tipo.

Las implementaciones concretas se proporcionan por separado y el compilador las conecta.

El ejemplo anterior es una forma de implementar una type class.


Una type class permite definir una capacidad que puede tener un tipo sin necesidad de modificar la definición original de ese tipo.


Por ejemplo, podemos definir cómo mostrar un entero y cómo mostrar una cadena, aunque Int y String sean tipos que no hemos creado nosotros.


La estructura es:

1. Definimos una abstracción, como Mostrar[A].

2. Proporcionamos implementaciones para los tipos que nos interesan mediante given.

3. Escribimos funciones que solicitan esa capacidad mediante using.

4. El compilador encuentra la implementación apropiada.


Esta idea es muy utilizada en Scala para implementar operaciones genéricas, comparaciones, serialización, conversión de datos y muchas otras abstracciones.


Scala 3 introdujo una sintaxis más específica para implicitos :

  • given declara instancias o valores contextuales.
  • using declara parámetros contextuales.
  • summon permite solicitar un valor contextual.
  • Conversion permite definir conversiones entre tipos.
  • extension permite agregar métodos de extensión a tipos existentes.


Los implícitos de Scala permiten que el compilador encuentre valores y comportamientos que una función necesita, sin que debamos pasarlos explícitamente en cada llamada.

domingo, 1 de noviembre de 2026

Scala 3: entendiendo los implícitos desde cero


Scala tiene una característica muy interesante: permite que el compilador encuentre ciertos valores o funcionalidades sin que tengamos que escribirlos explícitamente cada vez que los necesitamos.

Esta característica se conoce tradicionalmente como implicits (implícitos).

En Scala 3, los mecanismos principales para trabajar con implícitos son given y using. También existen otras herramientas relacionadas, como las conversiones automáticas mediante Conversion y las extensiones mediante extension.

Pero antes de hablar de palabras reservadas, vamos a entender el problema que intentan resolver.

Imaginemos que estamos desarrollando un programa que saluda a las personas.

Podríamos escribir una función como esta:


def saludar(nombre: String, idioma: String): String =

  if idioma == "es"

    then s"Hola, $nombre"

    else s"Hello, $nombre"


Para saludar a una persona, debemos indicar su nombre y el idioma:


saludar("Ana", "es")

saludar("Juan", "en")


Funciona perfectamente.

Sin embargo, imaginemos que toda nuestra aplicación está en español. Cada vez que llamamos a saludar, debemos repetir "es".


¿Qué pasaría si pudiéramos indicarle al programa que, por defecto, el idioma es español y que la función lo utilice automáticamente?

En Scala 3 podemos hacerlo mediante un parámetro contextual.


Veamos una implementación:


given idioma: String = "es"


def saludar(nombre: String)(using idioma: String): String =

  if idioma == "es"

    then s"Hola, $nombre"

    else s"Hello, $nombre"


Hay dos conceptos nuevos.

given: declarar un valor disponible para ser encontrado por el compilador.


given idioma: String = "es"


Estamos declarando un valor de tipo String que el compilador puede utilizar cuando necesite encontrar un valor de ese tipo en un contexto compatible.


using: declarar un parámetro que el compilador debe buscar.


def saludar(nombre: String)(using idioma: String): String =

  ...



La función necesita dos datos: el nombre y el idioma. El nombre se pasa normalmente, mientras que el idioma es un parámetro contextual.


Ahora podemos escribir:


saludar("Ana")

saludar("Juan")


El compilador encuentra el given de tipo String y lo utiliza para completar el parámetro using.


El resultado es:

Hola, Ana

Hola, Juan


¡No necesitamos escribir el idioma en cada llamada!

Es importante entender algo: el idioma no aparece mágicamente. Lo declaramos nosotros con given. Lo que hace Scala es encontrarlo y pasarlo automáticamente cuando corresponde.


¿Qué hace realmente el compilador?

Podemos pensar que el compilador completa la llamada a la función.


Nosotros escribimos:

saludar("Ana")


Conceptualmente, el compilador resuelve esa llamada como si hubiéramos escrito:

saludar("Ana")(using idioma)


No es necesario escribir esa segunda forma cuando el compilador puede encontrar el valor contextual adecuado.


Esta característica se conoce como contextual parameters, o parámetros contextuales.


El mecanismo permite separar dos responsabilidades:

  • La función declara qué información necesita.
  • El contexto proporciona esa información.


La función no necesita saber dónde se definió el idioma. Solo necesita recibir un String.


miércoles, 28 de octubre de 2026

[Infografía] 4 prioridades de infraestructura para escalar la IA de agentes

 

Me llegó este correo y lo quiero compartir :