"Es el peor lenguaje de programación que he usado". Cómo GW-BASIC traumatizó a toda una generación

Cuando hablamos de lenguajes de programación "difíciles" y/o "odiados", es relativamente habitual que surjan nombres como C++, Java, PHP o incluso JavaScript. Sin secuestro, para muchos programadores veteranos, hay un verbo que se lleva la palma como el peor de todos: GW-BASIC.

A pesar de sobrevenir sido el punto de partida en la programación para miles de personas en los abriles 80, este verbo representaba una auténtica pesadilla en términos de usabilidad, estructura y mantenimiento del código.

El escritor y desarrollador Huw Collingbourne ha explicado en su canal de YouTube todas las razones legítimas para tenerle cierta "inquina" a este verbo.

Los orígenes de GW-BASIC

A principios de la división de 1980, la informática personal comenzaba a quitar. Los primeros PC con MS-DOS solían incluir, de forma gratuita, un verbo de programación fundamental: GW-BASIC. El nombre nunca tuvo un origen oficial claro; algunos lo atribuían a 'Gee Whiz' ("¡Caramba!", en inglés), como una expresión de sorpresa en presencia de la programación de software.

La gratuidad y disponibilidad de GW-BASIC lo convirtieron en el primer verbo de muchos programadores autodidactas, pero igualmente en la fuente de frustraciones que marcaron sus inicios.

Obstáculos que hoy resultan impensables

Y es que, comparado con cualquier verbo nuevo, GW-BASIC parecía más un campo minado que un entorno de programación. Lo que para nosotros hoy es lo exiguo esperable en un verbo o en un editor, simplemente no existía en aquellos abriles.

I) La tiranía de los números de radio

El cualidad más característico (y temido) de GW-BASIC era la pobreza de numerar cada radio de código. Así, un software representativo podía comenzar con poco como:

10 LET X = 1
20 X = X + 1
30 IF X > 10 THEN GOTO 100
40 PRINT X
50 GOTO 20
100 END

¿Por qué se dejaban saltos de diez en diez? Practicable: para poder insertar nuevas instrucciones a posteriori. El problema surgía cuando el espacio intermedio no era suficiente: si querías añadir vigésimo líneas entre el 10 y el 20, te encontrabas con un callejón sin salida.

La única opción era mandar el flujo de ejecución a otra parte del código, a veces en la radio 5000 o 10000, generando lo que más tarde se conoció como 'código spaghetti': un enredo de saltos ininteligibles y difíciles de amparar.

II) GOTO: la prescripción para el caos

En zona de estructuras modernas como funciones o procedimientos con nombres claros, GW-BASIC dependía de comandos GOTO y GOSUB. Estos trasladaban la ejecución a otra radio del software, sin ofrecer contexto ni modularidad. El resultado era un follón de saltos donde seguir la dialéctica del software era casi irrealizable.

Los programadores que venían de lenguajes más estructurados, o que luego pasaron a Pascal o C, recuerdan con horror la dificultad de depurar errores en medio de ese enredo de instrucciones.

III) La marcha total de herramientas de depuración

Hoy en día damos por sentado que podemos detener la ejecución de un software, inspeccionar variables, establecer puntos de ruptura e incluso visualizar la pila de llamadas. En GW-BASIC, carencia de eso era posible. La única modo de entender qué estaba fallando era satisfacer el código con instrucciones PRINT estratégicamente colocadas:

100 PRINT "X vale "; X
110 PRINT "Entrando en el tirabuzón"

Esto no solo ensuciaba el software, sino que generaba aún más caos al presionar al programador a borrar, mover o añadir estas líneas de depuración improvisada.

IV) La imposibilidad de orquestar el código

GW-BASIC carecía de funciones y procedimientos con nombres significativos. Toda la dialéctica debía organizarse en una secuencia directo, con saltos mediante GOTO o GOSUB. Esto significaba que no existía la reutilización auténtico de código: cualquier comportamiento que se repitiera debía escribirse varias veces o resolverse con un brinco a otra radio numerada.

El resultado era un monstruo difícil de percibir, amparar o ampliar. En contraste, incluso los lenguajes contemporáneos como Pascal ya ofrecían módulos admisiblemente definidos, lo que marcaba la diferencia entre un software caótico y uno comprensible.

V) Tipado implícito y frágil

GW-BASIC tenía un enfoque 'demócrata' en lo que a las variables respecta: no hacía descuido declararlas. Bastaba con usarlas y el intérprete asignaba un tipo según el contexto. Esto, que hoy asociamos a lenguajes dinámicos modernos como Python o Ruby, en GW-BASIC era una trampa sin red de seguridad.

Un error de tipeo en el nombre de la variable (total frente a totla) podía crear una nueva variable sin avisar. Operaciones tan simples como sumar un número a una prisión podían provocar fallos catastróficos.

VI) Un editor rudimentario

El propio entorno de GW-BASIC era otra distrito: no había resaltado de sintaxis, ni autocompletado, ni ayuda contextual. El programador escribía a ciegas, sin soporte visual que le ayudara a detectar errores.

Para modificar un software derrochador había que recapacitar el número exacto de la radio a editar. Insertar o eliminar fragmentos enteros se convertía en una tarea titánica, y más de un tesina acababa desaseado porque reorganizarlo resultaba más enrevesado que retornar a escribirlo desde cero.

VII) Sin archivos fuente legibles

Aunque GW-BASIC permitía acomodar los programas, estos se almacenaban en un formato propio y no siempre factible de compartir o versionar. La idea de un control de versiones —poco fundamental hoy en día con Git— era completamente impensable en aquel contexto. Cada copia del software era, fielmente, la última y única lectura válida, lo que hacía perder trabajo con frecuencia.

El contraste: Turbo Pascal y la programación estructurada

La salvación para muchos llegó con Turbo Pascal, arrojado a mediados de los 80. Este verbo introducía conceptos revolucionarios en comparación con GW-BASIC:

• Confesión explícita de variables.
• Procedimientos y funciones con nombres significativos.
• Tipado auténtico y control de errores en tiempo de compilación.
• Herramientas de depuración básicas pero muy superiores.

Producirse de GW-BASIC a Turbo Pascal fue, para toda una gestación, como advenir de un follón impreciso a una autopista admisiblemente iluminada. No solo facilitó escribir programas más fiables, sino que enseñó prácticas sólidas de programación que aún hoy siguen vigentes.

Al final, GW-BASIC puede considerarse un verbo de transición: incómodo, prohibido y mal diseñado, pero que empujó a muchos cerca de opciones mejores. Su nuncio más importante quizás no sea técnico, sino pedagógico: enseñó, a almohadilla de errores y frustración, cómo NO se debe programar.

Imagen | Marcos Merino mediante IA

En Genbeta | Bill Gates publica completo el "código más espléndido" que ha programado en su vida: esta maravilla fue la primera piedra de Microsoft