DEV Community: Baltasar García Perez-Schofield

PicoCalc: retro-programando

Baltasar García Perez-Schofield — Tue, 09 Jun 2026 10:07:37 +0000

Algo tarde (en 2026), me he comprado un Clockwork PicoCalc. Tuvo su gran auge a principios de 2025, y muy básicamente se trata de un Cyberdeck que es programable. Y, de hecho, es programable en varios lenguajes de programación.

La que me ha llegado tiene el firmware "antiguo", de manera que las aplicaciones se guardan en la tarjeta como archivos .bin. La PicoCalc viene con los lenguajes de programación Lua, MicroPython, y MMBasic.

Es muy interesante lo que ofrece la PicoCalc desde MMBasic, que es no solo un intérprete de BASIC, sino casi un sistema operativo entero. De hecho, si encendemos la PicoCalc sin la tarjeta SD, lo que arranca es MMBasic, aunque no estoy seguro de si se trata de que es la última aplicación ejecutada.

> files
A:/
<DIR> .
<DIR> ..
rnd.bas

> files "b:"
B:/
0 directories, 0 files

Se nos ofrecen dos unidades, A:, que se almacena en la memoria FLASH de la PicoCalc, y B:, que nos da acceso a la tarjeta SD. Al igual que podíamos hacer en GW-BASIC para PC, tenemos disponibes varios comandos interactivos.

Comando	Explicación
`drive "a:"`	Cambia de unidad, "a:" o "b:"
`files`	Lista los archivos en la unidad actual.
`chdir d$`	Cambia el directorio actual al contenido de d$.
`kill n$`	Elimina el archivo de nombre contenido en n$.
`mkdir d$`	Crea un directorio nuevo de nombre contenido en d$.
`rmdir d$`	Elimina el directorio de nombre contenido en d$.
`rename n1$ as n2$`	Renombra un archivo de nombre en n1$ a n2$.
`list n$`	Lista el contenido del archivo de nombre n$.

Tenemos también aquellos comandos gráficos tan sencillos.

Comando	Explicación
`line a,b,c,d`	Línea de (a, b) a (c, d).
`circle a,b,r`	Círculo en (a, b) y radio r.

La posición (0,0) está en la esquina superior izquierda, mientras que (320, 320) es la esquina inferior derecha.

Un posible programa que se puede crear fácilmente es el del árbol fractal. Se trata de dibujar un árbol a base de piezas con forma de "Y". Empezamos dibujando una Y grande, nos movemos a la punta de la rama izquierda, y llamamos recursivamente a dibujar el árbol; y lo mismo moviéndonos a la rama derecha. Cada vez que nos movemos, dividimos la longitud l por algún valor (en este caso, por 2). Cuando la longitud baja por debajo de 1, ya no tiene sentido seguir dibujando nada, por lo que el algoritmo termina.

El código fuente es bastante sencillo, en realidad. Tecleamos "edit" (o pulsamos F4), y entramos en un editor a pantalla completa para poder escribir cómodamente nuestro programa.

Rem (c) fractal 2026 MIT License

Sub drawBranch(x, y, l)
    Line x, y, x, y - l
    Line x, y - l, x - l, y - (l * 2)
    Line x, y - l, x + l, y - (l * 2)
End Sub

Sub drawTree(x, y, l)
    drawBranch(x, y, l)
    drawBranch(x - l, y - (l * 2), l / 2)
    drawBranch(x + l, y - (l * 2), l / 2)
End Sub

Sub main()
    drawTree(160, 320, 75)
End Sub

main()

Solo queda guardarlo en la tarjeta SD:

drive "b:"
save "fractal.bas"

¿Y tú, también retro-programas?

Union(C#, F#)

Baltasar García Perez-Schofield — Thu, 04 Jun 2026 12:31:55 +0000

Recientemente se ha celebrado la Microsoft Build 2026, una conferencia donde Microsoft presenta lo último de lo último en desarrollo.

Una de estas novedades fueron los Union Types, que serán soportados en C# 15. C# 15 está soportado en .NET 11, que en este momento se puede descargar como preview, es decir, todavía no es una versión estable.

Una vez descargado, creamos un proyecto estándar con:

$ mkdir unions
$ cd unions
$ dotnet new console

Aunque estamos muy cerca, aún no podemos utilizar uniones. Para poder hacerlo, tendremos que editar el archivo de proyecto (unions.csproj), de manera que incluya <LangVersion>preview</LangVersion>, como se puede ver a continuación.

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net11.0</TargetFramework>
    <LangVersion>preview</LangVersion>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

</Project>

Vamos a definir ahora dos clases. En la mayoría de ejemplos, se utilizan record class, y esto es muy conveniente, son muy útiles. Pero para entenderlo bien, vamos a crear dos clases normales.

public class Person {
    public required string Name { get; init; }

    public override string ToString() => this.Name;
}

public class Employee {
    public required string Name { get; init; }
    public required string Email { get; init; }

    public override string ToString() => $"{this.Name} ({this.Email})";
}

Sería muy típico hacer que Employee derivase de Persona, pero como podemos ver, aunque incluso comparten una propiedad común, esto no es así. Es precisamente un caso en el que podemos crear una union.

public union Persona(Person, Employee);

...y ahora ya podemos crear una lista de elementos Person, o Employee.

var p1 = new Person{ Name = "Baltasar" };
var p2 = new Employee{ Name = "Baltasar", Email = "baltasarq@gmail.com" };
IList<Persona> l = [ p1, p2 ];

Si recorremos la lista, y pretendemos llamar al método ToString(), nos encontramos con que lo que se muestra por pantalla es lo siguiente:

Persona
Persona

Se está llamando al método ToString() de la unión, en lugar de cada uno de los métodos de los objetos pertenecientes a ella. No hay ningún tipo de method forwarding, es decir, de reenvío automático, de llamadas a métodos o propiedades, aunque existan en ambos tipos de la unión. Así, si queremos solucionar esto...

public union Persona(Person, Employee) {
   public override string ToString() => this switch {
           Person p => p.ToString(),
           Employee e => e.ToString()
   };
}

Efectivamente, tenemos que hacer pattern matching, una asociación de tipos, incluso para un caso tan sencillo como este. Podemos hacer algo más automático, como sigue:

public union Persona(Person, Employee) {
    public object Active => this switch {
           Person p => p,
           Employee e => e
    };

    public override string ToString() => this.Active.ToString();
}

Así, podemos simular el reenvío automático de una manera más cómoda, solo llamando a la propiedad Active, que observemos que devuelve object.

¿Y si lo que queremos es, simplemente, crear un identificador común para ambos casos? En el caso de un objeto Person, sería el nombre en minúsculas, y en el caso de Employee, el email en minúsculas.

public union Persona(Person, Employee) {
    public string Id => this switch {
        Person p => p.Name.Trim().ToLower(),
        Employee e => e.Email.Trim().ToLower(),
    };
}

La mayor ventaja de esto es que el compilador nos avisa del caso en el que el switch no es exhaustivo, es decir, no cubre todos los posibles tipos que pueden coexistir dentro de la unión. En ese caso, nos lanzaría un aviso durante la compilación.

Hay que tener en cuenta que las uniones son siempre discriminativas. Es decir, o contienen un objeto de un tipo o del otro. Esto choca con lo que se ha dicho de "está pensado para los métodos que se quiere que se devuelvan dos valores". Esto solo es cierto si se trata de un valor u otro, en otro caso, tendremos que utilizar una tupla, o quizás una lista.

Es en este matiz donde entra la programación funcional, de donde principalmente se ha obtenido la idea para este nuevo tipo. En este tipo de programación, es típico tener un resultado que puede contener un valor o un error.

public union Result<T>(T, Exception);

De esta manera, podemos gestionar errores a la Rust, lenguaje de programación que no soporta manejo de excepciones, sino que se maneja con retornos que pueden ser correctos o contener un estado de error. Por ejemplo, la función panic(msg) toma uno de estos resultados, y en caso de error muestra el mensaje msg por pantalla y termina el programa inmediatamente.

Bueno, lo primero de todo es lograr que se lance una excepción o se devuelva el valor correcto.

public union Result<T>(T, Exception) {
    public T Get() => this switch {
        Exception e => throw e,
        T t => t
    };
}

De esta manera, cuando intentemos obtener con Get() el valor obtenido de una función, en caso de que se trate de una excepción esta se lanza inmediatamente.

El método Panic(msg: string): object, es mucho más tradicional.

public union Result<T>(T, Exception) {
    public T Get() => this switch {
        Exception e => throw e,
        T t => t
    };

    public object Panic(string msg)
    {
        object? toret = null;

        switch (this) {
            case Exception e:
                throw new Exception( msg, e );
            default:
                toret = this.Get();
                break;
        }

        return toret;
    }
}

Con esta unión podemos crear código como el siguiente:

class ... {
    // Más cosas...
    public Result<string> ReadFile(string fn)
    {
        Result<string> toret;

        try {
            toret = File.ReadAllText( fn );
        } catch(IOException e) {
            toret = e;
        }

        return toret;
    }
}

En caso de que se produzca una excepción, esta se devuelve, en caso contrario, se almacena el resultado en la misma uníón Result<>.

Al llamar a este método, podemos descartar rápidamente un caso de error:

var result = ReadFile( "unions.cs" ).Panic( "[ERR] while accessing file 'unions.cs'" );
Console.WriteLine( result );

No creo que este tipo de programación cuadre demasiado con un lenguje como C#, que soporta excepciones, pero desde luego, es una posibilidad más.

Creando un Tetris con JavaScript VI: Complicando el juego.

Baltasar García Perez-Schofield — Mon, 25 May 2026 08:41:11 +0000

En la última entrega, dábamos prácticamente por terminado nuestro Tetris. Con el bucle de juego, ya era posible hacer que las piezas bajaran, así como moverlas. También las líneas completas eran eliminadas del tablero, con el siguiente código en showFrame():

showFrame: () => {
    // más cosas...

    let millis = performance.now() - game.startTime;

    if ( millis >= 10 ) {
        game.pushPieceDownTime += 1;

        // más cosas...

        if ( game.piece.row != 0 ) {
            let newScore = 0;

            game.portPieceToBoard();
            newScore = game.calculateScore();
            if ( newScore > 0 ) {
                game.score += newScore;
                pScore.innerText = "" + game.score;
            }

           // Prepare the board
           let filledRows = game.chkFilledRows();

           game.board.removeRows( filledRows );
           game.board.insertEmptyRows( filledRows );
       } else {
           game.stopGame();
       }

       game.chooseNewPiece();
   }
}

En la parte del comentario // Prepare the board, lo que hacemos es tomar los índices de aquellas filas que están llenas con trozos de fichas (su contenido es 1 en todas las celdas), y después llamar a Board.removeRows() para que las elimine. Entonces rellenamos con filas vacías por la parte delantera del tablero (la parte superior), de manera que el nivel de fichas "baja" tanto como filas hayamos eliminado.

De la modificación a continuación es de donde viene el nombre Insertrix: vamos a añadir filas "basura" en parte, además de seguir rellenando con filas vacías la parte superior. Estas filas "basura" serán filas que contendrán ceros y unos al azar. Hay algunos Tetris que, además de acelerar el tiempo de bajada de cada pieza, hacen esto para hacerte perder cuando ya llevas mucho tiempo jugando. En esta versión, la velocidad no va a variar, pero pueden introducirse muchas más filas "basura" que una fila cada cierto tiempo.

En concreto, vamos a introducir filas "basura" cuando llegue el momento de bajar el tablero el mismo número de filas que las que se han eliminado. Vamos a meter la mitad más uno de filas vacías, y el resto con filas basura. El algoritmo es el siguiente. Sabemos el número de filas total a rellenar porque tenemos la longitud del vector de índices de filas a eliminar, filledRows.length. Así, si calculamos la mitad sin redondear, tomando la parte entera: let numTrashRows = parseInt( filledRows.length / 2 ), tendremos exactamente la mitad o la mitad menos uno en numTrashRows, si filledRows.length es impar. Este se hace así para favorecer al usuario.

Por ejemplo, si el usuario elimina una fila, la mitad exacta de la divisón por dos es 0, por lo que se introducen 0 filas basura, y 1 fila vacía.

El código es el siguiente:

showFrame: () => {
    // más cosas...

    let millis = performance.now() - game.startTime;

    if ( millis >= 10 ) {
        game.pushPieceDownTime += 1;

        // más cosas...

        if ( game.piece.row != 0 ) {
            let newScore = 0;

            game.portPieceToBoard();
            newScore = game.calculateScore();
            if ( newScore > 0 ) {
                game.score += newScore;
                pScore.innerText = "" + game.score;
            }

           // Prepare the board
           let filledRows = game.chkFilledRows();
           let numTrashRows = parseInt( filledRows.length / 2 );

           game.board.removeRows( filledRows );
           game.board.insertEmptyRows( filledRows.length - numTrashRows );
           game.board.appendTrashRows( numTrashRows );
       } else {
           game.stopGame();
       }

       game.chooseNewPiece();
   }
}

Ya solo queda añadir al tablero tantas filas basura como nos digan, con el método Board.appendTrashRows(n: Integer). Podemos generar un número entero aleatorio entre 0 y 1 con Math.random() * 2, siempre que lo corrijamos con Math.floor().

class Board {
    // Más cosas...

    appendTrashRows(numRows)
    {
        for(let i = 0; i < numRows; ++i) {
            this.#board.push( Array.from( { length: this.cols }, () => Math.floor( Math.random() * 2 ) ) );
        }
    }
}

En lugar de #board.unshift() utilizamos #board.push(), pues lo que queremos es añadir filas al final. El método estático Array.from(), toma un Array ya existente, y lo modifica con la lambda que le pasemos, su segundo parámetro. En este caso, lo que hacemos es crear un objeto que tiene la propiedad length, lo cual a ojos de Array.from(), lo transforma en un array. Después, la lambda se aplica para cada elemento, con lo que se asigna un valor aleatorio entre 0 y 1.

¡Y ya está! Nuestro juego está listo. Arriba puedes ver cómo al eliminar dos filas, se ha añadido una fila "basura". La partida solo termina cuando una pieza ya no tiene sitio para caer, y se queda "enganchada" en la parte superior. No hay estrés por tener que mover las piezas cada vez más rápido. ¿Te animas a una partida a Insertrix?

Creando un Tetris con JavaScript V: el bucle de juego

Baltasar García Perez-Schofield — Wed, 20 May 2026 11:28:42 +0000

En este momento, sabemos que, utilizando el elemento Canvas de HTML5, podemos dibujar el tablero, así como la pieza que va cayendo. Pero nada se mueve, la pieza no cae, y desde luego, no podemos moverla.

Las piezas disponibles, para seleccionar la que está cayendo en este momento, son las siguientes:

const PIECES = [
            new PieceSquare(),
            new PieceBar(),
            new PieceL(),
            new PieceInverseL(),
            new PieceS(),
            new PieceInverseS() ];

Necesitamos un bucle de juego, y para ello sería interesante disponer de, o bien varias variables y funciones, o mejor todavía, un objeto. Se trataría de una clase que solo tendría una posible instancia. En otro lenguaje de programación, utilizaríamos el patrón Singleton. Pero en JavaScript, podemos crear un objeto único utilizando la notación JSON (JavaScript Simplified Object Notation), que podemos utilizar directamente en nuestro código fuente.

const game = {
    score: 0,
    piece: null,
    board: null,
    canvas: null,
    keysPressed: [],


    pickRandomPiece: () => {
        return PIECES[ Math.ceil( Math.random() * PIECES.length ) - 1 ];
    },


    chooseNewPiece: () => {
        game.piece = game.pickRandomPiece();
        game.canvas.piece = game.piece;
        game.piece.reset( game.board.cols );
    },

    // más cosas...
}

Nuestro objecto, que va a llevar el estado del juego, es game. Dentro de este objeto, construiremos el tablero del juego, la pieza actual, el canvas donde vamos a pintar el juego, etc.

const game = {
    // más cosas...    
    stopGame: () => {
        const dvStart = document.getElementById( "dvStart" );
        const dvGame = document.getElementById( "dvGame" );

        dvStart.style.display = "block";
        dvGame.disabled = true;
    },

    // más cosas...
}

En nuestro (parco) HTML, tendremos un botón (Button), que servirá para comenzar el juego. Habrá un DIV que contendrá este botón, y un segundo DIV que contendrá el HTML Canvas. Según ocultemos o visualicemos (style="display: none") o (style="display: block"), cada uno de estos DIVs, podremos comenzar el juego o jugar.

const game = {
    startGame: () => {
        const dvStart = document.getElementById( "dvStart" );
        const dvGame = document.getElementById( "dvGame" );
        const cvPaint = document.getElementById( "cvPaint" );

        // Set
        dvStart.style.display = "none";
        dvGame.disabled = false;

        game.score = 0;
        game.board = new Board( 26, 12 );
        game.canvas = new Canvas( cvPaint, game.board );
        game.chooseNewPiece();

        // Listeners
        window.requestAnimationFrame( () => game.showFrame() );
        document.onkeydown = (e) => {
            if ( e.isComposing
              || e.key === "Dead" )
            {
                return;
            }

            game.keysPressed.push( e );
        };

        return false;
    },

    // más cosas...
}

Además, debemos poder "animar" el juego. Tiene que haber una forma de conseguir que, una vez se pinte un frame, establezcamos algún mecanismo para "encargar" el pintado del siguiente.

Podemos establecer el pintado del primer frame con window.requestAnimationFrame(), al que se le pasa una lambda con el código a ejecutar. De acuerdo, pero... ¿cómo hacemos para ejecutar la siguiente? Pues volvemos a asignar window.requestAnimationFrame().

En cuanto a las pulsaciones de teclas, se utiliza el método document.onkeydown, de manera que en este método se filtran las teclas que no producen ninguna pulsación, y se guarda en la lista keysPressed.

const game = {
    // más cosas...

    chkKeyboard: () => {
        for(let key of game.keysPressed) {
            if ( key.code == "ArrowLeft" ) {
                game.piece.col -= 1;
                if ( game.chkPieceClash() ) {
                    game.piece.col += 1;
                }
            }
            else
            if ( key.code == "ArrowRight" ) {
                game.piece.col += 1;
                if ( game.chkPieceClash() ) {
                    game.piece.col -= 1;
                }
            }
            else
            if ( key.code == "ArrowUp" ) {
                game.piece.rotate();
                if ( game.chkPieceClash() ) {
                    game.piece.unrotate();
                }
            }
            else
            if ( key.code == "ArrowDown" ) {
                game.piece.row += 1;
                if ( game.chkPieceClash() ) {
                    game.piece.row -= 1;
                }
            }
        }

        game.keysPressed = [];
    },

    // más cosas...
}

En cuanto a chkKeyboard(), se detectan las teclas de los cursores, y en caso de que una de ellas sea la flecha hacia arriba, la pieza se rota. En el resto de los casos, la posición de la pieza se cambia... a no ser que se compruebe que coincida con el tablero.

const game = {
    // más cosas...

    chkPieceClash: () => {
        const PIECE = game.piece;
        const BOARD = game.board;

        let toret = 1;

        if ( game.chkInbounds() ) {
            toret = 0;

            for(let i = 0; i < PIECE.height; ++i)
            {
                if ( ( PIECE.row + i ) >= BOARD.rows ) {
                    break;
                }

                for(let j = 0; j < PIECE.width; ++j)
                {
                    if ( ( PIECE.col + j ) >= BOARD.cols ) {
                        break;
                    }

                    toret |= PIECE.shape[i][j]
                           & BOARD.cell( PIECE.row + i, PIECE.col + j );

                    if ( Boolean( toret ) ) {
                        break;
                    }
                }
            }
        }

        return Boolean( toret );
    },

    // más cosas....
}

Para comprobar si la pieza coincide con alguna pieza almacenada en el tablero, será necesario comprobar si alguna de las celdas de la pieza y la posición correspondiente en el tablero contienen ambas un 1. En ese caso, la pieza no puede moverse a esa posición, con lo que será necesario deshacer el movimiento. Si es una rotación, será necesario cancelar la rotación (método Piece.unrotate()).

    chkFilledRows: () => {
        const PIECE = game.piece;
        const BOARD = game.board;
        let toret = [];

        for(let i = 0; i < PIECE.height; ++i) {
            const NUM_ROW = i + PIECE.row;

            if ( BOARD.getRow( NUM_ROW ).every( x => Boolean(x) ) ) {
                toret.push( NUM_ROW );
            }
        }

        return toret;
    },

    portPieceToBoard: () => {
        const PIECE = game.piece;
        const BOARD = game.board;
        const MAX_HEIGHT = Math.min( BOARD.rows - 1, PIECE.row + PIECE.height );
        const MAX_WIDTH = Math.min( BOARD.cols - 1, PIECE.col + PIECE.width );

        for(let i = 0; i < PIECE.height; ++i) {
            for(let j = 0; j < PIECE.width; ++j) {
                const BOARD_POS_ROW = PIECE.row + i;
                const BOARD_POS_COL = PIECE.col + j;

                if ( BOARD_POS_ROW >= BOARD.rows
                  || BOARD_POS_COL >= BOARD.cols )
                {
                    break;
                }

                if ( Boolean( PIECE.shape[ i ][ j ] ) ) {
                    BOARD.setCell( BOARD_POS_ROW, BOARD_POS_COL );
                }
            }
        }

        return;
    }

    // más cosas...
}

El método chkFilledRows() comprueba si todas las celdas de alguna de las filas del tablero están llenas. Con el método every() para Array, podemos comprobar si se cumple una condición. De nuevo convertimos los 1 y 0 de la fila a booleano, y comprobamos entonces si todas dan true. En este último caso, pasamos el índice de la fila a un Array que vamos a devolver. Después llamaremos a Board.removeRows() para eliminarlas.

El método portPieceToBoard() comprueba todas las celdas de una pieza, y que en caso de que contengan un 1, portar ese 1 a la misma posición, pero en el tablero.

Ya solo nos falta comprobar si hay colisión entre la pieza que desciende y el contenido del tablero. Nos aprovechamos de que tanto la pieza como el tablero son Array's, y que en caso de que la posición esté ocupada, en cualquiera de los dos casos, va a contener un 1. Así, un and, nos permite generar un booleano que nos diga si hay coincidencia entre alguna de las casillas.

const game =
    // más cosas...

    chkPieceClash: () => {
        const PIECE = game.piece;
        const BOARD = game.board;

        let toret = 1;

        if ( game.chkInbounds() ) {
            toret = 0;

            for(let i = 0; i < PIECE.height; ++i)
            {
                if ( ( PIECE.row + i ) >= BOARD.rows ) {
                    break;
                }

                for(let j = 0; j < PIECE.width; ++j)
                {
                    if ( ( PIECE.col + j ) >= BOARD.cols ) {
                        break;
                    }

                    toret |= PIECE.shape[i][j]
                           & BOARD.cell( PIECE.row + i, PIECE.col + j );

                    if ( Boolean( toret ) ) {
                        break;
                    }
                }
            }
        }

        return Boolean( toret );
    },

    // más cosas...
}

Y finalmente, el núcleo del juego. En él, se comprueban las teclas pulsadas, se cambia la posición de la pieza si es necesario, se comprueba si coincide con el fondo del tablero o no, o si la pieza ya no puede moverse desde la primera fila (en ese caso, el juego termina). En cualquier caso, al final ya con la posición de la pieza definitiva, es cuando se pinta el frame.

const game = {
    // más cosas...

    showFrame: () => {
        const pScore = document.getElementById( "pScore" );
        let millis = performance.now() - game.startTime;

        if ( millis >= 10 ) {
            game.pushPieceDownTime += 1;

            if ( game.pushPieceDownTime >= 40 ) {
                game.pushPieceDownTime = 0;
                game.piece.row += 1;
                const isAtBottom = ( game.piece.row + game.piece.height ) >= game.board.rows;

                if ( game.chkPieceClash()
                  || isAtBottom )
                {
                    if ( !isAtBottom ) {
                        game.piece.row -= 1;
                    }

                    if ( game.piece.row != 0 ) {
                        let newScore = 0;

                        game.portPieceToBoard();
                        newScore = game.calculateScore();
                        if ( newScore > 0 ) {
                            game.score += newScore;
                            pScore.innerText = "" + game.score;
                        }

                        let filledRows = game.chkFilledRows();
                        game.board.removeRows( filledRows );
                        game.board.insertEmptyRows( filledRows.length );
                    } else {
                        game.stopGame();
                    }

                    game.chooseNewPiece();
                }
            }

            game.chkKeyboard();            
            game.drawFrame();
            game.startTime = performance.now();
        }

        window.requestAnimationFrame( () => game.showFrame() );
    },

    // más cosas...
}

Primero se hacen varias comprobaciones en cuanto a que haya pasado suficiente tiempo. De otra forma, se pintarían demasiados frames, y dado que pintar un solo frame lleva un tiempo, se establece un tiempo de 10 ms. mínimo entre frames. También se establece el contador pushPieceDownTime, de manera que el tiempo entre el movimiento de la pieza que cae, y el siguiente, sea de al menos 400 ms., es decir, casi medio segundo. Finalmente, se comprueba el teclado, se pinta el frame, y se vuelve a llamar a window.requestAnimationFrame() para el siguiente frame.

En cuanto a la pieza, en caso de que al caer una fila más en el tablero, esta coincida con los restos, entonces se porta esa pieza al tablero (pasa a formar parte de los restos), se comprueba si hay filas completamente rellenas, y en ese caso se eliminan, y se insertan tantas filas en blanco como sea necesario.

Y básicamente ya está. Puedes ver el código, y echar unas partidas en el repo de GitHub para Insertrix.

¿Y si Python permitiera 'end' como fin de bloque? (y III)

Baltasar García Perez-Schofield — Tue, 12 May 2026 08:12:54 +0000

El otro día, por razones que no vienen mucho al caso, me pregunté cómo de difícil sería añadir la posibilidad de incorporar ese end como marca de fin de bloque, por mi mismo. Así que me dirigí al repositorio de cPython, el intérprete de Python, y me lo bajé.

Ya en el propio README me encontré un enlace a la referencia de desarrollador de Python, lo que me serviría de guía en el proceso.

Lo primero que me planteé fue una modificación de la gramática. El directorio Grammar/ parecía prometedor, y, efectivamente, allí nos encontramos con python.gram, el archivo que representa a la gramática actual del lenguaje.

Aparecen muchas reglas EBNF, y una de ellas es la que parece más prometedora:

pass_stmt[stmt_ty]:
    | 'pass' { _PyAST_Pass(EXTRA) }

Al fin y al cabo, la forma más sencilla de lograr una marca de fin de bloque, que no implique generación de código, es crear un sinónimo de la palabra clave pass.

pass_stmt[stmt_ty]:
    | 'pass' { _PyAST_Pass(EXTRA) }
    | 'end'  { _PyAST_Pass(EXTRA) }

De acuerdo, ahora falta generar la gramática y compilar. Un vistazo rápido a la guía del desarrollador nos dice que lo que debemos hacer es:

$ make regen-pegen
$ make -j4

Le estamos pidiendo que regenere la gramática, y estamos recompilando cpython con 4 procesos. En Linux, el comando nproc nos dice cuántos procesos se pueden ejecutar concurrentemente. Así que podemos incluso ejecutar `make -j$(nproc)', lo cual automáticamente genera el número máximo de trabajos soportados.

En cualquier caso, nos encontraremos con este mensaje de error:

SyntaxError: invalid syntax (posixpath.py, line 305)

Si nos vamos a esa línea de posixpath.py, nos encontraremos con el uso de end como variable:

$ cat -n Lib/posixpath.py| grep 305
305:        end = b'}'

Esto es un problema. Si curioseamos un poco más, veremos que las variables start/end son bastante populares. Así que nos nos queda más remedio que deshacer el cambio en python.gram, y recompilar.

$ make regen-pegen
$ make -j4

Tiene que haber una forma más sencilla. No puede ser que creemos una nueva característica, que claramente tiene que ser opcional, pero que a la vez esta colisione con código ya existente.

Sabemos que Python tiene un módulo llamado __builtins__ que incorpora funciones y constantes que, por decirlo de alguna manera, siempre están disponibles. Es el caso de print, por poner un ejemplo.

>>> __builtins__
<module 'builtins' (built-in)>
>>> dir(__builtins__)
[
    # (...más cosas...)
    'abs', 'aiter', 'all', 'anext', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'end', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozendict', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'sentinel', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip'
]

Si pudiéramos añadir end como una constante en ese módulo, equivalente a ..., pues... ya estaría. El código Python sería:

end = ...

La cuestión es dónde se definen estas funciones, como print, o "..." que es la ellipsis. De hecho, si buscamos con:

$ grep -i "ellipsis" Grammar/python.gram
230:# note below: the ('.' | '...') is necessary because '...' is tokenized as ELLIPSIS
903:    | '...' { _PyAST_Constant(Py_Ellipsis, NULL, EXTRA) }

$ grep -niR "ellipsis" --include "*.c"
(...más cosas...)
Python/bltinmodule.c:3535:    SETBUILTIN("Ellipsis",              Py_Ellipsis);

Entonces nos encontramos con que Ellipsis, que representa a ..., es tokenizado como Py_Ellipsis. Si extendemos la búsqueda a los archivos de extensión .c, nos encontraremos con que hay un archivo llamado bltinmodule.c, que es precisamente el que estamos buscando. Así que justo debajo de la línea 3535, añadimos nuestra nueva definición:

SETBUILTIN("end",              Py_Ellipsis);

Y recompilamos:

$ make -j4

Esto genera el ejecutable python en la raiz. ¡Podemos lanzarlo y probarlo!

$ ./python

Python 3.15.0a8+ (heads/main-dirty:5fcab14c350, May 12 2026, 09:35:43) [GCC 15.2.1 20260209] on linux
Type "help", "copyright", "credits" or "license" for more information.

>>> end
Ellipsis

¡Funciona! Hagamos una prueba (hecho en el propio REPL):

class Entero:
...     def __init__(self, x):
...         self._x = x
...     end
...     @property
...     def x(self):
...         return self._x
...     end
...     def __str__(self):
...         return str(self.x)
...     end
... end
... 
Ellipsis
>>> e1 = Entero(42)
>>> e1.x
42
>>> str(e1)
'42'

Si pasamos este código a un archivo test_end.py:

class Entero:
    def __init__(self, x):
        self._x = x
    end

    @property
    def x(self):
        return self._x
    end

    def __str__(self):
       return str(self.x)
    end
end


if __name__ == "__main__":
    e1 = Entero(42)
    print(e1)
end

Y lo ejecutamos con ./python test_end.py, obtenemos:

Y así concluye el viaje. Se puede obtener el comportamiento deseado modificando el módulo __builtins__ de Python. ¡Un interesante ejercicio, al menos!

Hackeando una app para marcadores web

Baltasar García Perez-Schofield — Thu, 07 May 2026 10:40:32 +0000

Cuando comienzas un proyecto, lo haces porque consideras que va a ser algo fácil, que te va a llevar poco (diez minutos, un par de horas...). Cualquier proyecto, por pequeño que sea, siempre duplica, triplica o quintuplica el tiempo estimado para su realización.

Pero si no fuesemos tan positivos... ¡nunca comenzaríamos un proyecto! Veamos, ¿qué necesitamos para crear un marcador web en Python?

from typing import ClassVar
from datetime import datetime
from dataclasses import dataclass


@dataclass
class Bookmark:
    name: str
    url: str
    parent: object
    NUM: classvar[int] = 0

    def __init__(self, name, url, parent=None):
        Bookmark.NUM += 1

        if not url:
            url = "https://info.cern.ch/"

        name = name.strip()
        if not name:
            dt = datetime.now()
            name = f"name{Bookmark.NUM}-{dt.year:04}{dt:month:02}{dt.day:02}";

        self.name = name
        self.url = url
        self.parent = parent

    def __str__(self):
        return f"{self.name}: {self.url}"

También necesitamos una lista de Bookmarks:

class BookmarkList:
    """A list of bookmarks or other objects BookmarkList"""
    def __init__(self, name="", parent=None, initial_bml=None):
        self._parent = parent
        self._lb = {}

    @property
    def all(self):
        return self._lb.values()

    def add(self, bm: {Bookmark|BookmarkList}):
        """Adds a new entry, or a new list of bookmarks"""
        self._lb[bm.name] = bm
        bm.parent = self

    def get(self, name) -> {Bookmark|BookmarkList|None}:
        return self._lb.get(name)

    def delete(self, name: str):
        if name in self._lb:
            del self._lb[name]
            return True

        print("Not deleted")
        return False

    def at(self, i):
        return list(self._lb.values())[i]

    def __len__(self):
        return len(self._lb)

Y ahora viene la parte realmente interesante, en la que grabamos y cargamos una lista de enlaces (que puede ser recursiva). Guardar es muy fácil. Solo tenemos que guardar las listas de enlaces entre marcas dl, y cada enlace (como un hiperenlace), dentro de una marca dt. Además, el nombre de cada lista va dentro de las marcas dl, como un dt que tiene dentro una marca h3 con el nombre.

class PersistentBookmarks:
    """Persistence for bookmarks, read/write."""
    INDENT = "    "

    def __init__(self, bms: BookmarkList):
        """Creates a new saving PersistentBookmarks.
            :param bms: a bookmarks list
        """
        self._bms = bms

    def save(self, nf: str):
        """Saves the list of bookmarks.
            :param bf: a path to save the BookmarkList to.
        """
        if self._bms is None:
            return

        with open(nf, "wt") as f:
            PersistentBookmarks.write_headers(f)
            self._save_bms_to(f, 1, self._bms)

    def _save_bms_to(self, f, lvl, bms: BookmarkList):
        """Recursively saves a given BookmarkList.
            :param f: the file to save.
            :param lvl: the indent level.
            :param bms: the BookmarkList to save.
        """
        indent = PersistentBookmarks.INDENT * lvl
        inner_indent = indent + PersistentBookmarks.INDENT
        f.write(f"\n{indent}<dl>\n")
        f.write(f"{indent}<dt><h3>{bms.name}</h3></dt>\n")

        for entry in bms:
            if isinstance(entry[1], BookmarkList):
                self._save_bms_to(f, lvl + 1, entry[1])
            else:
                f.write(f"{inner_indent}<dt><a href=\"{entry[1].url}\">"
                        + f"{entry[0]}</a></dt>\n")
        f.write(f"\n{indent}<dl>\n")

    @staticmethod
    def write_headers(f):
        """Writes the required headers pf the bookmarks file."""
        f.write("<!DOCType NETSCAPE-Bookmark-file-1>\n")
        f.write("<meta http-equiv=\"Content-Type\" ")
        f.write("content=\"text/html;charset=UTF-8\">\n")
        f.write("<title>Bookmarks</title>\n")
        f.write("<h1>Bookmarks</h1>\n\n")

El trabajo duro lo hace la función _save_bms_to(lvl, bms), que guarda la lista de enlaces con un nivel (lvl), determinado. Este parámetro sería totalmente opcinal, solo se usa, en realidad, para crear la indentación adecuada y tener un archivo que sea agradeblemente legible. Esto lo conseguimos asignando a la variable inner_indent la expresión " " * lvl. Así, tendremos cuatro espacios de indentación, tantas veces como el nivel en el de lista anidada en el que estemos.

Así conseguimos algo como esto:

    <dl>
    <dt><h3>Bookmarks</h3></dt>
        <dl>
        <dt><h3>News</h3></dt>
            <dt><a href="https://www.youtube.com/">YouTube</a></dt>
            <dt><a href="http://thedailywtf.com/">The Daily WTF: Curious Perversions in Information Technology</a></dt>
            <dt><a href="http://www.facebook.com/">fb</a></dt>
            <dt><a href="https://slashdot.org/">Slashdot: News for nerds, stuff that matters</a></dt>
        </dl>
        <dl>
        <dt><h3>Tools</h3></dt>
            <dt><a href="http://www.ilovepdf.com/">I Love PDF</a></dt>
            <dt><a href="http://ideone.com/">Ideone.com | Online IDE & Debugging Tool</a></dt>
        </dl>
    </dl>

Recuperar los bookmarks es un pelín más complicado. Lo lógico es utilizar la extensa librería estándar de Python, y esta nos provee de la clase HTMLParser en el módulo html.parser. Esta librería funciona como eventos, es decir, el método handle_starttag()' es llamado cuando se encuentra una marca o _tag_ abierta, y otro (handle_endtag()'), cuando se encuentra cerrada.

class BookmarksFileParser(HTMLParser):
    """Parses a bookmarks file."""
    class Status(Enum):
        """State for the finite machine."""
        TOP_LEVEL = auto()
        READ_ENTRY = auto()
        READ_NAME = auto()
        READ_BOOKMARK = auto()

    def handle_starttag(self, tag, attrs):
        ...

    def handle_endtag(self, tag):
        ...

    def handle_data(self, data):
        data = data.strip()

        if data:
            match self._status:
                case BookmarksFileParser.Status.READ_NAME:
                    self._current_name = data
                case BookmarksFileParser.Status.READ_BOOKMARK:
                    self._curr.add(Bookmark(data, self._url))

Así que tenemos que crearnos un pequeña máquina de estados para saber en qué punto estamos (de ahí el enumerado Status). Por ejemplo, no es lo mismo encontrarse con un h3 cuando se espera el nombre de una lista, o un a cuando se espera encontrarnos con un enlace.

En el método start_tag():

class BookmarksFileParser(HTMLParser):
    # más cosas...
    def handle_starttag(self, tag, attrs):
        match tag.lower():
            case "dl":
                new_list = BookmarkList(self._current_name, self._curr)

                if self._bms is None:
                    self._bms = new_list

                if self._curr is not None:
                    self._curr.add(new_list)

                self._curr = new_list
                log.info(f"Created new list: {self._curr=}")
                log.info(f"Previous list: {self._curr.parent=}")
                self._status = BookmarksFileParser.Status.TOP_LEVEL
            case "dt":
                self._status = BookmarksFileParser.Status.READ_ENTRY
            case "h3":
                self._status = BookmarksFileParser.Status.READ_NAME
            case "a":
                self._status = BookmarksFileParser.Status.READ_BOOKMARK
                href = [v for (k, v) in attrs if k == "href"]
                if len(href) < 1:
                    raise Exception("couldn't find HREF in a")
                self._url = href[0]
                log.debug(f"{self._url=}")
                log.info(f"Status: {self._status}")

¿Por qué es necesario self._bms is None, o self._curr is not None, cuando normalmente escribiríamos self._bms o not self._curr? Pues porque _bms y _curr son listas, retornarán False no solo cuando son None, sino también cuando están vacías, es decir, no tienen elementos.

El código completo de (así he llamado esta app), Bookmank está en Github.

Python: la importancia de no ser None

Baltasar García Perez-Schofield — Mon, 27 Apr 2026 09:44:10 +0000

Pues verás, estaba yo programando tranquilamente (sí, yo soy de esos que todavía programa a mano, sin preguntarle a ninguna IA), una pequeña, muy pequeña herramienta relacionada con mi anterior entrada, sobre la organización de marcadores web.

El progama utiliza la librería estándar de Python para interpretar HTML, de manera que el archivo de marcadores terminaría representado en memoria como un árbol cuya raiz es BookMarklist, y que dentro puede tener marcadores (Bookmark), u otras listas (BookmarkList). Así que, cuando se llega a un <dl>, debemos crear una nueva lista, y el comportamiento es distinto si estamos en una subrama, o si, en cambio, todavía no tenemos la lista raíz. Tal que así:

new_list = BookmarkList(self._current_name, self._curr)

if not self._bms:
    self._bms = new_list

if not self._curr:
    self._curr.add(new_list)

self._curr = new_list

El atributo self._bms es la lista de marcadores raíz, mientras que self._curr es la lista que está siendo rellenada con nuevos marcadores.

El problema era que el código hacía cosas raras. De hecho, ¡asignaba dos veces la lista raíz! ¿Cómo es posible? Llegué a depurar el código, y comprobé que, aunque self._bms apuntaba a un objeto, estaba entrando en el cuerpo del if, y reemplazándolo por una nueva lista de todas maneras.

Miraba la pantalla, incrédulo. ¿He encontrado un error en el intérprete de Python? Me contesté a mi mismo: "Mmm... posible, pero improbable, muchacho."

Como pasa siempre, aquel hack de cinco minutos ya iba por la hora... con lo que resolví irme al baño. Y estaba entrando por la puerta cuando lo vi claro: ¿y si Python piensa que self._bms es una lista? Y es que efectivamente, me había disparado yo mismo en el pie.

Cuando escribimos if x: ... o if not x: ..., normalmente, esperamos estar comparando x con None, el equivalente a null de Python. Esto está bien en general, pero podemos encontrarnos las siguientes conversiones a bool extras (también conocidas como expresiones truthy o falsy):

Expresión	Valor booleano
""	False
" "	True
"balta"	True
0	False
1	True
42	True
0.0	False
1.0	True
42.0	True
[]	False
[None]	True

El problema es: ¿a partir de cuándo un objeto se considera una lista?
Veámoslo.

from dataclasses import dataclass


@dataclass
class Markdown:
    name: str
    url: str


class MarkdownList:
    def __init__(self):
        self._l = []

    def add(self, m: {Markdown|MarkdownList}):
        self._l.append(m)

    def __getitem__(self, item):
        return self._l[item]

    def __str__(self):
        return str.join(", ", [str(x) for x in self._l])


if __name__ == "__main__":
    m0 = None
    m1 = MarkdownList()
    m2 = MarkdownList()
    m2.add(Markdown("dev.to", "http://dev.to/"))

    print(f"{bool(m0)=} {isinstance(m0, list)=}")
    print(f"{bool(m1)=} {isinstance(m1, list)=}")
    print(f"{bool(m2)=} {isinstance(m2, list)=}")

La salida de este programa es la que esperamos. Es decir, si la referencia apunta a un objeto, True, si apunta a None, False.

bool(m0)=False isinstance(m0, list)=False
bool(m1)=True isinstance(m1, list)=False
bool(m2)=True isinstance(m2, list)=False

No es la sobrecarga del operador [] (mediante __getitem__) lo que hace que Python entienda el objeto MarkdownList como una lista. Podemos crear el método __iter__ para que se pueda hacer directamente un bucle for con el objeto MarkdownList, por ejemplo, si m1 es una referencia a un objeto MarkdownList: for x in m1: print(x). Pues aunque lo incluyamos, Python no lo considerará una lista, y la salida será igual a la anterior. Lo que hace que Python considere una clase como una lista (veremos má detalles sobre esto más adelante), es el método __len__, lo que hace que podamos utilizar len(m1) directamente, devolviéndonos el número de elementos almacenados.

class MarkdownList:
    def __init__(self):
        self._l = []

    def add(self, m: {Markdown|MarkdownList}):
        self._l.append(m)

    def __getitem__(self, item):
        return self._l[item]

    def __iter__(self):
        return (x for x in self._l)

    # el "culpable"
    def __len__(self):                        
        return len(self._l)

    def __str__(self):
        return str.join(", ", [str(x) for x in self._l])

Ahora la salida es:

bool(m0)=False isinstance(m0, list)=False
bool(m1)=False isinstance(m1, list)=False
bool(m2)=True isinstance(m2, list)=False

Nótese que Python cambia el significado de truthy/falsy, pero desde luego no lo considera un objeto derivado de list.

Investigando un poco (ahora sí, con la ayuda de la IA, que es fantástica para resumir documentación), resulta que Python maneja el concepto de protocolo; en este caso, el protocolo Sequence se activa si la clase contiene el método __len__. Aún así, la clase base de MarkdownList no cambia, sigue siendo Object.

Pero sí que hay una clase que de repente reconoce a MarkdownList como suya, y se trata de collections.abc.Sized. Así, si cambiamos los print del final del código anterior como sigue:

from collections.abc import Sized

# ...más cosas...

print(f"{bool(m0)=} {isinstance(m0, Sized)=}")
print(f"{bool(m1)=} {isinstance(m1, Sized)=}")
print(f"{bool(m2)=} {isinstance(m2, Sized)=}")

La salida pasa a ser:

bool(m0)=False isinstance(m0, Sized)=False
bool(m1)=False isinstance(m1, Sized)=True
bool(m2)=True isinstance(m2, Sized)=True

Aunque, insisto de nuevo, la clase base de MarkdownList no ha cambiado por el hecho de tener el método __len__ la clase Sized la reconoce como suya mediante un mecanismo que se basa en el método __subclasshook__. Este método comprueba la presencia de __len__ en la clase, y esto hace que pase a reconocerla como subclase, y que isinstance(m1, Sized) pase a devolver True.

Es desde luego muy curioso. Igual que el hecho de que no es necesario que una clase defina el método __iter__ para que sea iterable, es suficiente con el método __getitem__. Algo similar a lo que sucede con la clase collections.abc.Sized, sucede con la clase collections.abc.Iterable, que reconoce una clase como subclase si define el método __iter__. Según parece, esto último es el comportamiento deseado, pero en las versiones anteriores del lenguaje el bucle for x in l, en caso de que l no tuviese un método __iter__, pasaban a usar __getitem__ como último recurso, desde 0 hasta la captura de IndexError; y este comportamiento se mantuvo hasta hoy. Curioso, teniendo en cuenta la ruptura con el pasado que se hizo a partir de Python 3.0.

Ahora que sé esto, puedo seguir utilizando if a esperando False si a es None, pero teniendo el cuidado de respetar aquellas clases que definan __len__.

Afortunadamente, hay una forma de comprobar si una referecia apunta a None que va a tener siempre el mismo comportamiento:

m0 = None
m1 = MarkdownList()

if m0 is not None:
    # The following line is not executed
    m0.add(Markdown("dev.to", "http://dev.to/")

if m1 is not None:
    # Yes! This is now executed.
    m1.add(Markdown("dev.to", "http://dev.to/")

Esto es explícito y funciona siempre. Pero tengo que reconocer que me he llevado una sorpresa desagradable con todo este asunto. Python es relativamente puro y está lejos de ser un lenguaje de programación que te sorprenda desagradablemente según el escenario (como *C++, por poner un archiconocido ejemplo), y sin embargo, he caído en esta trampa, que no me esperaba.

Si seguimos el principio de que un lenguaje debe darte el menor número de sorpresas de este tipo, entonces podemos decir que Python me ha decepcionado un tanto.

¿Cómo guardar tus marcadores web?

Baltasar García Perez-Schofield — Mon, 20 Apr 2026 11:23:47 +0000

El otro día llegó el momento: tenía que organizar mis marcadores web. Los bookmarks. Un buen día, los había guardado desde Firefox, pero era plenamente consciente de que había muchos que ya no usaba. Así que me puse a ello.

Como los había guardado desde Firefox, lo había hecho en el formato nativo de Firefox: HTML. Pues sí. Como sabemos, Firefox no es sino la versión liberada de Netscape Navigator, el navegador privativo que reinó sobre Internet y los usuarios, hasta que fue destronado por Internet Explorer, el infame navegador de Microsoft. Infame porque Microsoft, para atacar a Netscape, lo incluyó de forma gratuita en todos los Windows, llegando a aducir que era un componente central del sistema operativo ante la eventual demanda por monopolio.

Pero centrémonos: el caso es que Netscape Navigator exportaba sus bookmarks (también conocidos como favoritos) en formato HTML. De hecho, se puede abrir en cualquier navegador y utilizar sus enlaces.

Así que me dispongo a buscar un formato más extendido: ¿CSV? Sí, pero como siempre, no está muy estandarizado. ¿JSON? Vale, pero solo es soportado por algunos navegadores, y de nuevo el formato no está muy estandarizado. Pero entonces, ¿cuál es el formato más estándar para almacenar enlaces web, de manera que puedan importarse en cualquier navegador? Pues el formato en el que ya los tenía, HTML. ¿Bien, no?

Bueno, al abrirlo, aquello es un desastre. Hay un montón de ruido. Muchos campos binarios en formato base64. Parece que lo que trata de hacer el archivo es guardar los iconos (favicon), para cada página enlazada.

Lo estudio con más detenimiento: mi objetivo es que aquel archivo sea manejable, así que intento ver qué puedo eliminar. Por ejemplo, a continuación pongo un enlace tal cuál aparece bajo un epígrafe.

    <!DOCType NETSCAPE-Bookmark-file-1>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>Bookmarks</title>
    <h1>Bookmarks</h1>
    <p><dt><p>
        <h3 ADD_DATE="1079992089" LAST_VISIT="1132078168">Tools</h3>
        <dl><p>
            <dt><a ADD_DATE="1079992089" LAST_VISIT="1132078168" FAV_ICON="...base64:dfdfdfldmndfljdpfudñfdmfdmfdoipjifohnlñjkdfngspopshgosigvnsǵnsñglgjagnaslgr" href="http://www.ilovepdf.com/">I Love PDF</a>
...
    </dl>

Podemos extraer la siguiente información:

Marca	Explicación
`dt`	marca indiferentemente un marcador o un epígrafe.
`dl`	marca de una lista de marcadores o epígrafes.
`h3`	marca de los epígrafes.
`a`	marca de un marcador, como un hiperenlace.
`add_date`	campo de la fecha de adición, como un entero.
`last_visit`	campo del último acceso al marcador.
'fav_icon`	campo que contiene una imagen en base64.
`p`	marca para párrafos separando marcadores.
`hr`	marca para los separadores de los menús.

A mi el icono no me interesa. La fechas de adición y acceso tampoco me interesan. Los párrafos son totalmente accesorios. El preámbulo parece conveniente mantenerlo. Pero al final, solo es necesario listar epígrafes con listas de hiperenlaces.

Así el código anterior se simplifica notablemente, y permite, ahora sí, que el archivo sea manejable y siga siendo funcional.

html <!DOCType NETSCAPE-Bookmark-file-1> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>Bookmarks</title> <h1>Bookmarks</h1> <dl> <dt><h3>Noticias</h3> <dl> <dt><a href="https://www.youtube.com/">YouTube</a> <dt><a href="https://www.google.com/calendar/">Google Calendar</a> <dt><a href="http://thedailywtf.com/">The Daily WTF: Curious Perversions in Information Technology</a> <dt><a href="https://slashdot.org/">Slashdot: News for nerds, stuff that matters</a> <dt><a href="http://www.codinghorror.com/blog/">Coding Horror</a> <dt><a href="http://www.osnews.com/">OSNews</a> <dt><a href="http://blogs.msdn.microsoft.com/oldnewthing/">The Old New Thing</a> <dt><a href="http://www.zonadepruebas.com/">ZonaDePruebas</a> <dt><a href="https://blog.cleancoder.com/">Clean Coder Blog</a> </dl> ... </dl>

¡Y se sigue pudiendo manejar como un archivo HTML normal y corriente!

Bookmarks

Noticias

¿Y tú, cómo manejas tus marcadores?

Evolución de los precios de los carburantes en España

Baltasar García Perez-Schofield — Mon, 13 Apr 2026 11:15:17 +0000

En esta entrada, me planteé corroborar la impresión general de que los precios de los carburantes en España se deben a la pura y simple especulación, y no directamente del precio del petróleo. Para hacer esto, la elección parecía obvia: Python con Pandas.

Origen de los datos

Pude obtener la evolución del precio del barril Brent desde una plataforma de inversión llamada investing.com. Los precios de la Gasolina y el Gasóil, los obtuve de la plataforma de datos de Europa Press.

Lo ideal hubiera sido tomar todos estos datos de los datos publicados por el ministerio correspondiente del gobierno de España. Sin embargo, aunque los datos sí se ofrecen, se hace en formato tipo texto, como documento PDF, de manera que los datos no son directamente utilizables.

Preparando los datos

Primero había que limpiar los datos. Se puede hacer de muchas formas, pero por ejemplo podemos transformar los precios en dólares que utilizan comas, de esta manera:

import pandas as pd

df = pd.read_csv("historico_precio-petroleo_brent.csv")
df.Precio = pd.to_numeric(df.Precio.str.replace(",", "."))
df.to_csv("historico_precio-petroleo_brent.csv", index=False)

En este caso, se transforma la columna de una columna de texto (de ahí que se acceda a df.Precio.str.replace(',', '.'). Esta propiedad str le dice a Pandas que debe aplicar el cambio a todos los valores de la columna. Utilizamos pd.to_numeric() para también convertir a número todos los valores.

Pero lo más importante es que el histórico de precios del barril Brent se ofrece mediante la fecha del domingo de cada semana, y el histórico de precios de carburantes en España, mediante el año y el número de semana de ese año. Podemos convertir la fecha del domingo de los datos del barril Brent en la descomposición en Año y Semana.

df.Fecha = df.Fecha.str.split('/').apply(lambda x: str.join('-', reversed(x)))
df.Fecha = pd.to_datetime(df.Fecha)
df["Semana"] = df.Fecha.dt.isocalendar().week
df["Año"] = df.Fecha.dt.year

Como las fechas se ofrecen en formato español, primero se divide por el carácter '/', se invierten su orden, y se vuelven a combinar usando el carácter '-'. Finalmente, se convierten en datos fecha desde sus valores como texto, y desde ahí se extraen Año y Semana. Ahora ya es posible combinar ambos datasets, dfbrent (el precio del barril Brent), y dfes (el precio de los carburantes en España).

dfr = dfbrent.merge(dfes, on=["Año", "Semana"])
dfr = dfr[dfr['Gasolina'].notna() & dfr['Gasóil'].notna()]
dfr.to_csv("normalized_data.csv", index=False)

Combinamos ambos datasets, y filtramos aquellas filas que tienen NaN como valores para los precios de la Gasolina o el Gasóil (tenemos más datos del dataset dfbrent que del dfes). Los datos se guardan en el archivo normalized_data.csv.

Ahora ya podemos analizar un poco los datos. Si ejecutamos lo siguiente, estaremos agrupando los datos por año, siempre que el barril de Brent estuviera por encima de 110.

df_by_year = df[df.Brent > 110].groupby("Año")[['Semana', 'Brent', 'Gasolina', 'Gasóil']]

    print(df_by_year)
    for year, group in df_by_year:
        print(f"\nYear: {year}")
        print(group)

Datos más relevantes

Los datos más relevantes se obtienen filtrando por el precio del mayor Brent mayor que 110, de manera que se observa cómo los precios sí crecen con el precio del barril, pero no decrecen cuando este decrece. Además, los precios actuales no se corresponden con el precio del barril Brent, pues podemos ver como el barril Brent en la semana 9 de 2022 estuvo a 112$, y en cambio el precio del gasóil estaba por debajo de 1.5€/L. En cambio, en la semana 12 de 2026 el precio del barril Brent estaba al mismo precio, y en cambio el precio del gasóil se sitúa en 1.84€/L., aún con IVA reducido. Pura especulación.

Año: 2022

Precio del barril Brent en dólares.
Precio de la Gasolina y el Gasóil en Euros/Litro.

Semana	Brent	Gasolina	Gasóil
8	118.11	1.58	1.46
9	112.67	1.59	1.48
11	120.65	1.68	1.58
14	111.70	1.82	1.84
18	111.55	1.82	1.85
19	112.55	1.84	1.87
20	119.43	1.88	1.91
21	119.72	1.90	1.89
22	122.01	1.94	1.87
23	113.12	1.97	1.85
24	113.12	2.05	1.92
25	111.63	2.12	2.00
29	110.01	2.07	2.02

Año 2026

Precio del barril Brent en dólares.
Precio de la Gasolina y el Gasóil en Euros/Litro.

Semana	Brent	Gasolina	Gasóil
11	112.19	1.60	1.65
12	112.57	1.71	1.84

Gráfica de evolución de los precios

Se aprecia como los precios en España siguen unos dientes de sierra más suaves, pues "tardan" mucho más en bajar que el precio del barril Brent.

Ejecución

Estos datos están disponible en el repositorio de la evolución de los precios del carburante en España.

La ejecución puede realizarse directamente con plot_results.py, pero a continuación se muestra la forma de invocación por módulo, anteponiendo python -m, al ser más versátil. Las opciones son -d, que muestra los datos por la salida estándar, y -g. que muestra el gráfico que genera pyploy.

$ python -m plot_results.py -d
Year: 2022
...

$ python -m plot_results.py -g

Si te gusta este contenido, puedes encontrar más en mi libro Introducción a la programación con Python. ¡Aprende mientras aplicas tus conocimientos en casos reales!

El tercer intento de API de fechas de Java

Baltasar García Perez-Schofield — Wed, 08 Apr 2026 09:35:03 +0000

Java es un lenguaje de pogramación con algunos años ya. El problema de los calendarios y las fechas es conocido: cada cuatro años se añade un día más, pero incluso en ciertos escenarios se añade un segundo a un año arbitrariamente. Como esto no se podía representar con la clase Date tal cual estaba planteada, decidieron desactualizar varios de sus métodos, de manera que fuera solo parcialmente funcional, y promocionaron el uso de Calendar en su lugar.

Calendar es una clase mucho más capaz, y solo se le pueden achacar problemas de edad, como el hecho de que no utilice enumerados (enum).

Fueron dos intentos ímprobos, y el segundo de muy buen resultado y ejecución, sobre una materia que ya de por sí es difícil. Por si fuera poco, la información mundial de time zones (zonas horarias), puede cambiar en cualquier momento, por lo que es una API que debe ser actualizada frecuentemente.

Así que los ingenieros de Java han creado LocalDate en el paquete java.time, el tercer intento de plantear una solución a la fecha y hora (spoiler: seguirá teniendo defectos, y se planteará una nueva alternativa).

El caso es que la nueva clase LocalDate proporciona el método getMonth(), que devuelve el mes que está representado en la fecha en sí. Este método devuelve un enumerado Month.

var fecha = LocalDate.now();
final var MESES = new String[]{ "Enero", "Febrero", "Marzo", "Abril", "Mayo", "Junio", "Julio", "Agosto", "Septiembre", "Octubre", "Noviembre", "Diciembre" };

System.out.println( "Fecha: " + fecha.toString() );
System.out.println( "Mes (val): " + MESES[ fecha.getMonth().getValue() ] );
System.out.println( "Mes (ord): " + MESES[ fecha.getMonth().ordinal() ] );

La salida de este código es:

Fecha: 2026-04-07
Mes (val): Mayo
Mes (ord): Abril

¿Hemos creado una fecha de marzo o de abril? A ver, el código se ejecutó el 7 de abril de 2026, fecha de escritura de este texto. Por lo tanto, la fecha (que, correctamente, se ofrece en formato ISO): 2026-04-07 se corresponde perfectamente. El problema viene cuando accedemos al mes con LocalDate.getMonth(). Se devuelve una de las constantes JANUARY, FEBRUARY, MARCH... Y aquí es cuando comienzan los problemas. Si accedemos al valor del enumerado Month, nos encontramos con que JANUARY es... 1. Porque sí, se nos ofrece el valor del enumerado a través de getValue().

Por eso, fecha.getMonth() devuelve 4, y entonces MESES[ fecha.getMonth().getValue() ] devuelve la 5ª posición en el vector, y así el código retorna, incorrectamente, Mayo. Nos han estropeado la forma acostumbrada de obtener el nombre del mes.

Al menos, no han tocado el valor del propio enumerado. Es decir, el valor Month.ordinal() sigue siendo el correcto: 3. Para obtener el mismo resultado mediante LocalDate.getValue(), tendremos que restar 1, de ahí que el código anterior deba ser corregido a:

System.out.println( "Mes (val): " + MESES[ fecha.getMonth().getValue() - 1 ] );
System.out.println( "Mes (ord): " + MESES[ fecha.getMonth().ordinal() ] );

A partir de ahora, será necesario escribir MESES[ fecha.getMonth().getValue() -1] si utilizamos getValue(), y continuar escribiendo el mismo código si utilizamos ordinal().

Y no es que getValue() esté mal. Veámos la siguiente tabla:

Método	Basado en	Ejemplo	Concepción
getValue()	1	Enero == 1	Intuitiva
ordinal()	0	Enero == 0	Costumbre

Y es que, efectivamente, la costumbre entre programadores es que los meses empiecen en 0, de manera que se pueda indexar directamente en un vector de meses, como en el ejemplo. Sin embargo, reconoceremos que lo normal, lo que sería intuitivo para un no programador sería que los meses empezasen en 1, es decir, que el índice de la posición de Enero fuese 1.

¿Y por qué me quejo? Pues porque a veces es mejor dejar las cosas como están. Cuando a tu alrededor todo funciona de una manera, cambiar a otra, aunque sea la más correcta, no necesariamente es la mejor idea. Especialmente cuando esa costumbre se ha extendido durante años.

Estamos hablando, en definitiva, de un estándar de facto (que los meses se indexen desde 0), frente a lo que podría ser un estándar por lo intuitivo (o un estándar concreto, el ISO 8601). Lo único cierto, es que desde C las colecciones comienzan a contar en 0, no en 1 (solo BASIC y Pascal (cuando se especifican los límites), lo permiten así).

En C, la forma de obtener el mes es dejando que el sistema rellene una estructura tm.

#include <stdio.h>
#include <time.h>

int main()
{
    time_t t = time( NULL );
    struct tm tm = *localtime(&t);

    printf( "now: %4d-%02d-%02d\n", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday );
}

La función localtime() es una llamada al kernel del sistema operativo.

Lenguaje	Método o función	Ejemplo	Basado en
C	localtime()	tm->tm_mon	0
Java	Calendar.get()	cal.get( Calendar.MONTH )	0
JavaScript	Date.getMonth()	new Date().getMonth()	0
Perl	localtime()	$d, $m, $y = localtime()	0
PHP	date(fmt)	$current_month = date('n');	1
Python	datetime.month	datetime.now().month	1
C#	DateTime.month	DateTime.now().Month	1
Nim	Month int	int(month(now()))	1
Gleam	month_int()	month_int(datetime.now())	1
V	Time.month	time.now().month	1
C3	datetime.month	datetime::now().month	1
Rust	chrono::Datelike	chrono::now().month	1
Go	Month()	time.Now().Month()	1
Zig	localtime()	tm->tm_mon	0

¿Qué puedo decir? Me quedo con que tengo razón, solo porque para eso es mi columna, la del viejo programador malhumorado.

Pero no se puede ignorar que, a medida que surgen lenguajes de programación más recientes (modernos), cada vez más se fijan en estándares como el RFC 3339, o el ISO 8601, y estos estándares identifican unívocamente enero con el índice 1, lo que no es sorprendente. Al fin y al cabo, que enero se identifique con 0 solo depende de una optimización del lenguaje de programación C, que se basa en que el nombre de un array en C es un puntero al primer elemento, es decir *v, *(v + 0) y v[ 0 ] son todas distintas formas de referirse a ese primer elemento.

En cualquier caso, que sea más intuitivo no hace que sepas de antemano con qué te vas a encontrar. Y es que, uses la librería que uses, no te quedará más remedio que comprobar si el número de mes se basa en 0 o en 1, y entonces, decidir si debes restar uno. O sumarlo. O no. Yo qué sé.

Street Smart Coding

Baltasar García Perez-Schofield — Wed, 01 Apr 2026 13:15:38 +0000

Hace ya algún tiempo que tengo Street Smart Coding, un libro de programación escrito en inglés, por César Aguirre, uno de los escritores más prolíficos aquí en dev.to, y me propuse escribir una revisión del mismo.

Cuando lees este libro, te das cuenta de un detalle importantísimo, y que para mi valida su contenido como para recomendarlo a cualquiera: está escrito desde la experiencia. Es decir, no te dice cómo hay que hacer las cosas, sino cómo aprendió personalmente cómo hay que hacer las cosas.

Pongamos un ejemplo. He escogido este porque no tiene que ver directamente con programación, sino con lo que hoy en día se denomina soft skills. A mi me gusta más el término acuñado ya hace unos años: peopleware.

That day, I learned it's never just five minutes. Next time someone says "just five minutes," remember it could turn into 3:00AM the next day. Say no.

Encontraremos este párrafo en el capítulo Learn to say no, junto con Saying yes to everything often means saying no to the people who matter most. You need healthy boundaries instead. Sometimes, all it takes is one single word: no. Efectivamente, aprender a decir no es muy importante, tan importante que si no lo haces, puede implicar decir no a tus más allegados: los límites son importantes. ¿Pero, cómo puedes explicarle a un desarrollador junior que es importante saber decir no? La única forma es hacerlo a través de una experiencia personal (experiencia que encontraremos en ese capítulo, junto a las conclusiones ya mencionadas), y ahí es donde está la fortaleza real de este libro.

Never, ever, ever tell anyone they're wrong.

Efectivamente, siempre hay una forma distinta de hablar con alguien, incluso convercerlo de algo, más productiva, en lugar de decirle: "no, eso está mal." Personalmente, esto lo aprendí en mi trabajo como profesor; pronto me di cuenta de que decirle a un alumno que algo que había dicho estaba mal era la mejor forma de conseguir que dejase de participar en clase. Quizás en una relación profesor-alumno podemos asumir que decir "no, eso está mal", debería ser una posibilidad real y por lo tanto constructiva, pero no lo es. Así, una pequeña modificación de esa frase tan simple podría ser: "eso es cierto, pero también hay que tener en cuenta..." Y es que, la confianza de tu interlocutor en ti termina cuando le dices que algo está mal. Es indiferente si tienes razón o no.

Vamos con algo de código, C# en este caso:

var movies = [ "The Matrix", "Inception", "Interstellar" ];

string result = movies[0];

for (int i = 1; i < movies.Count; i++) {
    result += "," + movies[i];
}

César nos explica que podemos sustituir el código de arriba por el siguiente:

var movies = [ "The Matrix", "Inception", "Interstellar" ];

string result = string.Join( ", ", movies );

¿La diferencia? Que hay código que no escribimos nosotros. Efectivamente, siempre que abordo un proyecto cualquiera, siempre tengo que descender por debajo del nivel de abstracción en el que yo deseo estar; es decir, siempre que me planteo escribir código como el de arriba, me pregunto. ¿Para algo tan básico y repetitivo, no hay ya una función/clase/biblioteca que lo haga?

Podemos encontrar este ejemplo en Know your standard library. ¿Por qué no escribir código es algo importante? Porque podemos apoyarnos en código ya escrito, de manera que nos evitemos una tarea menor y repetitiva, reutilizando código que alguien ya se ha molestado en desarrollar y probar para nosotros, lo que nos permite centrarnos en el código realmente importante. No reinventes la rueda, apóyate en código de calidad, en cambio.

¿Por qué nos comenta el autor esto? Pues porque él mismo se ha encontrado con código similar, independientemente del lenguaje de programación, en casi todos los trabajos en los que ha estado. Volvemos así al aspecto de la experiencia personal.

Estos son solo unos pocos ejemplos de lo que puedes encontrar en Street Smart Coding. ¿Te lo vas a perder?

Un nuevo C: el C++ ligero.

Baltasar García Perez-Schofield — Mon, 23 Mar 2026 12:09:51 +0000

Buscando el camino

Hay muchas críticas que se le pueden hacer a C++: que si permite comportamiento indefinido sin avisar (incluso lo aplica en el modo de optimización más agresivo), que si ha crecido hasta límites desmesurados, que si el precio a pagar es el de unos ejecutables monstruosos... Últimamente, la crítica se ha centrado en la seguridad del manejo de la memoria. Por ejemplo, la Casa Blanca ha pedido pasarse a lenguajes más seguros, como por ejemplo C# o Rust. La NSA ha emitido recomendaciones similares sobre abandonar C y C++. Incluso la Wikipedia tiene una página dedicada a las críticas a C++. Esta crítica a C++ no ha sentado nada bien a Bjarne Stroustrup, el creador original del lenguaje de programación C++.

En cualquier caso, todo esto lo que ha provocado es que hayan surgido nuevos lenguajes de programación para sustituir a C++, siendo los más conocidos C# y Java.

Pero esto no quiere decir que no existan muchos más, que han surgido buscando eliminar puntos de fricción de C++, simplificar la experiencia de programación, y aportar sus propias características. Notables menciones son Zig, V, o Rust.

En 2013, Bas vd Berg creó C2, una evolución del lenguaje de programación C con el objetivo de eliminar complejidad innecesaria. Por ejemplo, no presenta archivos de cabecera .h, no hay macros...

El lenguaje de programación C3 se basa en C2 para ofrecer un mismo objetivo, pero además con ciertas capacidades que lo acercan a C++. Y este es el objetivo de este artículo.

C3

El ¡Hola, mundo! en este lenguaje de programación es como sigue a continuación.

import std::io;

fn void main()
{
    io::println("¡Hola, mundo!");
}

Para compilarlo, aunque podríamos haber creado un proyecto completo, podemos simplemente hacer:

$ c3c compile holamundo.c3
$ ./holamundo
¡Hola, mundo!

Las diferencias sintáticas con C son muy pocas: las funciones van ahora precedidas de fn, de manera que se distingan facilmente de cualquier otra estructura. No hay archivos de cabecera, sino verdaderos módulos que son utilizados mediante import. El significado, la semántica del programa, es mucho más evidente que en C.

El siguiente es un programa que trata de generar ternas pitagóricas a partir de números aleatorios.

import std::io;
import std::time;
import std::core::string;
import std::collections::list;
import std::math::random;


struct Terna {
    ulong a;
    ulong b;
    ulong c;
}

fn bool Terna.chk(&self)
{
    ulong sqa = self.a * self.a;
    ulong sqb = self.b * self.b;
    ulong sqc = self.c * self.c;

    return ( sqc == ( sqa + sqb ) );
}

fn String Terna.str(&self)
{
    return string::tformat( "(%d, %d, %d)", self.a, self.b, self.c );
}

fn void main()
{
    random::Lcg128Random rand;
    List{ Terna } l;

    io::printn( "Ternas pitagóricas\nCalculando..." );

    l.push( { 3, 4, 5 } );

    ulong i;
    for(i = 0; i < 1_000_000_000; i++) {
        Terna t = { rand.next_long(), rand.next_long(), rand.next_long() };

        if ( t.chk() ) {
            l.push( t );
        }
    }

    io::printf( "%d ternas encontradas tras %d ciclos.\n", l.len(), i );

    foreach(Terna t: l) {
        io::printn( t.str() );
    }
}

El programa crea una estructura Terna, que consta de tres enteros long (128 bits) sin signo. La idea es que la suma de los cuadrados de a y b debe ser igual a c. Esta propiedad se verifica mediante el método Terna.chk(). El método Terna.str() devuelve los valores de la terna como texto.

Así que utilizamos Lcg128Random del módulo std::math::random para generar enteros de 128 bits. Con un bucle, probamos a generar números aleatorios, y si se crea una terna válida, se añade a una lista (esta lista puede crecer dinámicamente).

C3 se siente bastante directo, fácil de comprender (no existe una nueva sintaxis), con un compilador que genera ejecutables rápidamente, y que son muy rápidos ellos mismos.

$ c3c compile ternas_pitagoricas.c3
$ ./ternas_pitagoricas                                                  Ternas pitagóricas
Calculando...
1 ternas encontradas tras 1000000000 ciclos.
(3, 4, 5)

El ejecutable realiza mil millones (1 000 000 000) de ciclos en unos 17 segundos de manera consistente. Esto involucra crear una terna, llamar su método chk() (que consiste en un cálculo matemático), y añadirlo o no a una lista.

$ time ./ternas_pitagoricas
Ternas pitagóricas
Calculando...
1 ternas encontradas tras 1000000000 ciclos.
(3, 4, 5)
./ternas_pitagoricas  16,38s user 0,00s system 99% cpu 16,438 total

$ time ./ternas_pitagoricas
Ternas pitagóricas
Calculando...
1 ternas encontradas tras 1000000000 ciclos.
(3, 4, 5)
./ternas_pitagoricas  16,35s user 0,00s system 99% cpu 16,402 total

$ time ./ternas_pitagoricas
Ternas pitagóricas
Calculando...
1 ternas encontradas tras 1000000000 ciclos.
(3, 4, 5)
./ternas_pitagoricas  16,31s user 0,00s system 99% cpu 16,368 total

El ejecutable es de unos 700 k, como se muestra a continuación.

$ ls -l ternas_pitagoricas                                             
-rwxr-xr-x 1 baltasarq baltasarq 702640 mar 23 12:13 ternas_pitagoricas

¿Podemos compararlo con una versión C++? Pues claro.

#include <string>
#include <list>
#include <cstdio>


class Terna {
public:
    Terna(ulong a, ulong b, ulong c)
        :a(a), b(b), c(c)
    {}

    bool chk() const
    {
        ulong sqa = a * a;
        ulong sqb = b * b;
        ulong sqc = c * c;

        return ( sqc == ( sqa + sqb ) );
    }

    std::string str() const
    {
        return std::to_string( a )
                + ", " + std::to_string( b )
                + ", " + std::to_string( c );
    }
private:
    ulong a;
    ulong b;
    ulong c;
};


int main()
{
    std::list<Terna> l;

    printf( "Ternas pitagóricas\n" );

    ulong i = 0;
    l.push_back( Terna( 3, 4, 5 ) );

    for(; i < 1000000000ul; ++i) {
        Terna t( std::rand(), std::rand(), std::rand() );

        if ( t.chk() ) {
            l.push_back( t );
        }
    }

    printf( "%lu ternas encontradas tras %lu ciclos.\n", l.size(), i );

    for(Terna t: l) {
        printf( "%s\n", t.str().c_str() );
    }
}

La salida devuelve la solución tras mil millones de ciclos en unos 17 segundos de manera consistente.

$ g++ ternas_pitagoricas.cpp -o ternas_pitagoricas
$ time ./ternas_pitagoricas
Ternas pitagóricas
1 ternas encontradas tras 1000000000 ciclos.
3, 4, 5
./ternas_pitagoricas  17,20s user 0,00s system 99% cpu 17,270 total

Obtenemos un resultado similar. Esto no es extraño, pues aprovecha el backend de LLVM.

En este caso, C++ es capaz de generar el ejecutable más pequeño, aunque es cierto que no se emplea la estructura de entrada y salida oficial, IOStreams. También es importante notar que el ejecutable enlaza con la librería estándar de C++, que no es, precisamente, pequeña (unos 3 MB). C3 genera, por otra parte, un ejecutable que es autocontenido.

$ g++ ternas_pitagoricas.cpp -o ternas_pitagoricas    
$ ls -l ternas_pitagoricas
-rwxr-xr-x 1 baltasarq baltasarq 44320 mar 23 12:54 ternas_pitagoricas
$ ldd ternas_pitagoricas                                                
        linux-vdso.so.1 (0x00007faefdf04000)
        libstdc++.so.6 => /usr/lib/libstdc++.so.6 (0x00007faefdc00000)
        libm.so.6 => /usr/lib/libm.so.6 (0x00007faefdae2000)
        libgcc_s.so.1 => /usr/lib/libgcc_s.so.1 (0x00007faefdab5000)
        libc.so.6 => /usr/lib/libc.so.6 (0x00007faefd8c4000)
        /lib64/ld-linux-x86-64.so.2 => /usr/lib64/ld-linux-x86-64.so.2 (0x00007faefdf06000)

$ c3c compile ternas_pitagoricas.c3                                    
Program linked to executable './ternas_pitagoricas'.
$ ldd ternas_pitagoricas
        linux-vdso.so.1 (0x00007fad32973000)
        libm.so.6 => /usr/lib/libm.so.6 (0x00007fad32796000)
        libc.so.6 => /usr/lib/libc.so.6 (0x00007fad325a5000)
        /lib64/ld-linux-x86-64.so.2 => /usr/lib64/ld-linux-x86-64.so.2 (0x00007fad32975000)

¿El sucesor oficial, o al menos un lenguaje estable? Es difícil decirlo, solo el tiempo lo dirá.