DEV Community: David Dominguez

The experiment: Reviving 90s Paratrooper without writing a single line of code

David Dominguez — Mon, 11 May 2026 03:19:38 +0000

A few days ago, I wanted to play the mythical DOS game Paratrooper – the one where you control an anti-aircraft gun and shoot down enemy paratroopers. But I didn't want to download an emulator or code it myself. I wanted to see if two different AIs could do it for me, each with a distinct role.

The result was functional, yes, but very basic. No advanced physics, no sound, no helicopters. But the cannon shoots, enemies fall, lives decrease, and you can lose. Just enough to feel nostalgic for five minutes.

How did I do it? Let me walk you through the process, the tools, and the lessons learned.

The two AIs and their roles

AI	Role	What it did
DeepSeek (me, the assistant)	Architect / Planner	Designed the project structure (TS, CSS, HTML files), wrote the detailed prompts that would later be sent to the other AI.
Nemotron 3 Super Free	Coder	Received DeepSeek's prompts and generated the actual game source code (TypeScript, CSS, HTML).

Important: I did not use OpenCode with the Nemotron model. I simply copied the prompts that DeepSeek gave me and pasted them into the Nemotron 3 Super Free interface (a free model that claims to understand legacy code and retro languages, available on several AI platforms).

Step 1: DeepSeek plans the structure

I asked DeepSeek to help me create a Paratrooper game in TypeScript, with CSS and HTML, but with one condition: the code had to be generated by another AI. So DeepSeek didn't write the game – instead, it generated a series of ready-to-copy-paste prompts.

These prompts included:

A tsconfig.json to compile TypeScript.
An index.html with canvas, life counter, and restart button.
A styles.css with a retro look.
A full game.ts with the game logic: mouse-controlled cannon, click-to-shoot, falling paratroopers, collisions, lives, game over, and restart.

DeepSeek also warned me that the result would probably be very basic if I didn't iterate much. It was right.

Step 2: Nemotron 3 Super Free writes the code

I copied the longest prompt (the one for game.ts) and pasted it into Nemotron 3 Super Free. In less than a minute, the AI returned complete code. Then I did the same for the other prompts.

When I opened index.html in my browser… it worked on the first try! The cannon moved with the mouse, paratroopers fell from the top, shots eliminated them, and lives decreased when they hit the ground.

But I also noticed clear limitations:

Imprecise collisions – Sometimes a bullet passed near an enemy and still killed it.
No fire rate limit – I could shoot like a machine gun.
No animations – Paratroopers were just brown rectangles with a white square on top (the parachute). No sprites.
No helicopters – Just basic paratroopers.
Restart sometimes left "ghost bullets" in the array.

In short: it delivers the core mechanics, but without any refinement. It's a functional prototype, not a polished game.

Can you improve it with more prompts?

Absolutely. I asked DeepSeek to generate correction prompts: limit shots, adjust collisions, clean the array on restart. I copied those new prompts to Nemotron, and after two or three iterations the game improved noticeably.

But even after several rounds, the result was still "very basic" compared to the original DOS Paratrooper. The reason? Nemotron 3 Super Free seems optimized for simple, straightforward code, not complex simulations or games with delicate state.

What I promised vs. what I got

Feature	Final state
Cannon follows mouse	✅ Yes
Click to shoot	✅ Yes
Paratroopers fall	✅ Yes
Bullet-enemy collisions	✅ Yes, but somewhat imprecise
Lives (3) and game over	✅ Yes
Restart button	✅ Yes, though sometimes buggy
Fire rate limit	❌ Not initially, yes after correction
Sound	❌ No
Explosions	❌ No
Helicopters	❌ No
High scores	❌ No

In one word: basic.

Lessons learned (if you want to try this yourself)

AIs don't replace human judgment – Without my corrections (the extra prompts from DeepSeek), the game would have been almost unplayable.
Nemotron 3 Super Free is great for rapid prototypes, but don't expect a commercial game.
DeepSeek (or any conversational assistant) is ideal for designing architecture and prompts, because it understands the overall project context.
Iteration is key – With each correction prompt, the game gets a little better. Three or four iterations already give a decent result.
"Very basic" isn't bad – Sometimes we just want to revive a memory, not create the next indie hit. And for that, these tools are perfect.

Final reflection: was it worth it?

Absolutely. In less than an hour, without writing a single line of manual code, I had a playable game in the browser. My 10-year-old nephew tried it and had fun shooting at the paratroopers. Sure, after five minutes he said "it's too easy" and went back to Roblox. But for me, seeing that cannon move clumsily on screen was like traveling back to 1992.

If you also want to revive a DOS classic without the hassle, I recommend this method: use one AI to plan (DeepSeek, ChatGPT, Claude) and another to code (Nemotron, Copilot, Codeium). The result will be basic, but functional. And the fun is in the process.

Bonus: the (very basic) final code generated by Nemotron

In case you want to try it or improve it, here's the link to my repository:

➡️ https://github.com/davdomin/paratrooper

It's not pretty, but it works.

Have you tried building games with two different AIs? Share your experience in the comments! 🕹️

AI Coliseum: Building a Python Chess Engine for LLM Benchmarking

David Dominguez — Sun, 03 May 2026 00:44:40 +0000

What happens when you pit two different programming logics against each other in an environment of strict rules? To answer this, I developed a Python project that functions as an execution environment (Engine) where different AI scripts can compete.

In this post, I’ll explain how I designed the board, the rules, and the experiment of facing white.py against black.py.

1. The Referee: A Pure Rules Engine

Unlike other projects, here the "engine" is not the player. Its sole mission is to be the board's operating system. It is programmed to:

Validate Legal Moves: Ensuring no AI attempts to bypass the rules.
Manage State: Controlling castling, en passant captures, and promotions.
Detect Game End: Applying rules for insufficient material, threefold repetition, and the 50-move rule.

2. The Experiment: `white.py` vs. `black.py`

The real magic happens in external files. The engine acts as a "Coliseum" that delivers the current board state to each script and waits for a response.

This allows for AI Benchmarking experiments:

Search Logic: Who calculates better: a Minimax-based script or one based on experimental heuristics?
Optimization: How response time (time.time()) affects the quality of the move returned.
Evaluation Heuristics: Comparing how different algorithms value piece positioning.

3. Anatomy of the Engine (The Backbone)

The code is designed to be modular and transparent. Key implementation points include:

Board Cloning: The engine allows AIs to clone the state to simulate future moves without affecting the live game.
PGN Builder: Automatic generation of standard notation so games can be analyzed in external viewers.
Console Visualization: An ASCII rendering system to follow the "fight" in real-time from the terminal.

4. Why Separate the Board from the Logic?

Separating the engine from the players (white.py and black.py) offers critical software development advantages:

Modularity: You can change an AI's logic without touching a single line of chess rule code.
Impartiality: Both scripts receive the exact same state information (get_state()).
Scalability: It's easy to add new "players" and face them in a Round Robin tournament.

The Experiment: A Chronicle of Algorithmic Slaughter

Developing this Coliseum wasn't linear; it was an evolution of "survival of the fittest." In early tests, GPT—using an optimized initial prompt—completely swept basic versions of Gemini and clearly outperformed DeepSeek. The throne seemed set.

However, the landscape shifted when Claude entered the scene. With much deeper calculation logic and superior decision-tree management, Claude dethroned GPT and mercilessly "destroyed" the other competitors.

The most interesting part followed: by applying the optimization principles and code structure used by Claude to the other AIs, the field leveled. While still playing with less precision, these improved versions began forcing draws by repetition. They evolved from tactical suicides to a defense solid enough to hold the line.

From Code to Board: Generating PGN

To ensure these games don't just live as terminal logs, the software implements a PGN Builder. PGN (Portable Game Notation) is the universal standard for recording chess games.

How the Data Flows:

Move Capture: Every time white.py or black.py makes a move, the engine logs the origin, destination, captures, and promotions.
Algebraic Translation: The engine converts internal array coordinates (e.g., [7, 4]) into standard notation (e.g., e1).
Special State Detection: The software checks if the move resulted in check (+), checkmate (#), or castling (O-O).
Export: At the end of the game, these strings are concatenated: 1. e4 e5 2. Nf3 Nc6....

Visualizing on Chess.com or Lichess

The final result is a block of text you can paste into tools like the Chess.com Analysis board. These platforms read the PGN, reconstruct the game visually, and let you use engines like Stockfish to see exactly where Claude gained the upper hand.

Open Source Challenge

I have uploaded this competition environment to my repository. If you are a developer and want to test your own chess logic, just create your script and pit it against the board.

Project Repository: https://github.com/davdomin/chess_motor

What strategy would you use to win: an aggressive material-based attack or a solid positional defense? Let me know in the comments!

Keep Code Left: The Art of Readable Logic

David Dominguez — Fri, 01 May 2026 22:08:18 +0000

In 2015, while working at Software Andina, I had the privilege of attending a session that changed the way I look at a source file. At the time, we were frequently visited by developers from the United States who shared their expertise to help us sharpen our craft.

One of those visitors was Mick Andrew, a seasoned developer and Director of Development at Sage. He was a close friend of my boss at the time, John Rutherfurd, and he brought with him a presentation titled "Keep Code Left" (KCL).

The title was deceptively simple, but the philosophy behind it was profound. As developers, we often focus on making code work, but we frequently forget that code is read far more often than it is written. Mick taught us that by following a few "cookbook" rules, we could transform convoluted, deeply nested logic into something clean, linear, and remarkably easy to maintain.

What is Keep Code Left?

At its core, Keep Code Left is a coding style designed to maximize readability. The name refers to the visual structure of the code: the more your logic is indented (pushed to the right), the harder it becomes for a human brain to track the "state" and the flow of the program.

The goals of KCL are straightforward:

** Simplify Logic**: Create code that flows linearly rather than branching out.

** Enhance Readability**: Allow developers to "see the flow" and grasp the goal of a method at a glance.

** Reduce Maintenance Bugs**: Simple code is harder to break during future updates.

** Streamline Reviews**: It provides a standard that can be verified during code reviews without needing deep domain knowledge.

Since that day in 2015, I have applied these rules to nearly every project I’ve touched. In this post, I’ll break down exactly how to "Keep Code Left" and why your future self (and your team) will thank you for it.

Why “Keep Code Left” Matters
When code becomes deeply nested, several problems appear:

Harder to read line-by-line
Logic becomes difficult to follow
Increased risk of bugs
Slower code reviews

KCL aims to:

Simplify logic
Reduce indentation
Make flow visible at a glance
Enable faster and more reliable reviews

The Core Principle

Avoid unnecessary nesting. Prefer early exits and linear flow.

Instead of wrapping logic inside multiple if blocks, you handle edge cases early and return immediately.

Example 1: Nested Code (Bad)

public void ProcessOrder(Order order)
{
    if (order != null)
    {
        if (order.IsValid())
        {
            if (order.Items.Count > 0)
            {
                // Process order
                Save(order);
            }
        }
    }
}

Problems:

3 levels of nesting
Hard to scan quickly
Main logic is buried

Example 1: Keep Code Left (Better)

public void ProcessOrder(Order order)
{
    if (order == null) return;
    if (!order.IsValid()) return;
    if (order.Items.Count == 0) return;

    // Process order
    Save(order);
}

Benefits:

Flat structure
Easy to read top-to-bottom
Main logic is immediately visible

Example 2: Conditional Complexity
Bad Approach

if (user) {
    if (user.isActive) {
        if (!user.isBlocked) {
            sendEmail(user);
        }
    }
}

KCL Approach

if (!user) return;
if (!user.isActive) return;
if (user.isBlocked) return;

sendEmail(user);

**Key Techniques of Keep Code Left

Early Returns ** Handle invalid cases first:

def process(data):
    if data is None:
        return

2. Guard Clauses

Protect your logic from bad inputs:

if (user == null) return;
if (!user.hasPermission()) return;

3. Reduce Indentation

Every level of indentation increases cognitive load.

Bad:

if (a)
{
    if (b)
    {
        if (c)
        {
            DoSomething();
        }
    }
}

Better:

if (!a || !b || !c) return;

DoSomething();

4. Focus on the “Happy Path”

The main logic should be:

Straightforward
Easy to locate
Not buried inside conditions

Impact on Code Reviews

KCL is extremely effective in reviews because:

Patterns are easy to detect
Less domain knowledge is required
Reviewers can quickly spot:
Missing checks
Logical errors
Anti-patterns

Mental Model
When writing code, ask:

Can I exit earlier?
Can I reduce one level of indentation?
Is the main logic immediately visible?

Real-World Benefit

Over time, applying KCL leads to:

Fewer bugs
Faster onboarding of new developers
Cleaner diffs in pull requests
More maintainable systems

Keep Code Left (KCL) Guidelines for AI
Applying Keep Code Left (KCL) principles when working with AI assistants is important because, by default, they tend to generate code that is correct but unnecessarily nested. This makes the code harder to read, review, and maintain over time. By explicitly enforcing simple rules like early returns and minimal indentation, you guide the AI to produce cleaner, more linear code that aligns better with how humans understand logic. This reduces cognitive load, speeds up code reviews, and improves long-term maintainability.

Claude.MD Example:

Example: Claude `.md`

md
## KCL Rules
- Use early returns
- Avoid nested if statements
- Keep code flat and readable

### Example

Bad:
if (user) {
    if (user.isActive) {
        process(user);
    }
}

Good:
if (!user) return;
if (!user.isActive) return;

process(user);

Remade the 1991 Classic "Gorillas" in Python—and Survived the Snapcraft Journey

David Dominguez — Sat, 25 Apr 2026 06:06:15 +0000

The Nostalgia Hit 🍌

Remember the two gorillas standing on a skyline, tossing exploding bananas at each other? I decided to bring that back. I built a remake of the classic QBasic Gorillas using Python and Pygame.

It has everything:

Randomly generated city skylines.

Parabolic physics (gravity is a beast).

The classic sun that reacts when hit.

Screen shake for that "modern" retro feel.

The Tech Stack

Language: Python 3.12

Library: Pygame (for the heavy lifting of 2D rendering)

Distribution: Snapcraft (Ubuntu Snaps)

The "Snap" Struggle is Real 🛠️

Packaging this for Linux was an adventure. I wanted to make it easy for anyone to install without messing with virtual environments.

I hit every wall possible:

The Python Plugin: Getting the interpreter to behave inside a clean container was tricky.

Confinement: Switching to classic confinement was the key to getting audio and video drivers working smoothly across different distros.

The "Destructive" Fix: Learning to use --destructive-mode when my local container felt like being stubborn.

How to Play

If you are on Linux, you can try it out right now (waiting for store approval, but you can build from source!):
Bash

Clone the repo

git clone https://github.com/davdomin/gorillas-retro-remake
cd gorillas-retro-remake

Run it

python3 src/main.py

What’s Next? 🚀

I'm currently thinking about adding a multiplayer mode via IP connection. Is it overkill for a 1991 remake? Maybe. Is it going to be fun to code? Absolutely.

Check out the code here: https://github.com/davdomin/gorillas

Cómo consumir un API REST en C++ utilizando la biblioteca cURL.

David Dominguez — Sun, 22 Oct 2023 03:22:07 +0000

La programación en C++ es versátil y poderosa, y una de las tareas comunes es interactuar con servicios web a través de API REST. ¡Hoy te mostraré cómo hacerlo en unos pocos pasos!

Paso 1: Preparando el Entorno

Primero, asegúrate de tener la biblioteca cURL instalada. Puedes hacerlo utilizando tu administrador de paquetes favorito. Luego, incluye los encabezados necesarios en tu código.

Paso 2: Escribiendo el Código

Diseña tu programa C++ para realizar solicitudes HTTP utilizando cURL. Debes configurar la solicitud, incluyendo la URL del servicio web y definir una función de devolución de llamada para procesar la respuesta.

Paso 3: Haciendo la Solicitud

Utiliza cURL para realizar la solicitud HTTP al servicio REST. Maneja la respuesta y procesa los datos según tus necesidades.

Paso 4: Limpieza y Cierre

No olvides liberar los recursos una vez que hayas terminado de usar cURL.

✨ ¡Y eso es todo! Ahora puedes interactuar con servicios web en C++ y trabajar con los datos que obtengas. La programación en C++ abre un mundo de posibilidades.

Programación #CPlusPlus #RESTAPI #DesarrolloWeb

Sigue el enlace para mas detalles y obtener el codigo fuente
davdomin.blogspot.com/2023/10/como-consumir-un-api-rest-en-c.html
https://github.com/davdomin/RestApiCpp

Crear una Extensión para Chrome en 10 Sencillos Pasos

David Dominguez — Sat, 21 Oct 2023 02:21:20 +0000

Las extensiones de Chrome son pequeños programas que amplían las funcionalidades del navegador Google Chrome. En esta guía, aprenderás a crear una extensión básica desde cero. No se requiere experiencia previa en programación.

Configuración del Entorno de Desarrollo

Instalar Google Chrome: Si aún no tienes Google Chrome instalado, descárgalo e instálalo en tu computadora. Debes utilizar Chrome como navegador principal para probar tus extensiones.

Editor de Código: Utiliza un editor de código de tu elección. Recomiendo Visual Studio Code, que es gratuito y fácil de usar.

Crear la Estructura de Carpetas 3. Crea una Carpeta: En tu computadora, crea una carpeta para tu extensión. Nombremos esta carpeta "MiPrimeraExtension."

Archivo de Manifiesto 4. Crear el Archivo de Manifiesto: En la carpeta "MiPrimeraExtension," crea un archivo llamado "manifest.json". El manifiesto es un archivo importante que define la extensión y sus propiedades.

Editar el Manifiesto: Abre "manifest.json" en tu editor de código y agrega el siguiente código básico:

json

{
  "manifest_version": 3,
  "name": "Mi Primera Extensión",
  "version": "1.0",
  "description": "Una extensión simple de Chrome",
  "permissions": [
    "activeTab"
  ],
  "action": {
    "default_popup": "popup.html",
    "default_icon": {
      "16": "images/icon16.png",
      "48": "images/icon48.png",
      "128": "images/icon128.png"
    }
  }
}

Este código define información básica sobre la extensión, como su nombre y descripción, así como los íconos y la página emergente.

Archivo HTML para la Página Emergente 6. Crear la Página Emergente: En la misma carpeta, crea un archivo llamado "popup.html." Esta será la página que aparecerá cuando hagas clic en el ícono de la extensión.

Editar la Página Emergente: Abre "popup.html" y agrega el siguiente código HTML simple:

<!DOCTYPE html>
<html>
<head>
  <title>Mi Extensión</title>
</head>
<body>
  <h1>Hola, esta es tu primera extensión de Chrome.</h1>
</body>
</html>

Íconos para la Extensión 8. Preparar Íconos: Crea tres imágenes PNG para los íconos de la extensión con tamaños de 16x16, 48x48 y 128x128 píxeles. Guárdalas en una carpeta llamada "images" dentro de tu carpeta "MiPrimeraExtension."

Cargar la Extensión 9. Acceder a Chrome: Abre Google Chrome y visita "chrome://extensions/". Asegúrate de que la casilla de "Modo de desarrollador" esté marcada en la esquina superior derecha.

Cargar la Extensión: Haz clic en "Cargar extensión no empaquetada" y selecciona la carpeta "MiPrimeraExtension."

Enlace de la entrada: davdomin.blogspot.com/2023/10/como-crear-una-extension-para-chrome-en.html

Historia del "DLL Hell" a principios de los 90

David Dominguez — Wed, 18 Oct 2023 22:16:21 +0000

Las DLLs se introdujeron por primera vez en Windows 3.1 en 1992. Las DLLs permiten a los desarrolladores compartir código entre diferentes aplicaciones, lo que reduce la cantidad de código que debe escribirse y mantener.

En los primeros años de Windows, el infierno de las DLLs era un problema relativamente común. Esto se debía a que los desarrolladores no estaban familiarizados con las DLLs y no siempre tomaban las medidas necesarias para evitar conflictos.

Por ejemplo, un desarrollador podría instalar una DLL que proporciona una nueva función para una aplicación. Sin embargo, si otra aplicación ya está utilizando una DLL que proporciona la misma función, podría producirse un conflicto.
**
La introducción del Windows DLL Manager**

Microsoft ha tomado medidas para abordar el problema del infierno de las DLLs. En Windows 95, se introdujo el sistema de administración de DLLs de Windows (Windows DLL Manager). Este sistema ayuda a evitar conflictos al resolver automáticamente qué DLL se debe cargar en caso de conflicto.

El Windows DLL Manager funciona asignando un número de versión a cada DLL. Cuando un programa intenta cargar una DLL, el Windows DLL Manager busca la DLL con el número de versión más alto.

Si hay varias DLLs con el mismo número de versión, el Windows DLL Manager intentará resolver el conflicto utilizando un algoritmo de resolución de conflictos.

El infierno de las DLLs sigue siendo un problema potencial en los sistemas operativos de Microsoft. Esto se debe a que los desarrolladores aún pueden instalar DLLs que tienen el mismo nombre o versión.

Además, el Windows DLL Manager no siempre es capaz de resolver todos los conflictos de DLLs.

Aquí hay algunos ejemplos de cómo el infierno de las DLLs puede causar problemas:

Una aplicación puede dejar de funcionar o incluso bloquearse.
El sistema operativo puede mostrar un error o una pantalla azul de la muerte.
El sistema operativo puede ralentizarse o incluso dejar de responder.

Post completo: davdomin.blogspot.com/2023/10/historia-del-dll-hell-principios-de-los.html

Nuevas características y correcciones en la documentación y componentes de Quasar

David Dominguez — Wed, 18 Oct 2023 02:19:28 +0000

Quasar es un framework de desarrollo web y móvil de código abierto que utiliza Vue.js. Es conocido por su facilidad de uso, su rendimiento y su amplia gama de características.

El equipo de Quasar ha estado trabajando en algunas nuevas características y correcciones para la documentación y los componentes del framework. Algunas de estas novedades ya están disponibles, mientras que otras se lanzarán con futuras versiones de Quasar.

Nuevas características

** Nuevos idiomas:** La documentación ahora admite alemán (Suiza) y alemán (Alemania).
** Prop rawSort de QTable**: El componente QTable ahora tiene una nueva prop rawSort que se puede utilizar para ordenar filas con valores null o undefined.

Fuente:https://davdomin.blogspot.com/2023/10/novedades-quasar-framework-v2130.html

Ubuntu Desktop 23.10 en la Mira: Lo que Necesitas Saber sobre las Traducciones Ofensivas

David Dominguez — Mon, 16 Oct 2023 03:06:52 +0000

El mundo de la tecnología a menudo nos sorprende con desafíos inesperados, y la comunidad de Ubuntu Desktop no ha sido la excepción. En una reciente actualización, se ha detectado un incidente de traducción maliciosa que afecta a la versión 23.10 de Ubuntu Desktop. A continuación, te proporcionamos detalles clave sobre este incidente y las medidas tomadas para abordarlo.

Un colaborador de la comunidad envió traducciones ofensivas en ucraniano a un servicio en línea de terceros que se utiliza para brindar soporte de idioma para el instalador de Ubuntu Desktop. Apenas tres horas después del lanzamiento de Ubuntu 23.10, este hecho llamó la atención de la comunidad, y se tomaron medidas inmediatas para eliminar las imágenes afectadas.

Seguir leyendo: https://davdomin.blogspot.com/2023/10/nuevo-ubuntu-2310-mantic-minotaur.html

El Operador ternario en programación: Historia, ventajas y usos en diferentes lenguajes

David Dominguez — Thu, 12 Oct 2023 23:11:38 +0000

En el mundo de la programación, los operadores son herramientas esenciales para tomar decisiones y simplificar el código. Uno de los operadores más interesantes es el llamado "operador ternario". Personalmente, descubrí su existencia en 2012 mientras trabajaba en Yarkan, gracias a mi amigo Angel Ybarbhuen, quien me enseñó cómo usarlo. Desde entonces, el operador ternario se ha convertido en una parte fundamental de mi arsenal de programación. En este artículo, exploraremos su historia, ventajas y cómo se utiliza en diferentes lenguajes de programación.

Historia del Operador Ternario:

El operador ternario tiene una historia fascinante que se remonta a los primeros lenguajes de programación. Su origen se encuentra en el lenguaje de programación C, donde se introdujo por primera vez. A medida que los lenguajes evolucionaron, el operador ternario se incorporó a muchos de ellos debido a su eficacia en la escritura de código conciso y legible.

¿Qué es el Operador Ternario?:

Nota completa: davdomin.blogspot.com/2023/10/el-operador-ternario-en-programacion.html

El Anuncio de Microsoft: Microsoft Build for OpenJDK 21

David Dominguez — Thu, 12 Oct 2023 18:55:07 +0000

La industria tecnológica nunca deja de sorprendernos, y una de las últimas noticias emocionantes es el anuncio de Microsoft sobre la disponibilidad de su propia versión de OpenJDK 21, conocida como "Microsoft Build for OpenJDK 21". En este artículo, exploraremos esta noticia y lo que significa para la comunidad de desarrolladores.

Microsoft se une a la fiebre de Java 21:
Justo después del lanzamiento de la plataforma Java 21 por parte de Oracle, Microsoft ha dado un paso al frente al ofrecer su propia versión de OpenJDK 21 de forma gratuita. Esta noticia es un hito importante, ya que Microsoft está brindando a la comunidad de desarrolladores acceso gratuito a esta tecnología.

Características destacadas:
La versión de Microsoft Build for OpenJDK 21 trae consigo algunas características emocionantes que la diferencian de las versiones anteriores de Java. Algunas de las novedades incluyen:

Articulo completo davdomin.blogspot.com/2023/10/microsoft-ofrece-descarga-gratuita-de.html

Mi Viaje como Programador: Desde QBasic hasta la Era de la Inteligencia Artificial

David Dominguez — Thu, 12 Oct 2023 03:29:40 +0000

Mi viaje como programador comenzó en un momento muy diferente al que vivimos hoy en día. En los primeros días, no había tutoriales en línea ni la capacidad de buscar instantáneamente soluciones en la web. Todo lo que teníamos eran libros y la curiosidad para aprender. En esta entrada, compartiré mi emocionante y enriquecedor viaje desde mis humildes comienzos en QBasic hasta la emocionante era de la programación en Internet. A lo largo de los años, he experimentado cambios radicales en la tecnología y en la forma en que abordo la programación, y quiero compartir cómo esto ha moldeado mi carrera.

Los Primeros Pasos con QBasic:
Recuerdo con cariño mis primeros pasos en la programación con QBasic. Fue una época en la que pasaba horas escribiendo líneas de código y experimentando con programas sencillos. Fue mi padre quien me introdujo en el mundo de la programación. Me enseñó cómo crear un programa que solicitaba tu año de nacimiento y calculaba automáticamente tu edad. Este fue mi primer proyecto real, y me enseñó las bases de la lógica de programación.

Sigue leyendo : davdomin.blogspot.com/2023/10/de-qbasic-la-era-de-internet-mi-viaje.html