¡BASIC cumple 60 años!
Tags: spanish, programming, basic, retro
Published: 2024-05-03 14:34:24

---
title: ¡BASIC cumple 60 años!
published: true
description: El veterano lenguaje de programación para principiantes.
tags: #spanish #programming #basic #retro
cover_image: https://upload.wikimedia.org/wikipedia/commons/thumb/1/1b/ZX_Spectrum128K.jpg/1280px-ZX_Spectrum128K.jpg
# Use a ratio of 100:42 for best results.
# published_at: 2024-05-03 11:04 +0000
---
BASIC (acrónimo de *Beginners' All-purpose Symbolic Instruction Code*, o código de instrucciones simbólico de propósito general para principiantes) es un lenguaje de programación creado en el Darmouth College de New Hampshire (EEUU).

Este lenguaje de programación se distribuyó como la espuma, al ser una forma de programar cualquier computadora, incluso un *mainframe*, de manera muy sencilla.

Con el tiempo, otros lenguajes de programación tomaron su lugar, tanto en prestaciones como en facilidad de uso.

Vale, pues resulta que [el lenguaje de programación BASIC ha cumplido la friolera de 60 años](https://computerhoy.com/pc/lenguaje-programacion-basic-cumple-60-anos-1383537).

Como no, el BASIC trae recuerdos. Cuando los ordenadores domésticos (ahora llamados PC (*Personal Computer*, u ordenador personal, y entonces llamados microordenadores) empezaron a proliferar en la década de los 80 del siglo XX, todos ellos traían algún variante de BASIC instalado (en realidad, incluso los primeros IBM PC arrancaban con GW-BASIC en ROM). No solo eso, sino que el propio lenguaje de programación era lo más parecido a un sistema operativo, permitiendo acceder a los periféricos, muchas veces empleando instrucciones BASIC dedicadas. Por ejemplo, en un [Sinclair Spectrum +3](https://en.wikipedia.org/wiki/ZX_Spectrum), para enumerar los programas en el *diskette* se utiliza la instrucción "CAT", mientras que para cargar y guardar programas BASIC se emplea "LOAD" y "SAVE". Los programas en código máquina se cargan y se guardan con "LOAD CODE" y "SAVE CODE". Para imprimir por la impresora se emplea "LPRINT" y para listar el programa en BASIC "LLIST".

En mi caso, mi primer ordenador fue el [Sinclair Spectrum 128K (español)](https://web.archive.org/web/20210307052117/https://www.zonadepruebas.com/viewtopic.php?t=1826). Un ordenador desarrollado en conjunción entre Sinclair e Investrónica, una empresa española afiliada a El Corte Inglés. Hoy por hoy, este modelo específico de microordenador es casi una rareza.

La ventaja de BASIC era que cada instrucción se podía *leer* (en inglés, eso sí) prácticamente tal y como si se hubiera escrito en lenguaje natural.

Una característica notoria de esta época, que desaparecería con el tiempo, era utilizar un número de línea para cada instrucción o pequeño grupo de instrucciones.

Por ejemplo, el siguiente código visualiza *¡Hola mundo!* continuamente por pantalla.

```basic
10 print "¡Hola, mundo!"
20 goto 10
```

Podemos ver este código escrito en el Spectrum 128k.

![¡Hola, mundo! en Sinclair BASIC](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/8drv4qs4xkv8vir1v013.png)

Y la ejecución no nos dejará indiferentes.

![Programa en ejecución](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ynm6l9p2ej2xo7fkpngj.png)

Por supuesto, este código, por popular que sea, no resuelve ningún problema. Veamos algo un poco más interesante. El siguiente programa saluda al usuario.

```basic
10 input "Dame tu nombre: "; a$
20 print "Hola, "; a$
```

![Código del saludo en Sinclair BASIC](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ibjtd4g9d8kg46xjzqgo.png)

Y la salida del programa es la que esperadaba, tras introducir mi propio nombre.

![Salida del programa del saludo](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ybb6famd9f5d1fgv9e7k.png)

Es simple de entender: mientras **print** muestra valores por pantalla, **input** permite mostrar un mensaje por pantalla para guardar un valor introducido por teclado en una variable llamada *a$*.

En los primeros BASIC era muy típico utilizar terminaciones en los nombres de las variables para conocer cuál era su tipo. Utilizar el símbolo del dolar para indicar que la variable es de tipo cadena de caracteres (es decir, sucesión de caracteres), es un clásico.

Por cierto, en Microsoft BASIC (presente en el PC, los MSX, el Dragon...), las cadenas de caracteres se ofrecían en modalidad Pascal, por tanto con un máximo de 256 caracteres. En Sinclair BASIC, las cadenas de caracteres pueden tener el tamaño que se desee (probablemente están codificadas en modalidad C, con un caracter centinela marcando el final). El heredero directo de este BASIC es [GW-BASIC](https://devblogs.microsoft.com/commandline/microsoft-open-sources-gw-basic/), que se distribuía con los IBM PC y clónicos como parte de MS-DOS. Una implementación moderna en Python puede encontrarse en el [repo GitHub de PC-BASIC](https://robhagemans.github.io/pcbasic/), e instalarse con un sencillo `pip install -U pcbasic` si tienes Python correctamente instalado (sí, también hay instaladores para Windows).

Esto todavía no muestra un programa que realmente haga algo. ¿Por qué no implementar el cálculo de la sucesión de **Fibonacci**?

![Cálculo de Fibonacci en Sinclair BASIC](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/5movl5ddftjvm4k6h6bf.png)

```basic
10 cls: print "Fibonacci": print
20 input "Cuántas posiciones: "; MAX
20 let N1 = 1: let N2 = 1: print 1, 1
30 for I = 1 to MAX - 2
40 let N2B = N2
50 let N2 = N1 + N2
60 let N1 = N2
70 print N2,
80 next I
90 print
```

En la línea 10 pedimos un valor entero al usuario que guardaremos en *MAX*. Se trata del número de posiciones a calcular de la sucesión de **Fibonacci**.

En la línea 20 definimos con **let** las variables *N1* y *N2*, las dos con valor 1. Esto es así porque, como sabemos, los valores iniciales de la sucesión de **Fibonacci** son sendos unos. Las siguientes posiciones se calculan sumando la penúltima y antepenúltima posición. Así, despues de las primeras posiciones, la primera posición calculada es la tercera, con valor 2, pues las anteriores son 1 y 1. La cuarta toma el 2 recién calculado y la segunda posición, es decir, el "último" uno del par inicial, sumando 3. La siguiente es 5 (3 + 2), después 8 (5 + 3), después 13 (8 + 5)...

Así, los valores iniciales de la sucesión de **Fibonacci** son: 1, 1, 2, 3, 5, 8, 13, 21...

Cuando hacemos en Sinclair BASIC `print 1, 1,`, estamos diciéndole, por cierto, que muestre valores en dos columnas, empleando tantas filas como sea necesarias. Así, si visualizamos con `print 1, 2, 3, 4, 5, 6`, se mostrará como sigue, obteniendo un formato ordenado y limpio.

```
1    2
3    4
5    6
```

A partir de la línea 30 tenemos un bucle **for**. Las líneas entre el **for** de la línea 30 y el next 80 se repetirán mientras la variable I no alcance el límite designado (*MAX - 2* en el código). Así, el bucle define un punto inicial y un punto final. Ya que hemos empezado con los dos unos iniciales, tendremos que realizar *MAX - 2* vueltas en el bucle, para llegar a calcular el número de elementos guardado en *MAX* dado por el usuario. Esta es una forma de hacerlo, otra sería empezar en 3 y terminar en *MAX*. Realmente, el contenido de la variable de bucle *I*, que irá tomando los valores desde el inicio (1 en el código), hasta el final (*MAX - 2* en el código) nos resulta indiferente, con tal de que el bucle se ejecute las veces necesarias.

En cada vuelta de bucle calcularemos una nueva posición. Salvaguardamos el valor de *N2* en *N2B*, pues vamos a necesitarlo más tarde. Guardamos en *N2* la suma de *N2* y *N1* (el nuevo valor), y en *N1* el antiguo valor de *N2*, con lo que hemos "desplazado" los valores de *N1* y *N2* a la siguiente posición calculada, preparándolo todo para la siguiente vuelta del bucle. De nuevo, al utilizar una coma al final del **print** de la línea 70, estamos indicando que queremos visualizar un valor en la siguiente columna libre (puede ser en la línea actual del cursor, o en la siguiente).

¡Y ya está!

![Salida de la ejecución de Fibonacci en Sinclair BASIC](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/vtdmgm45gz2jpf2x8g1d.png)

Es notable ver que en Sinclair BASIC se utilizan los números reales cuando se alcanzan, aparentemente, los 26 bits. O quizás vaya por número de dígitos, quién sabe. El caso es que, en realidad, Sinclair BASIC siempre utiliza números en coma flotante, empleando una forma especial de visualización cuando no hay decimales.

¿Y qué ha pasado con el BASIC? ¿Se sigue utilizando hoy en día? Lo cierto es que tuvo una edad de oro a finales de los 90 del siglo XX y en la primera década del siglo XXI. Las últimas versiones de MS-DOS incorporaban [**QBasic**](https://es.wikipedia.org/wiki/QBasic), un entorno de programación para un intérprete de BASIC capaz de manejarse con gráficos y sonidos, y que ya prescindía de los números de línea. El siguiente nivel era [**QuickBasic**](https://es.wikipedia.org/wiki/QuickBASIC), que permitía incluso compilar el programa BASIC a código máquina, no necesitando por tanto un intérprete para ser ejecutado en el IBM PC o compatible del destino. Y finalmente, apareció [**Visual Basic**](https://es.wikipedia.org/wiki/Visual_Basic). Este producto fue un auténtico bombazo para Microsoft, haciendo que sus ventas se dispararan, así como el software disponible para Windows, sobre todo el realizado por un usuario más *amateur* que quería resolver la automatización de ciertas tareas (aunque en algunos casos, se crearon productos profesionales con él).

Aunque **Visual Basic** ya no se comercializa, sus notables sucesores fueron **VBScript** para el navegador (en lugar de **JavaScript**, aunque [VBScript acaba de ser descontinuado](https://dev.to/baltasarq/es-descanse-en-paz-vbscript-2gbg)); VBA ([Visual Basic for Applications](https://es.wikipedia.org/wiki/Visual_Basic_for_Applications), lenguaje de script presente en MS Office para automatizar el tratamiento de datos), y finalmente [**Visual Basic.NET**](https://es.wikipedia.org/wiki/Visual_Basic_.NET), que de forma controvertida sustituyó a Visual Basic 6 sin ofrecer retrocompatibilidad (los programas en VB6 no se pueden ejecutar directamente con VB.NET).

Pero lo cierto es que existen tantas variantes de BASIC de todos los posibles sabores que podamos imaginar: una simple búsqueda por Internet nos devolverá varias docenas.