Commodore BASIC para niños
Datos para niños Commodore BASIC |
||
|---|---|---|
 |
||
| Desarrollador(es) | ||
| Microsoft |
||
| Información general | ||
| Apareció en | 1977 | |
| Diseñado por | Microsoft | |
| Última versión estable | V7.0 (1985) | |
| Implementaciones | desde el PET al C128 | |
| Licencia | privativa | |
El Commodore BASIC es un lenguaje de programación especial. Fue usado en las computadoras de 8 bits de la compañía Commodore International. Estas computadoras se fabricaron entre 1977 y 1985. También se le conoce como PET BASIC o CBM-BASIC.
Este lenguaje se basó en el Microsoft BASIC, que fue creado para el procesador MOS Technology 6502. Por eso, comparte muchas características con otros lenguajes BASIC de esa época, como el Applesoft BASIC. Commodore obtuvo la licencia de Microsoft en 1977. Fue un pago único, sin tener que pagar más por cada computadora vendida.
La primera versión para la computadora PET era muy parecida a la original de Microsoft. El BASIC 2.0, usado en la popular Commodore 64, también era similar. Las computadoras PET más nuevas usaban el BASIC 4.0, que añadía comandos para trabajar con disquetes.
El BASIC 3.5 fue el primero en cambiar bastante. Agregó comandos para manejar gráficos y sonido en las computadoras Commodore 16 y Plus/4. El BASIC 7.0 vino con la Commodore 128. Incluía comandos de programación más avanzados y funciones para aprovechar las nuevas capacidades de esa máquina. También tenía un editor de sprites (pequeñas imágenes) y una herramienta para ver el lenguaje de máquina. La última versión, BASIC 10.0, fue parte de la Commodore 65, una computadora que nunca se vendió al público.
Contenido
Commodore BASIC: El Lenguaje de las Computadoras Clásicas
Una Historia Curiosa: Commodore y Microsoft
Commodore tomó el código fuente del BASIC y lo mejoró para todas sus computadoras de 8 bits. Curiosamente, no fue hasta la Commodore 128 (con la versión 7.0) que se mostró un aviso de derechos de autor de Microsoft.
Sin embargo, Microsoft había escondido un "huevo de Pascua" (un mensaje oculto) en la versión 2 del Commodore BASIC. Si escribías el comando `WAIT 6502, 1`, la palabra `Microsoft!` aparecía en la pantalla. Este mensaje estaba muy bien escondido y no se veía fácilmente.
La famosa Commodore 64 usaba el BASIC v2.0, aunque se lanzó después de las computadoras PET/CBM que ya tenían la versión 4.0. Esto se hizo porque la Commodore 64 estaba pensada para el hogar. Las series PET/CBM, en cambio, estaban dirigidas a negocios y escuelas, donde se esperaba que se usara más su lenguaje de programación. Usar la versión 2.0 también ayudó a reducir los costos de fabricación, ya que cabía en memorias ROM más pequeñas.
Cómo se Programaba: Edición y Comandos
Una característica útil del intérprete BASIC, que estaba guardado en la memoria ROM, era su editor de pantalla completa. Aunque los teclados Commodore solo tenían dos teclas para mover el cursor (que cambiaban de dirección al presionar la tecla Mayúsculas), el editor permitía escribir y modificar líneas de programa en cualquier parte de la pantalla.
Si una línea empezaba con un número, se guardaba como parte del programa. Las líneas sin número se ejecutaban al presionar la tecla ENTER. Esto era una gran mejora comparado con otros lenguajes BASIC de la época, que usaban editores más básicos.
También se podían guardar archivos con nombres en cualquier dispositivo, como las cintas de casete. Las cintas eran una forma económica de guardar información en los primeros días de las computadoras Commodore. A diferencia de otros sistemas, los archivos en casete de Commodore se podían buscar por nombre. El sistema leía los datos hasta encontrar el nombre del archivo deseado. Los datos de los casetes Commodore se grababan de forma digital, lo que era más fiable que los métodos analógicos de otros fabricantes. Por eso, se necesitaba un dispositivo especial llamado Commodore Datasette.
El comando `LOAD` se usaba para cargar programas. Si se añadía `,1` (por ejemplo, `LOAD "PROGRAMA",1`), el programa se cargaba en una dirección de memoria específica. Si no se usaba `,1`, el programa se cargaba al inicio del área de programas BASIC.
Las palabras clave de Commodore BASIC se podían abreviar. Por ejemplo, `GOTO` se podía escribir como `G` y luego `Shift-O`. Esto hacía que el intérprete reconociera el comando completo. Esto era una comodidad para escribir, no una forma de hacer los programas más pequeños, ya que todas las palabras clave se guardaban como un solo "token" (un código corto) en la memoria.
Velocidad y Trucos de Programación
Como otros lenguajes BASIC, Commodore BASIC era más lento que el código de máquina (el lenguaje que la computadora entiende directamente). Para que los programas fueran más rápidos, los programadores usaban trucos. Por ejemplo, guardar números que se usaban mucho en "variables" en lugar de escribirlos cada vez.
Cuando la velocidad era muy importante, los programadores convertían partes de sus programas BASIC a lenguaje ensamblador (un lenguaje más cercano al código de máquina). Este código se cargaba por separado y se ejecutaba desde BASIC usando el comando `SYS`.
Una característica única de Commodore BASIC era el uso de códigos de control para tareas como borrar la pantalla o mover el cursor. Se podían usar con el comando `PRINT CHR$(X)` o presionando la tecla correspondiente directamente. Por ejemplo, `PRINT CHR$(147)` borraba la pantalla.
Las líneas de programa en Commodore BASIC no necesitaban espacios. Por ejemplo, `100 IFA=5THENPRINT "YES":GOTO160` era válido. Esto ayudaba a ahorrar memoria, aunque el comando `LIST` siempre mostraba los espacios.
Las líneas de programa podían tener hasta 80 caracteres en la mayoría de las máquinas. En la Commodore 128, el límite era de 160 caracteres. Usar abreviaturas como `?` en lugar de `PRINT` permitía poner más código en una sola línea.
El orden en que se ejecutaban las líneas de programa no dependía solo de su número. Las líneas se guardaban en la memoria como una "lista enlazada". Esto significaba que cada línea tenía un "puntero" que indicaba dónde estaba la siguiente línea. Los programadores podían manipular estos punteros para cambiar el orden de ejecución o incluso dar a varias líneas el mismo número. Esto a veces se usaba para proteger el software.
Los números de línea podían ir de 0 a 65520. Poner varias instrucciones en una sola línea usaba menos memoria y se ejecutaba más rápido.
Los nombres de las variables solo eran importantes por sus dos primeras letras. Así, `VARIABLE1`, `VARIABLE2` y `VA` se referían a la misma variable.
Commodore BASIC también soportaba operaciones lógicas como `AND`, `OR` y `XOR`.
Entendiendo las Variables y Números
El formato principal para los números en Commodore BASIC era el de "coma flotante". Esto significa que los números se guardaban con una parte para el valor y otra para la posición del punto decimal. Esto permitía manejar números muy grandes o muy pequeños. Sin embargo, la precisión era limitada (unos 6.5 dígitos decimales), lo que podía causar pequeños errores de redondeo.
Aunque Commodore BASIC permitía variables de números enteros (indicadas con un signo de porcentaje, como `NUM%`), en la práctica, solo se usaban para listas de números (matrices). Esto ayudaba a ahorrar memoria en matrices grandes. Si se usaba un número entero en una variable normal, BASIC lo convertía a coma flotante, lo que podía hacer el programa más lento.
El comando `SYS` se usaba para iniciar programas escritos en lenguaje de máquina. Este comando no estaba en el BASIC original de Microsoft.
Todas las computadoras Commodore (excepto la C128) no podían iniciar programas de disco automáticamente. Por eso, era común incluir una línea BASIC como `10 SYS 2048` para que el programa se ejecutara.
Si no se declaraba una lista de números (matriz) con el comando `DIM`, se le asignaban automáticamente 10 elementos (en realidad, 11, porque se cuentan desde 0). Las matrices más grandes debían declararse.
Las variables de texto (cadenas) se indicaban con un signo de dólar (`$`) al final del nombre, como `NOMBRE$`. Las variables de texto, las de números y las listas de números se consideraban diferentes, incluso si tenían nombres parecidos.
Las computadoras Commodore tenían un reloj interno que se iniciaba en 0 al encenderse y se actualizaba 60 veces por segundo. Había dos variables para la hora: `TI` (solo lectura) y `TI$` (para establecer la hora).
La función `RND` se usaba para generar números aleatorios. `RND(0)` usaba el reloj para generar números entre 0 y 255. Para números más aleatorios, se usaba el canal de ruido blanco del chip de sonido SID en la C64 y C128.
Problemas y Soluciones del BASIC 2.0
El BASIC 2.0 era conocido por ser muy lento al "recoger basura" (liberar memoria de cadenas de texto que ya no se usaban). Si un programa usaba muchas variables de texto, esta tarea podía tardar mucho tiempo. No se podía detener este proceso.
La función `FRE`, que mostraba la memoria libre, tenía un problema en BASIC 2.0. No podía manejar números mayores de 32768. Por ejemplo, en una Commodore 64 (con 38KB de memoria BASIC), `FRE` mostraba un número negativo. Las versiones posteriores de BASIC (3.5 y 7.0) corrigieron este problema.
Alternativas y Mejoras al BASIC Original
Se crearon muchas extensiones para el BASIC 2.0 de la Commodore 64, ya que sus capacidades eran algo limitadas. Una de las más populares fue el DOS Wedge, que venía en el disco de prueba de la unidad de disquete Commodore 1541. Esta extensión añadía comandos para el disco, como la capacidad de ver el contenido de un disco sin borrar el programa en la memoria.
Otras extensiones de BASIC añadieron comandos para facilitar la programación de gráficos, sonido y sprites, como el famoso Simons' Basic.
Algunos expertos decían que las limitaciones del BASIC 2.0 eran buenas, porque obligaban a los usuarios a aprender lenguaje de máquina, que era más potente.
Usando BASIC como Interfaz de Usuario
Al igual que otras computadoras de la época, las máquinas Commodore se iniciaban directamente en el intérprete BASIC. Los comandos de programación y de archivos se podían escribir directamente para cargar y ejecutar programas. Si un programa se detenía, los valores de las variables se mantenían en la memoria, lo que permitía revisarlos para encontrar errores.
Aunque algunas versiones de Commodore BASIC tenían comandos específicos para el disco como `DLOAD` y `DSAVE`, la versión de la Commodore 64 no los tenía. Esto significaba que el usuario tenía que especificar el número de la unidad de disco (normalmente 8 o 9) en el comando `LOAD` estándar.
Otra cosa que faltaba en el BASIC 2.0 de la Commodore 64 era un comando para ver el contenido de un disco sin borrar la memoria. En la C64, para ver los archivos, se cargaba un "programa" especial que, al listarse, mostraba el directorio como si fuera un programa BASIC. Esto borraba cualquier programa que estuviera en la memoria. Extensiones como el DOS Wedge solucionaron esto mostrando la lista directamente en la pantalla.
Versiones Importantes de Commodore BASIC
Aquí tienes una lista de las versiones de CBM BASIC y las características que se fueron añadiendo:
Versiones Publicadas
- V1.0: Para la primera PET 2001.
* Listas de números (matrices) limitadas a 256 elementos.
- V2.0 (primer lanzamiento): Para la PET 2001 con teclado mejorado.
* Mejoró la gestión de memoria. * Corrigió un error en las matrices. * Incluía el "huevo de Pascua" de Microsoft.
- V4.0: Para las series PET/CBM 4000/8000.
* Añadió 15 comandos para operaciones de disco, como `DLOAD` (cargar desde disco) y `DSAVE` (guardar en disco). * Mejoró mucho la velocidad de limpieza de memoria.
* Comandos para manejar la memoria: `BANK`. * Más operaciones de disco: `BLOAD`, `BSAVE`. * Manejo de errores: `TRAP`, `RESUME`.
- V3.5: Para la C16/116 y Plus/4.
* Comandos para sonido y gráficos. * Entrada de joystick: `JOY`. * Conversión entre números decimales y hexadecimales: `DEC()`, `HEX$()`. * Estructuras de bucle avanzadas: `DO`, `LOOP`, `WHILE`, `UNTIL`, `EXIT`. * Edición de programas: `AUTO`, `DELETE`, `RENUMBER`. * Herramientas para encontrar errores (depuración): `TRON`, `TROFF`.
- V7.0: Para la C128.
* Más comandos de sonido y gráficos, incluyendo manejo de sprites. * Editor de sprites integrado: `SPRDEF`. * Comandos para ventanas de texto: `WINDOW`. * Gestión de memoria: `SWAP`, `FETCH`, `STASH`. * Más operaciones de disco: `BOOT`, `DVERIFY`. * Ajuste de velocidad del procesador: `FAST`, `SLOW`. * Comando para entrar en modo C64: `GO64`.
Versiones No Publicadas
- V3.6: Para la Commodore LCD (un prototipo que no se lanzó). Muy similar a la V7.0.
- V10: Para la Commodore 65 (otro prototipo que no se lanzó).
* Comandos de gráficos y video: `PALETTE`, `GENLOCK`. * Entrada de ratón: `MOUSE`, `RMOUSE`. * Edición de programas: `FIND`, `CHANGE`.
Extensiones Famosas
- Super Expander (para VIC-20 y C64, en cartucho).
- Simons' Basic (para C64, en cartucho).
- Graphics BASIC (para C64, en disquete).
- BASIC 8 (para C128, en disquete o chip ROM opcional).
Galería de imágenes
-
La pantalla de inicio del Simons' BASIC.
Véase también
En inglés: Commodore BASIC Facts for Kids
