JavaScript must be enabled in order for you to see "WP Copy Data Protect" effect. However, it seems JavaScript is either disabled or not supported by your browser. To see full result of "WP Copy Data Protector", enable JavaScript by changing your browser options, then try again.
PUBLICIDAD publicidad

De la redacción
El Buen Tono

Una propuesta de arquitectura de software desarrollada por Sui Gn plantea una nueva forma de administrar grandes cantidades de información sin que cada modificación obligue a procesar nuevamente todo el sistema.

El proyecto, presentado en la publicación especializada CodeX de Medium, lleva por título “Decoupling Universe Size (n) From Mutation Cost (K)” y explica cómo separar el tamaño total de una estructura de datos del número de elementos que realmente necesitan actualizarse cuando ocurre un cambio.

La investigación utiliza dos variables principales: N, que representa el universo completo de información, y K, que identifica los elementos afectados por una modificación.

La idea central es sencilla: si un sistema contiene un millón de registros y solamente cambia uno, no debería ser necesario recalcular los otros 999 mil 999 elementos cuando no existe una relación directa con ellos.

Una prueba con el transporte público de Madrid

Para demostrar su funcionamiento, el desarrollador utilizó información GTFS del transporte público de Madrid, España, que incluye servicios, rutas, viajes y horarios de paso por estaciones.

Los datos fueron incorporados a .me, un sistema de conocimiento reactivo que mantiene relaciones y dependencias explícitas entre los elementos.

Las pruebas se realizaron con tres escalas de información:

  • Escala 1: 2 mil 364 horarios de paso.
  • Escala 10: 23 mil 640 horarios.
  • Escala 100: 236 mil 400 horarios.

Esto representó un crecimiento de aproximadamente 100 veces en el volumen de información.

Sin embargo, el número de elementos afectados por cada modificación permaneció prácticamente igual.

Los resultados fueron los siguientes:

IndicadorEscala 1Escala 10Escala 100
Horarios de paso2,36423,640236,400
K mediana111
K percentil 9518.51818
K máximo272727
Recálculo p500.004 ms0.003 ms0.003 ms
Recálculo p950.073 ms0.086 ms0.131 ms

El dato más relevante es que, aunque la cantidad de información aumentó alrededor de 100 veces, la distribución de elementos afectados no creció.

El código detrás de la propuesta

El repositorio de código abierto .me, desarrollado en TypeScript, Rust y Python, muestra cómo funciona este modelo mediante relaciones explícitas y reglas que se actualizan automáticamente.

Uno de los ejemplos utiliza una estructura de dependencias entre usuarios:

// Crear información de dos usuarios
me.users.ana.age(22);

// Crear una relación entre amigos
me.friends.ana["->"]("users.ana");

// Definir una regla que identifica a los adultos
me.users["[i]"]["="]("isAdult", "age >= 18");

// Consultar quiénes cumplen la condición
me("friends.ana.isAdult");
// Resultado: true

En este ejemplo, la regla se establece sobre los usuarios y puede consultarse mediante una relación, sin necesidad de duplicar la información.

Otro ejemplo muestra cómo una modificación actualiza automáticamente los resultados:

// Registrar la edad de Pablo
me.users.pablo.age(18);

// Consultar nuevamente a los adultos
me("friends[isAdult == true].name");

Cuando cambia la edad de un usuario, el sistema puede actualizar las dependencias correspondientes y reflejar el nuevo resultado.

Un ejemplo con un millón de sensores

El repositorio también presenta una demostración denominada Hemisphere Scale, diseñada para mostrar cómo funciona el procesamiento localizado en redes de gran tamaño.

En el escenario presentado se utilizan un millón de nodos y se modifica el estado de un solo sensor.

El código de demostración es el siguiente:

// Crear una regla relacionada con un sensor
me.geo[777777]["="]("blackout", "!powerUp");

// Definir una acción de emergencia
me.services["="](
  "generatorMode",
  "traffic.emergencyReroute"
);

// Modificar el estado del sensor
me.geo[777777].powerUp(false);

// Consultar cuántos elementos necesitan recalcularse
me.explain("services.generatorMode").meta.k;

// Resultado: 6

De acuerdo con la demostración publicada en el repositorio, solamente seis elementos necesitaron recalcularse, mientras que los otros 999 mil 994 permanecieron sin cambios.

El ejemplo reporta una latencia de 4.346 milisegundos para ese escenario.

El propio autor reconoce las limitaciones

Uno de los aspectos importantes del experimento es que Sui Gn aclara que los resultados no significan que todas las modificaciones tengan un costo O(K).

El desarrollador explica que el procesamiento de dependencias puede mantenerse localizado, pero otras operaciones estructurales, especialmente las eliminaciones, todavía pueden depender del tamaño total del universo de información.

En las pruebas, una operación DELETE llegó a registrar aproximadamente 22 segundos en la escala más grande, mientras que el recálculo de sus dependencias fue de alrededor de 0.37 milisegundos.

La carga inicial también aumentó conforme creció el conjunto de datos: pasó de aproximadamente 0.33 segundos a 32.5 segundos.

Esta diferencia es fundamental para interpretar correctamente los resultados: el sistema no elimina el costo de procesar grandes cantidades de información, sino que evita que cada modificación provoque innecesariamente el recálculo de elementos que no están relacionados con ella.

¿Qué representa este avance para el desarrollo de software?

La arquitectura propuesta podría tener aplicaciones en plataformas de transporte, ciudades inteligentes, sistemas de sensores, redes de información, bases de conocimiento y herramientas que necesitan actualizar datos constantemente.

Su principal aportación consiste en mantener relaciones explícitas entre los elementos y calcular cuáles dependen realmente de una modificación.

El repositorio .me está disponible públicamente en GitHub y contiene implementaciones, documentación y demostraciones en diferentes lenguajes de programación.

El experimento con Madrid muestra que una estructura de información puede multiplicar considerablemente su tamaño sin que necesariamente aumente el número de dependencias afectadas por cada cambio.

La propuesta no demuestra que cualquier sistema pueda escalar sin límites, pero sí presenta una alternativa técnica para reducir el trabajo innecesario en aplicaciones que administran universos de información cada vez más grandes.

Recibe noticias y promociones de El Buen Tono
Recibe directamente en tu correo electrónico nuestras principales noticias, información y promociones de El Buen Tono.
Es gratis. Solo escribe tu correo y presiona Sign Up para suscribirte.
[mc4wp_form id=1102202]
Tu información será utilizada únicamente para el envío de nuestras comunicaciones.
``` CANAL OFICIAL neurons