DEV Community: Baltasar García Perez-Schofield

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á.

Hackeando en 8 bits (y IV)

Baltasar García Perez-Schofield — Mon, 16 Mar 2026 17:43:35 +0000

Y vamos a terminar ahora con la serie dedicada a hackear juegos en el Speccy, lo que se conocía en la época como desprotegerlos. Vamos a buscar vidas infinitas em Abu Simbel Profanation e Ikari Warriors. Y como herramienta, utilizaremos em emulador de Spectrum Zesarux.

En la última entrega de esta serie, vimos a grandes rasgos cómo crear uno de aquellos cargadores que proporcionaban vidas infinitas o bombas infinitas, o cualquier otro cheat, metiendo POKEs justo antes de la ejecución del programa.

Pero en esta entrega vamos a centrarnos en otro tipo de hack: simularemos que tenemos un Multiface. Este aparato permite, conectado a la parte trasera del Speccy, pulsar un botón rojo que genera una NMI (Non Maskable Interruption o interrupción no enmascarable). Al pulsar el botón, al Speccy no le queda más remedio, esté haciendo lo que esté haciendo, que ejecutar el código del vector de interrupción dado, lo que ejecuta su software mientras el software está en memoria. Lo que se podía hacer entonces era guardar el contenido de la memoria (con lo que podías guardar el juego tal cual se estaba ejecutando en ese momento), introducir POKEs, o explorar la memoria.

Vamos a simular, como decía, la forma de utilizar un periférico como Multiface, pero con la comodidad de un emulador de hoy en día. Todo lo que vamos a hacer aquí se puede hacer con dicho aparato enchufado y siguiendo sus instrucciones, pero lógicamente es mucho más tedioso.

Abu Simbel Profanation

Este juego fue creado por Víctor Ruiz para su sello familiar (compartido con sus heramanos), Dinamic. Según las entrevistas que se le han hecho con el tiempo, fue creado en una especie de versión más limitada de BASIC, que era posible compilar a código máquina.

Al arrancar Zesarux, seleccionamos la cinta a cargar en el menú Z >> smart load, que en este caso será el .TAP o .TZX descargado desde la web de World of Spectrum. Este emulador es muy particular, y cargará la cinta él solo, como si hubiéramos tecleado la secuencia de comandos.

Cuando el juego se ejecute, seleccionamos la opción 3. keyboard (o 2. kempston si tenemos un controlador conectado), y el juego nos sitúa dentro de la pirámide con cierta (infame) gota cayendo desde el techo.

En la parte superior del escritorio de Zesarux, a la derecha de la pantalla del Speccy, veremos un icono de una cucaracha: se trata de las opciones que nos permitirán depurar un programa. Vamos a utilizarlo para encontrar pokes. Nos metemos en la opción Debug >> Find >> Find bytes.

#	Menú	Submenú	Submenú	Submenú
1	Debug	Find	Find bytes	Find bytes (initial)
2				Find bytes (next)
3				View results
4				Clear results

En la tabla anterior vemos las posibilidades del menú. Aunque hay opciones automatizadas para buscar POKEs, lo haremos de forma genérica para permitir buscar cheats sobre municiones, granadas, etc.

Comenzamos. La primera vez seleccionamos (1), Find bytes (initial). Ahora que estamos en el juego podemos buscar el valor 10, que introducimos, pues es el número inicial de vidas. Nos dará varios cientos de resultados, como es de esperar, pero lo importante es que Zesarux va a recordar los resultados. Así, la siguiente vez que entremos en el menú, nos encontraremos con (2) Find bytes (next), en lugar de la opción (1). ¡Pero espera! Aún es pronto.

Mueve a Johnny Jones con las teclas O (izquierda), P (derecha), y Q (salto) hasta... sí, la gota. Ponle debajo y pierde una vida. Confía en mi, merecerá la pena... Es verdad, ahora solo tienes 9 vidas, pero verás lo que pasa.

Volvemos al menú de Find y (2) Find bytes (next), y esta vez introducimos 9. ¡Solo hay una coincidencia! Pulsamos ESC y volvemos al mismo submenú para seleccionar (3) View results. La dirección de memoria con valor 9 es 38818. ¡Ya sabemos en qué posición de memoria guarda el juego las vidas!

Nos vamos de nuevo al menú Debug, y esta vez seleccionamos la opción POKE. Seleccionamos la primera opción, POKE.... Nos pregunta la dirección, introducimos 38818. A continuación, nos pregunta con qué valor queremos modificar la dirección 38818. En cada posición de memoria, solo podemos escribir un valor entre 0 y 255. Sabemos que va a ser el número de vidas disponible, así que... ¡qué caray! ¡Introduzcamos 255! ¡Mejor que zozobre que no que zofalte!

A continuación, nos pregunta cuántos bytes queremos modificar. Lo más normal es, como en esta ocasión, que sea solo uno. Pero es posible que, para valores por encima de 255, un juego utilice dos (el mínimo), o más bytes. En este caso, simplemente introducimos 1.

Tras pulsar ENTER, puede que pensemos que algo ha ido mal. Que no ha cambiado nada. Pero... llevemos a Johnny hasta la gota, para morir de nuevo. Solo una vez más. Si lo hacemos... ¡habrán aparecido 254 vidas restantes! Tiene sentido que el juego solo actualice el marcador de vidas del jugador cuando este número cambia... es decir, cambia según las reglas normales del juego.

Un detalle curioso es que no aparece solo "254", sino "0254". Está claro que Víctor Ruiz quería que los marcadores estuvieran "equilibrados", ya que hay más de 10 pantallas, y en la primera se muestra como "01", no como "1". Está claro que el número de vidas es tan exagerademente alto, que el algoritmo para mostrar vidas se desborda. Literalmente.

Un detalle... creo que es en la segunda o en la tercera pantalla que es posible caer en un pozo vertical que termina en unas mortíferas agujas... Es importante que no caigas ahí, o... tendrás que esperar a morir doscientas y pico veces (o, mejor, hacer un POKE de 38818 con 1).

Si queremos buscar algún otro valor en memoria, tendremos que seleccionar (4) Clear results, para poder volver a empezar, seleccionando de nuevo la opción (1) Find bytes (initial).

Ikari Warriors

El siguiente juego que desprotegeremos es Ikari Warriors. Descárgate el .TAP o el .TZX, y cárgalo en Zesarux, de nuevo mediante la opción de menú Z >> Smart load. El juego pide seleccionar el controlador del primer jugador, y después del segundo jugador. En mi caso, redefeniré las teclas (opción 1), del juego para el Jugador 1, y cualquier otra cosa pra el Jugador 2, pues no pienso usarlo. Finalmente, seleccionamos (1) (Start one player game) para comenzar el juego.

Las vidas están representadas mediante cabezas del héroe, son 6 en total. Así que seleccionamos (1) Find bytes (initial), e introducimos 6 (o las vidas que nos queden en ese momento, el juego no se anda con chiquitas). Nos dirá que hay más de seiscientos resultados. Seguramente ya nos habrán matado una o dos veces, seleccionamos (2) Find bytes (next) e introducimos el número de vidas que nos quede. Ahora ya solo aparecerá un resultado. Con (3) View results, comprobaremos que la dirección de memoria de las vidas es 58478. Ahora seleccionamos Debug >> Poke >> Poke.... Introducimos la dirección de memoria, 58478. A continuación, nos pide un valor, sabemos que como máximo puede estar entre 0 y 255. Pero... ¡cuidado! Recuerda que las vidas se representan con figuras en la pantalla. Si introducimos un valor demasiado alto, las figuras se extenderán corrompiendo la pantalla, e impidiendo que nuestro héroe se mueva por ella. Un valor seguro es 40, ya que son las 10 filas por cuatro figuras que se pueden representar en pantalla sin sobrepasar el espacio destinado para ellas. El juego, como decía, no se anda con chiquitas, así que tendrás que introducir el POKE a 58478 con 40 varias veces. En cambio, es bastante improbable que te quedes sin granadas, pudiendo llegar a acumular varias docenas. Así que, personalmente, no creo que merezca la pena buscar el POKE correspondiente. Aún así, lo hice por experimentar, pero... no salió nada, ni con las granadas ni con los disparos. Probablemente, algún tema de ofuscación, curioso.

En cualquier caso, ya sabes cómo encontrar vidas en un juego. ¡Enhorabuena, eres un hacker!

¿Qué?
¿Cómo?
¿Qué con estas técnicas y ciertos programas buscadores de cheats, también se pueden buscar vidas infinitas en lo juegos de ahora? No tengo ni idea de lo que me estás hablando...

Hackeando en 8 bits (y III)

Baltasar García Perez-Schofield — Fri, 13 Mar 2026 12:18:41 +0000

Como hemos visto en las dos entregas anteriores, todo se reduce a un concepto: cambiar la memoria. Si lo hacemos cuidadosamente, podemos colocar, o bien nuestras propias instrucciones, cambiando el comportamiento del programa, o bien nuestros propios datos, de manera que podamos cambiar el número de vidas, el número de balas, el número de bombas... etc.

En esta entrega vamos a ver un ejemplo real, centrándonos en Stop the express. Vamos a seguir el proceso de creación de un cargador que nos proporcione vidas y tiempo infinito. Lo que hoy en día se conoce como cheats.

Encontrar las posiciones de memoria adecuadas y saber modificarlas, implica tener conocimientos de ensamblador y código máquina del Z80, el microprocesador dentro del ZX Spectrum. En este pequeño artículo lo haremos paso a paso, sin asumir conocimientos previos.

Comencemos el proceso de crear un cargador con Stop the Express. Tras encender el Spectrum, y colocar la cinta en el reproductor de cassette, tecleamos merge "" y pulsamos PLAY. Bueno, esto es la idea, a partir de ahora vamos a manejarnos con un emulador de Spectrum, llamado FBZX. Precisamente, nos permitirá emular insertar una cinta, ponerla en marcha, etc.

Así, pulsamos F3 y 1 para indicar que queremos cargar una cinta, el .tap o .tzx de Stop the Express que nos hayamos descargado de World of Spectrum. Teclamos merge"" como se ve en la imagen anterior. Es importante que nos fijemos en que hemos desactivado la carga rápida y la carga turbo.

Ahora, de vuelta en la pantalla de Spectrum, pulsamos ENTER para cargar la cinta, y pulsamos F6 para ponerla en marcha (virtualmente). Una vez que aparece Ok 0:1, pulsamos F5 para parar la cinta. Volvemos a pulsar ENTER para ver el código en pantalla.

Introducimos 20 y ENTER y en la línea 50 eliminamos los colores, de manera que solo nos quede la línea 20, que es la que carga la pantalla de presentación (load "" screen$), el código máquina del juego (load "" code), y la ejecución del mismo randomize usr 48096. Este último lo vamos a modificar poniendo REM delante, lo que lo transforma en un comentario.

50 load "StopExpr2" screen$: load "StopExpr3" code: rem randomize usr 48096

Esta última instrucción es interesante. Ahora le hemos puesto rem delante, con lo que la hemos transformado en un comentario y no se va a ejecutar. La pregunta ahora es: ¿cómo es que esta instrucción ejecuta el juego? La parte importante es USR 48096. Lo que sucede es que es una función, no una instrucción. Necesita una instrucción a la cual va a ser pasada por parámetro. ¿Cuál instrucción exactamente? Realmente no importa demasiado, solo la necesitamos para que evalúe sus argumentos. Concretamente, se usa RANDOMIZE, que inicializa la semilla aleatoria que alimenta a la función RND, que devuelve un valor aleatorio entre 0 y 1. Así, una vez que RANDOMIZE evalúe su parámetro, podrá inicializar la semilla aleatoria. Lo que pasa es que nunca se producirá un retorno de la función que llama al código máquina del juego, claro...

La documentación del ZX Spectrum nos dice que cuando ejecutamos un load "" code, en realidad estamos haciendo un load "" code 32768. Estamos cargando el código del juego a partir de la dirección de memoria 32768. Si tenemos en cuenta que el código tiene un tamaño de 15394 bytes, entonces sabemos que ocupará desde la dirección en memoria 32768 hasta la dirección 48162, inclusive. El resto de la memoria, desde la dirección en memoria 48163 hasta 64k (65536), queda libre.

Tener parte de la memoria libre es importante porque necesitamos espacio para poder cargar un desensamblador, sin "pisar" el programa, es decir, sin utilizar la memoria que está siendo ocupada por el programa. El desensamblador nos va a decir las instrucciones que están en memoria, sin necesidad de que interpretemos los números en ella directamente.

Hasta ahora hemos utilizado emulador el mejor Spectrum posible, el creado por Investrónica en 1986, con características mejoradas como el chip de sonido de tres canales, o la memoria de 128k. Se trata del Sinclair Spectrum + 128k. Pero Stop the express necesita un modelo de 48k, el modelo anterior, así que por si acaso, pasaremos a ese modo con la instrucción SPECTRUM. Si ahora pulsamos la tecla K, veremos que aparece la instrucción LIST en pantalla. Pulsamos ENTER y veremos de nuevo el listado.

Esta forma de manejarse con el teclado es típica del ZX Spectrum original, el de 48k. Se concibió como una manera de ahorrar memoria, y también de ayudar a los usuarios a teclear programas en BASIC. Hay muchos detractores de esta forma de operación, así como fervientes seguidores de la misma.

Ahora pulsamos R (aparece RUNen pantalla) y pulsamos ENTER. Pulsamos F6 para volver a poner la cinta en marcha. El programa cargará la pantalla de presentación, y después el bloque de código máquina del juego en sí.

Cuando termine, veremos en la parte inferior de la pantalla Ok 50:2. Aparentemente, no ha pasado nada, pero tenemos el juego en memoria. Si pulsamos V (aparece CLS), y ENTER, y K (aparece LIST), y ENTER, veremos que seguimos teniendo el cargador en memoria.

Ahora es necesario cargar el desensamblador que mencionamos. Vamos a utilizar HiSoft MONS. El primer archivo, HiSoftDevpacV3M2Mons.tap.zip ya nos vale. Lo descomprimimos, por ejemplo en el mismo directorio de descargas, con lo que nos quedamos con MONS321.tap. Esta cinta, es decir, este archivo .tap, solo tiene un programa, que es el propio desensamblador, que cargaremos con load "" code 52000. Volvemos a FBZX, pulsamos F3 y 1 para seleccionar MONS321.tap, y ESC para volver a la emulación. Pulsamos J (aparece LOAD), pulsamos Ctrl + P dos veces para obtener dos dobles comillas, y a continuación pulsamos Ctrl + Shift, y soltamos (el cursor cambia para mostrar una E parpadeante), y entonces pulsamos la tecla I (aparece CODE en pantalla). Finalmente, tecleamos 52000, para obtener load "" code 52000. Pulsamos ENTER para pasar al modo de carga, y F6 para comenzar la reproducción de la cinta. En pantalla aparecerá BYTES: MONS3M2, y realizará la carga correspondiente, hasta mostrar Ok 0:1.

El proceso de carga del juego para su desensamblado, en realidad suele hacerse desde el mismo MONS, pero para no entrar en excesivas tecnicidades, y explorar también al propio Spectrum 48k, al final he decidido hacerlo así.

Para ejecutar el desenamblador, tecleamos T(aparece RANDOMIZE), Ctrl + Shift (el cursor cambia a una E parpadeante), y L (aparece USR). Tecleamos a continuación 52000, para obtener RANDOMIZE USR 52000. Pulsamos ENTER.

Veremos brevemente un mensaje de bienvenida de MONS3, y después una pantalla con el contenido de los registros del Z80, el contenido de una zona de la memoria en hexadecimal, y un cursor parpadeante en la zona inferior de la pantalla.

Como yo no soy un experto en ensamblador del Z80, me dirijo a los pokes disponibles, que son los siguientes para vidas infinitas y tiempo infinito. A continuación aparecen las direcciones en memoria a cambiar, el valor en hexadecimal del nuevo valor a poner en memoria, y su opcode correspondiente en el Z80.

Dirección en memoria	Valor	Significado	Hex	Opcode
34464	183	Vidas infinitas	B7	OR A, A
34926	183	Vidas infinitas	B7	OR A, A
35257	183	Vidas infinitas	B7	OR A, A
35780	0	Tiempo infinito	0	NOP
39549	0	Tiempo infinito	0	NOP

En Mons3, si pulsamos la combinación de teclas Shift + 1, volvemos a BASIC. Para volver a entrar en Mons3, necesitaremos volver a teclear randomize usr 52000, es decir, T, Ctrl+ Shift, L, 52000 y ENTER.

Con Ctrl+ 3, desensamblamos el programa empezando en la dirección de memoria por defecto, que al principio es 0, es decir, estaríamos desensamblando la ROM del Speccy, la que contiene el intérprete de BASIC, etc.

Con H, y un número decimal, obtenemos su valor hexadecimal equivalente. Por ejemplo, H y 52000 nos devuelve CB20, que es la posición en memoria de Mons3. Si convertimos 34464, la dirección del primer POKE, nos devuelve 86A0.

Con 'M', y un valor en memoria hexadecimal, nos pasamos a esa dirección en memoria. En lugar de utilizar directamente 86A0, utilizaremos 869B, así, con M', 869B yCtrl`+ 3, obtendremos un listado como el siguiente:

plaintext 869V 1102A7 LD DE, #A702 869E 96 SUB (HL) 869F 5F LD E, A 86A0 9D SBC A, L ; este es el valor a cambiar 86A1 93 SUB E 86A2 AA XOR D 96A3 ...

En la primera columna aparece la dirección en memoria en hexadecimal. A continuación, los valores en hexadecimal para la instrucción. Hay que tener en cuenta que hay instrucciones que ocupan varios bytes. Por ejemplo, la primera en 869V es 1102A7. El valor 11 es el de la instrucción LD, concretamente LD DE, cargar en el registro DE el valor A702, que como vemos aparece como 02A7, ya que el Z80 codifica los valores como LSB (Least Significan Byte), es decir, coloca primero el byte menos significativo de un valor en 16 bits. El registro DE es el formado por el par de registros de 8 bits D y E, para conformar un registro de 16 bits. En cambio, en la dirección 86A0 tenemos 9D, una instrucción que ocupa un solo byte y que significa que se debe restar el contenido del registro L + el bit de acarreo, del contenido del registro A. El resultado se guarda en A.

Si en esta posición ponemos en cambio el byte B7, entonces estaremos haciendo un OR del valor del registro A con el valor del registro A. La operación OR comprueba un valor en binario con otro, y pone a 1 aquellos pares de valores que contengan 0 y 1, o 1 y 1. Por ejemplo, si tomamos un valor en binario como 0110, que es 6 en binario, con 1100, que es 12, obtendremos 1110, que es 14. Sí, ¡se puede utilizar para sumar! ¿Pero, qué pasa si hacemos un OR de un valor consigo mismo? Pues nada. El valor se queda como estaba. Y eso es lo que quiere conseguir el POKE: eliminar la resta para que no se reste una vida. Pero, a la vez, deja el registro A y el acarreo como tiene que estar para poder continuar la ejecución sin que esta se vea afectada.

De acuerdo. La dirección en memoria 36780 (8FAC), contiene una instrucción que debemos poner a 0 para que el tiempo sea infinito. El opcode 0 es NOP, es decir, no hacer nada. Si nos fijamos, en esa posición hay otro SBC, otra resta teniendo en cuenta el acarreo. Si la ponemos a 0, simplemente no se hace. En este caso, no es necesario dejar el registro A y el acarreo de ninguna manera especial para que la ejecución continúe correctamente.

Y bueno, este es el proceso que seguiría un hacker de 8 bits para encontrar los POKEs del juego. Buscaríamos por ejemplo el valor 3, descartando todos los valores hasta encontrar el número de vidas inicial en una dirección de memoria concreta. Después buscar restas de esa posición en memoria, buscando por el opcode SUB o SBC hasta encontrar la instrucción que resta la vida, y encontrar el valor adecuado que consigue que se haga la resta mientras a la vez consigue que continúe la ejecución sin errores. Y cada error, supone cargar el Mons3 desde cinta, y a continuación el juego desde cinta. Tiene mérito, ¿eh?

Y ahora es necesario crear el cargador del juego. Es decir, la parte BASIC que carga el juego. Nos habíamos quedado con esto:

bbcbasic 20 load "StopExpr2" screen$: load "StopExpr3" code: rem randomize usr 48096

Vamos a pasarlo a lo siguiente. Tenemos que cambiar los valores después de cargar el juego, y antes de ejecutarlo. Podemos hacerlo como aparece a continuación, creando el archivo cargador.bas:

bbcbasic 10 load "StopExpr2" screen$ 20 load "StopExpr3" code 30 cls:print "Stop the Express cracked" 40 input "Vidas infinitas (s/n):";v$ 50 if v$(1)<>"n" then poke 34464, 183:poke 34926, 183:poke 35257,183 60 input "Tiempo infinito (s/n):";t$ 70 if t$(1)<>"n" then poke 35780, 0: poke 39549, 0 100 randomize usr 48096

Nos podemos descargar BasinC, y ejecutarlo (en linux, necesitaremos Wine). Cargamos el archivo cargador.bas en BasinC, y seleccionamos File >> Export as tap, guardándolo como cargador.tap.

Ya solo queda volver FBZX, y pulsar F3 para seleccionar una cinta, escoger cargador.tap, pulsar ESC e introducir SPECTRUM, y después pulsar J, Ctrl + P dos veces y ENTER para ejecutar load "", pulsando entonces F6. Al terminar la carga, pulsamos R y ENTER para ejecutar el programa. Seleccionamos la cinta del juego original con F3 y 1, y al pulsar ESC y F6, el juego se cargará saltándose el BASIC original, y preguntándonos si queremos vidas y tiempo infinito. Al terminar las preguntas, el juego se ejecutará modificado.

Enhorabuena, ¡eres un hacker!