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/
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:
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.
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/
Pero históricamente ha tenido una gran limitación: no puede ejecutarse en el backend.
Ahí entra Lamdera, un lenguaje derivado de Elm que propone algo ambicioso:
“Desarrollar aplicaciones fullstack en Elm, con estado compartido entre cliente y servidor, sin escribir ni una línea de JavaScript ni HTTP.”
Lamdera es un lenguaje y un entorno de ejecución creado por James Carlson, completamente compatible con Elm, pero que agrega:
En otras palabras, Lamdera hace que Elm sea fullstack.
El compilador transforma tu código en una aplicación que corre tanto del lado del cliente como del servidor, sin necesidad de gestionar APIs, JSON o sincronización manual.
Lamdera extiende The Elm Architecture (TEA), pero con dos bucles de actualización:
uno en el cliente y otro en el servidor.
Ambos comparten el mismo modelo (Model) y el mismo tipo de mensaje (Msg), por lo que el tipado es consistente en toda la aplicación.
Un proyecto Lamdera se organiza con tres módulos principales:
module Main exposing (..)
import Lamdera exposing (ClientProgram)
import Shared exposing (..)
import Client
import Server
main : ClientProgram Shared.Model Shared.Msg Shared.ToServer Shared.ToClient
main =
Lamdera.client
{ init = Client.init
, update = Client.update
, view = Client.view
, subscriptions = Client.subscriptions
, onServerMsg = Client.onServerMsg
, onClientConnect = Client.onClientConnect
, onClientDisconnect = Client.onClientDisconnect
}
Contiene los tipos comunes:
module Shared exposing (..)
type alias Model =
{ counter : Int }
type Msg
= Increment
| Decrement
type ToServer
= SaveCounter Int
type ToClient
= CounterUpdated Int
Client.elm : Maneja la vista y la interacción del usuario:
module Client exposing (..)
import Lamdera exposing (sendToServer)
import Element exposing (..)
import Shared exposing (..)
init : (Model, Cmd Msg)
init =
({ counter = 0 }, Cmd.none)
update : Msg -> Model -> (Model, Cmd Msg)
update msg model =
case msg of
Increment ->
let
new = model.counter + 1
in
( { model | counter = new }
, sendToServer (SaveCounter new)
)
Decrement ->
let
new = model.counter - 1
in
( { model | counter = new }
, sendToServer (SaveCounter new)
)
Server.elm: Contiene la lógica del servidor (persistencia, validación, etc.):
module Server exposing (..)
import Lamdera exposing (sendToClient)
import Shared exposing (..)
update : ToServer -> Model -> (Model, Cmd Msg)
update msg model =
case msg of
SaveCounter value ->
( { model | counter = value }
, sendToClient (CounterUpdated value)
)
Con esto ya tenés una aplicación fullstack con comunicación cliente-servidor y estado sincronizado, todo en Elm.
Lamdera incluye herramientas propias:
Lamdera todavía no es software libre (su runtime es cerrado, aunque gratuito para uso educativo y hobby).
Tampoco permite acceso directo a archivos o bases de datos externas (aunque se planea extender esto).
Aun así, su estabilidad es sorprendente: muchas aplicaciones en producción usan Lamdera desde hace años sin un solo error en runtime.
Lamdera lleva la promesa de Elm un paso más allá:
> “Sin errores, sin JavaScript, y ahora… sin backend.”
Con él, podés crear aplicaciones reactivas, tipadas y persistentes con una única base de código funcional pura.
Ideal para quienes aman Elm y quieren llevar sus principios hasta el servidor.
Dejo link: https://lamdera.com
A simple vista parecen similares, pero no son equivalentes. La diferencia entre ambos puede tener implicaciones importantes en rendimiento, versionado y comportamiento en tiempo de ejecución.
Cuando definimos un campo como const, su valor se conoce y se fija en tiempo de compilación.
Esto significa que el compilador reemplaza todas las referencias a esa constante por su valor literal.
public class MathUtils
{
public const double Pi = 3.14159265359;
}
Si en otro proyecto escribimos:
Console.WriteLine(MathUtils.Pi);
El compilador incrusta el valor 3.14159265359 directamente en el código IL.
Por eso, si luego cambiamos Pi a 3.14 y recompilamos solo la librería, las aplicaciones que la usaban seguirán mostrando 3.14159265359, a menos que se recompilen también.
En resumen:
Un campo static readonly se evalúa en tiempo de ejecución, no en compilación.
Su valor puede asignarse en la declaración o dentro del constructor estático de la clase.
public class Config
{
public static readonly DateTime StartTime = DateTime.Now;
}
Aquí StartTime toma el valor actual al cargarse la clase, algo que sería imposible con const.
Otra diferencia clave: si modificamos el valor en el código fuente y recompilamos solo la librería, las aplicaciones que la referencian verán el cambio sin necesidad de recompilarse.
En resumen:
Usá const cuando el valor sea verdaderamente inmutable y universal (como Math.PI, o un nombre de tabla en una base de datos).
Usá static readonly cuando el valor dependa de la ejecución o pueda cambiar sin recompilar los clientes.
De hecho, los tests en Elm complementan su sistema de tipos, ayudándote a verificar la lógica de negocio, las transformaciones de datos y el comportamiento de tus funciones puras.
A diferencia de otros lenguajes donde los tests buscan prevenir errores de nulls, tipos o efectos secundarios, en Elm los tests sirven principalmente para:
Gracias a la pureza funcional, las pruebas en Elm son simples y predecibles.
El framework oficial de testing es elm-test.
Instalalo con:
npm install -g elm-test
elm-test init
Esto crea una carpeta:
tests/
└── Example.elm
donde podrás escribir tus pruebas.
Supongamos que tenés una función en src/MathUtils.elm:
module MathUtils exposing (add)
add : Int -> Int -> Int
add a b =
a + b
Podés crear un test en tests/MathUtilsTest.elm:
module MathUtilsTest exposing (tests)
import Expect
import Test exposing (..)
import MathUtils exposing (add)
tests : Test
tests =
describe "Pruebas de MathUtils"
[ test "Suma básica" <|
\_ -> Expect.equal 4 (add 2 2)
, test "Suma con negativos" <|
\_ -> Expect.equal 0 (add 2 -2)
]
Ejecutalo con:
elm-test
y deberías ver algo como:
TEST RUN PASSED
Duration: 15 ms
Podés probar también las funciones update de tu arquitectura Elm.
Supongamos una aplicación simple que incrementa un contador:
type alias Model =
{ counter : Int }
type Msg
= Increment
update : Msg -> Model -> Model
update msg model =
case msg of
Increment ->
{ model | counter = model.counter + 1 }
El test sería:
module CounterTest exposing (tests)
import Expect
import Test exposing (..)
import Main exposing (update, Model(..), Msg(..))
tests : Test
tests =
describe "Update del contador"
[ test "Incrementa el contador" <|
\_ ->
let
model = { counter = 0 }
updated = update Increment model
in
Expect.equal 1 updated.counter
]
Expect.notEqual – asegura que dos valores sean diferentes.
Expect.true / Expect.false – comprueba booleanos.
Expect.all – combina varios asserts sobre el mismo valor.
Fuzz tests – pruebas con datos aleatorios (muy útiles para funciones matemáticas o validaciones).
Ejemplo de fuzzing:
import Fuzz exposing (int)
fuzzTest : Test
fuzzTest =
fuzz int "Suma con cero no cambia el número" <|
\n -> Expect.equal n (add n 0)
El fuzzer genera cientos de casos aleatorios para asegurar que la propiedad siempre se cumple.
El sistema de tipos de Elm ya evita gran parte de los errores comunes, pero las pruebas unitarias llevan esa confianza un paso más allá. Te permiten documentar y verificar el comportamiento de tus funciones de forma declarativa, legible y segura.
Pero, ¿cómo logra mantener esa pureza funcional incluso cuando necesita interactuar con el mundo real —hacer peticiones HTTP, leer el tiempo o escuchar eventos del navegador?
La respuesta está en su sistema de efectos controlados, manejados a través de tres conceptos clave:
En lenguajes imperativos, un efecto secundario (como imprimir en consola, hacer un fetch, o leer el reloj) puede suceder en cualquier parte del código.
En Elm, en cambio, toda función debe ser pura: dado el mismo input, siempre devuelve el mismo output.
Esto significa que no podés ejecutar efectos directamente dentro de tus funciones —en su lugar, los describís y Elm se encarga de ejecutarlos de forma controlada.
Un Cmd (Command) representa una acción que Elm debe realizar fuera del mundo puro, y que luego generará un mensaje (msg) cuando termine.
Ejemplo: hacer una solicitud HTTP.
import Http
import Json.Decode exposing (string)
type Msg
= GotGreeting (Result Http.Error String)
fetchGreeting : Cmd Msg
fetchGreeting =
Http.get
{ url = "https://api.example.com/hello"
, expect = Http.expectString GotGreeting
}
Este Cmd Msg no ejecuta la solicitud, solo le dice al runtime de Elm:
Por favor, hacé esta petición y cuando tengas el resultado, mandame un GotGreeting.
En tu update, procesás el resultado:
update : Msg -> Model -> (Model, Cmd Msg)
update msg model =
case msg of
GotGreeting (Ok text) ->
({ model | greeting = text }, Cmd.none)
GotGreeting (Err _) ->
({ model | greeting = "Error al conectar" }, Cmd.none)
Task: trabajos que pueden fallar o devolver un valor
Un Task es una descripción más general de un efecto que puede producir un resultado o un error.
Por ejemplo, si quisieras obtener el tiempo:
import Task
import Time exposing (Posix)
type Msg
= GotTime Posix
getTime : Cmd Msg
getTime =
Task.perform GotTime Time.now
Task.perform convierte un Task en un Cmd, para que pueda ser ejecutado por Elm.
El flujo sería:
Sub msg: escuchar eventos externos
Mientras que Cmd representa acciones que Elm inicia,
Sub representa cosas que suceden fuera y Elm escucha.
Por ejemplo, escuchar el paso del tiempo:
subscriptions : Model -> Sub Msg
subscriptions model =
Time.every 1000 Tick
Cada segundo, Elm enviará un mensaje Tick, que procesás en tu update:
type Msg
= Tick Posix
update : Msg -> Model -> (Model, Cmd Msg)
update msg model =
case msg of
Tick time ->
({ model | currentTime = time }, Cmd.none)
Elm logra un equilibrio brillante:
Gracias a Task, Cmd y Sub, todo efecto está tipado, controlado y predecible, lo que permite que el compilador te ayude a manejar cada posible resultado.
Por eso, en Elm, incluso el caos del mundo exterior se maneja con elegancia funcional.
Pero hay una limitación importante, cada caso solo puede contener una expresión, no un bloque de varias sentencias.
Si intentás esto:
var result = value switch
{
1 =>
{
Console.WriteLine("Caso 1");
return "Uno";
},
_ => "Otro"
};
El compilador se queja: > *CS1525: Invalid expression term '{'*
Esto ocurre porque una switch expression espera una sola expresión por rama, no un bloque {}.
La pregunta es cómo resolverlo:
Opción 1: Lambda invocada inmediatamente
Si necesitás ejecutar varias líneas y devolver un resultado, podés usar una lambda expression que se ejecuta al instante:
var result = value switch
{
1 => (() =>
{
Console.WriteLine("Caso 1");
var temp = 10 * 2;
return $"Resultado: {temp}";
})(),
2 => "Dos",
_ => "Otro"
};
El truco está en (() => { ... })(): una función anónima definida y ejecutada inmediatamente.
Opción 2: Método auxiliar
Cuando el bloque es más grande o se usa varias veces, conviene delegar la lógica a un método:
var result = value switch
{
1 => CalcularCasoUno(),
2 => "Dos",
_ => "Otro"
};
string CalcularCasoUno()
{
Console.WriteLine("Caso 1");
var temp = 10 * 2;
return $"Resultado: {temp}";
}
Más limpio, legible y fácil de testear.
Los switch expressions son ideales para lógica declarativa y corta, pero cuando necesitás más pasos, la solución está en envolver el bloque dentro de una lambda o extraerlo a un método auxiliar.
Aunque en muchos casos usamos List<E> para mantener una secuencia, las colas ofrecen operaciones especializadas que reflejan su propósito: procesar elementos en un orden determinado.
Queue<E>: la cola clásica
Una Queue (cola) sigue la política FIFO: el primer elemento en entrar es el primero en salir.
Entre los métodos principales tenemos:
Usá offer, poll y peek cuando no quieras manejar excepciones, y add, remove, element si esperás que siempre haya elementos.
Veamos un ejemplo con LinkedList: LinkedList implementa Queue, así que se puede usar como una cola:
import java.util.*;
public class EjemploQueue {
public static void main(String[] args) {
Queue<String> cola = new LinkedList<>();
cola.offer("A");
cola.offer("B");
cola.offer("C");
System.out.println("Frente de la cola: " + cola.peek());
while (!cola.isEmpty()) {
System.out.println("Atendiendo: " + cola.poll());
}
}
}
Salida:
Frente de la cola: A
Atendiendo: A
Atendiendo: B
Atendiendo: C
Aquí los elementos se procesan en el mismo orden en que fueron agregados.
Implementaciones comunes de Queue:
Deque<E>: doble cola
Deque (Double-Ended Queue) es una cola doble, permite insertar y eliminar elementos tanto por el frente como por el final.
Veamos un ejemplo con ArrayDeque:
import java.util.*;
public class EjemploDeque {
public static void main(String[] args) {
Deque<String> deque = new ArrayDeque<>();
deque.addFirst("A");
deque.addLast("B");
deque.addLast("C");
deque.addFirst("Inicio");
System.out.println("Primero: " + deque.peekFirst());
System.out.println("Último: " + deque.peekLast());
while (!deque.isEmpty()) {
System.out.println("Procesando: " + deque.pollFirst());
}
}
}
Salida:
Primero: Inicio
Último: C
Procesando: Inicio
Procesando: A
Procesando: B
Procesando: C
Antes de Java 1.6 se usaba la clase Stack, pero hoy se recomienda usar Deque como pila:
Deque<Integer> pila = new ArrayDeque<>();
pila.push(10); // addFirst
pila.push(20);
pila.push(30);
while (!pila.isEmpty()) {
System.out.println("Sacando: " + pila.pop());
}
Salida:
Sacando: 30
Sacando: 20
Sacando: 10
Aquí la Deque actúa como una pila LIFO (Last-In, First-Out).
Las interfaces Queue<E> y Deque<E> amplían el poder del Java Collections Framework al modelar estructuras de datos de procesamiento secuencial, ideales para tareas como:
"La Encuesta para Desarrolladores 2025 es el informe definitivo sobre el estado del desarrollo de software. En su decimoquinta edición, Stack Overflow recibió más de 49 000 respuestas de 177 países en 62 preguntas centradas en 314 tecnologías diferentes, incluyendo un nuevo enfoque en herramientas de agentes de IA, LLM y plataformas comunitarias. Esta Encuesta anual para Desarrolladores ofrece una visión general crucial de las necesidades de la comunidad global de desarrolladores, centrándose en las herramientas y tecnologías que utilizan o sobre las que desean aprender más."
Dejo link:
Un Set se define como:
Set comparable
comparable: el tipo de los valores que puede contener (por ejemplo, Int, String, Char, etc.).
Todos los valores deben ser comparables, es decir, Elm debe poder ordenarlos.
Esto significa que no podés usar listas, records o funciones dentro de un Set.
Podés crearlo vacío o a partir de una lista:
import Set exposing (Set)
-- Conjunto vacío
numeros : Set Int
numeros = Set.empty
-- Desde una lista
pares : Set Int
pares = Set.fromList [2, 4, 6, 8, 10]
Los duplicados se eliminan automáticamente:
Set.fromList [1, 2, 2, 3]
-- Resultado: {1, 2, 3}
Set.member 4 pares
-- True
Set.member 5 pares
-- False
-- Agregar un elemento
paresActualizados =
Set.insert 12 pares
-- Eliminar un elemento
paresFiltrados =
Set.remove 8 paresActualizados
Recordá: todo es inmutable. Cada operación devuelve un nuevo Set, sin modificar el original.
Podés convertir un Set a lista:
Set.toList pares
-- [2,4,6,8,10]
Y viceversa:
Set.fromList [3,1,2]
-- {1,2,3}
Para aplicar transformaciones, primero lo convertís a lista y luego de vuelta:
paresDoblados =
Set.fromList (List.map (\x -> x * 2) (Set.toList pares))
Elm ofrece las funciones clásicas de teoría de conjuntos:
Set.union: Unión de dos conjuntos
Set.union (Set.fromList [1,2]) (Set.fromList [2,3]) --> {1,2,3}
Set.intersect: Intersección
Set.intersect (Set.fromList [1,2,3]) (Set.fromList [2,3,4]) --> {2,3}
Set.diff: Diferencia
Set.diff (Set.fromList [1,2,3]) (Set.fromList [2]) --> {1,3}
Set.isEmpty:¿Está vacío?
Set.isEmpty Set.empty --> True
Set.size: Cantidad de elementos
Set.size (Set.fromList [1,2,3]) --> 3
Gracias al sistema de tipos de Elm:
Por ejemplo:
-- Esto da error de compilación
Set.fromList [1, "dos", 3]
Está implementada internamente sobre un arreglo dinámico, y su código fuente se encuentra en java.util.ArrayList dentro del JDK.
Veamos cómo funciona en detalle:
Internamente, ArrayList mantiene un array (arreglo) de tipo Object[] llamado elementData donde guarda los elementos:
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
private static final int DEFAULT_CAPACITY = 10;
private static final Object[] EMPTY_ELEMENTDATA = {};
private transient Object[] elementData;
private int size;
}
Cuando creás un ArrayList sin indicar capacidad:
List<String> list = new ArrayList<>();
internamente no se reserva espacio aún. Se crea con elementData = EMPTY_ELEMENTDATA.
Recién al agregar el primer elemento, se inicializa con una capacidad por defecto (10).
Cuando llamás a:
list.add("Hola");
Java hace esto internamente:
public boolean add(E e) {
ensureCapacityInternal(size + 1);
elementData[size++] = e;
return true;
}
Y ensureCapacityInternal verifica si el arreglo tiene espacio suficiente:
private void ensureCapacityInternal(int minCapacity) {
if (elementData == EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
Si no hay espacio, llama a grow():
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1); // 1.5 veces más
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
elementData = Arrays.copyOf(elementData, newCapacity);
}
Cuando se queda sin espacio, duplica la capacidad en un 50% (crecimiento amortizado).
Acceder es O(1) porque es un arreglo:
public E get(int index) {
rangeCheck(index);
return (E) elementData[index];
}
Cuando quitás un elemento:
list.remove(2);
se mueve el resto de los elementos para no dejar “huecos”:
public E remove(int index) {
rangeCheck(index);
E oldValue = elementData(index);
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index + 1, elementData, index, numMoved);
elementData[--size] = null; // libera la referencia
return oldValue;
}
Esto hace que remove sea O(n) en el peor caso (por el corrimiento de elementos).
Veamos ventajas y desventajas
Ventajas:
Desventajas:
ArrayList es básicamente una versión moderna y no sincronizada de Vector.
Si necesitás sincronización, podés envolverlo así:
List<String> syncList = Collections.synchronizedList(new ArrayList<>());
Un Array en Elm es una estructura inmutable y eficiente que permite:
Su módulo se importa así:
import Array exposing (Array)
Podés crearlo vacío o a partir de una lista:
-- Array vacío
vacio : Array Int
vacio = Array.empty
-- Desde una lista
numeros : Array Int
numeros = Array.fromList [10, 20, 30, 40]
Y también convertirlo nuevamente a lista:
Array.toList numeros
-- [10, 20, 30, 40]
Para obtener el valor en un índice determinado:
Array.get 2 numeros
-- Just 30
Observá que devuelve un Maybe, ya que el índice podría no existir.
Array.get 10 numeros
-- Nothing
-- Actualizar el valor en la posición 1
actualizado =
Array.set 1 25 numeros
Array.toList actualizado
-- [10, 25, 30, 40]
Cada modificación devuelve un nuevo Array, sin alterar el original (inmutabilidad funcional).
Para agregar al final, usamos Array.push:
conNuevo =
Array.push 50 numeros
Array.toList conNuevo
-- [10, 20, 30, 40, 50]
Y para quitar el último, usamos Array.pop:
sinUltimo =
Array.pop conNuevo
Array.toList sinUltimo
-- [10, 20, 30, 40]
Podés recorrerlo de manera muy parecida a una lista:
Array.map (\x -> x * 2) numeros
-- {20, 40, 60, 80}
Y también filtrarlo o transformarlo:
Array.filter (\x -> x > 20) numeros
-- {30, 40}
Y hay más!! :
Array.length: Devuelve el tamaño
Array.length numeros --> 4
|
Array.isEmpty: ¿Está vacío?
Array.isEmpty Array.empty --> True
Array.initialize: Crea un array con una función
Array.initialize 5 (\i -> i * 2) --> {0,2,4,6,8}
Array.foldl/Array.foldr: Reduce el array
Array.foldl (+) 0 numeros --> 100 |
Veamos un ejemplo completo:
import Array exposing (Array)
main =
let
nums = Array.fromList [1,2,3,4]
dobles = Array.map (\n -> n * 2) nums
filtrados = Array.filter (\n -> n > 4) dobles
in
Array.toList filtrados
-- Resultado: [6,8]
Array en Elm te da:
Usá List cuando pienses en secuencias y Array cuando necesites posiciones.
Un Dict se define como:
Dict comparable value
Solo podés usar tipos comparables como claves, es decir, tipos con un orden definido (Int, String, Char, etc.).
No podés usar listas, records o funciones como claves.
Podés crear un diccionario vacío o con elementos iniciales:
import Dict exposing (Dict)
-- Vacío
usuarios : Dict Int String
usuarios = Dict.empty
-- Con valores
usuariosIniciales : Dict Int String
usuariosIniciales =
Dict.fromList
[ (1, "Ana")
, (2, "Luis")
, (3, "María")
]
Para buscar un valor por su clave:
Dict.get 2 usuariosIniciales
-- Resultado: Just "Luis"
Dict.get 5 usuariosIniciales
-- Resultado: Nothing
El resultado es un Maybe, lo que evita errores por claves inexistentes.
Podés manejarlo así:
case Dict.get 5 usuariosIniciales of
Just nombre ->
"Usuario encontrado: " ++ nombre
Nothing ->
"No existe ese usuario."
Insertar y eliminar elementos:
-- Agregar o actualizar
usuarios2 =
Dict.insert 4 "Sofía" usuariosIniciales
-- Eliminar
usuarios3 =
Dict.remove 2 usuarios2
Todo es inmutable: estas operaciones devuelven un nuevo Dict, no modifican el original.
Podés convertirlo a lista y trabajar con sus elementos:
Dict.toList usuariosIniciales
-- [(1, "Ana"), (2, "Luis"), (3, "María")]
List.map (\(id, nombre) -> nombre ++ " (" ++ String.fromInt id ++ ")")
(Dict.toList usuariosIniciales)
O usar funciones específicas:
Dict.map (\_ nombre -> String.toUpper nombre) usuariosIniciales
Dict.member key dict: ¿Existe la clave?
Dict.size dict: Cantidad de elementos
Dict.keys dict: Lista de claves
Dict.values dict: Lista de valores
Dict.filter pred dict: Filtra según condición
Dict.union d1 d2: Une dos diccionarios
Dict.merge: Mezcla con control sobre conflictos
Dict en Elm es:
En Elm, un Dict es más que un mapa: es una garantía de orden, seguridad y pureza funcional.
Nos brinda estructuras de datos genéricas, algoritmos reutilizables y utilidades funcionales para escribir código más limpio, rápido y seguro.
Vamos a repasar sus componentes principales y las funciones más usadas.
La STL nos da varios tipos de contenedores, cada uno con su propósito:
Los algoritmos de la STL trabajan sobre iteradores, lo que los hace genéricos y potentes.
#include <algorithm>
#include <vector>
#include <iostream>
int main() {
std::vector<int> numeros = {3, 1, 4, 1, 5, 9};
// sort: ordena
std::sort(numeros.begin(), numeros.end());
// reverse: invierte
std::reverse(numeros.begin(), numeros.end());
// count: cuenta ocurrencias
int cantidad = std::count(numeros.begin(), numeros.end(), 1);
// find: busca un elemento
auto it = std::find(numeros.begin(), numeros.end(), 5);
if (it != numeros.end())
std::cout << "Encontrado: " << *it << std::endl;
// accumulate: suma o acumula valores
int suma = std::accumulate(numeros.begin(), numeros.end(), 0);
std::cout << "Suma total: " << suma << std::endl;
}
Estos algoritmos no dependen del tipo de contenedor.
Si el contenedor tiene iteradores, funciona igual.
Veamos funciones:
std::copy_if: Copia elementos que cumplan una condición
copy_if(v.begin(), v.end(), back_inserter(res), [](int n){ return n > 3; });
std::transform: Aplica una función a cada elemento
transform(v.begin(), v.end(), v.begin(), [](int n){ return n * 2; });
std::for_each: Itera con una función lambda
for_each(v.begin(), v.end(), [](int n){ cout << n << " "; });
std::remove_if: Elimina (lógicamente) los elementos que cumplan una condición
v.erase(remove_if(v.begin(), v.end(), [](int n){ return n % 2 == 0; }), v.end());
Veamos funciones matematicas comunes:
std::min_element(v.begin(), v.end());
std::max_element(v.begin(), v.end());
std::accumulate(v.begin(), v.end(), 0);
std::inner_product(v.begin(), v.end(), v2.begin(), 0);
Y por ultimo unos trucos:
La STL no es solo una librería: es una forma de pensar en C++.
En lugar de escribir bucles y estructuras manuales, usás herramientas ya optimizadas, seguras y expresivas.
