Diferencias

Muestra las diferencias entre dos versiones de la página.

--- tutorial_de_aventuras_en_basic [2022/01/25 18:53] – peron
+++ tutorial_de_aventuras_en_basic [2022/08/01 23:14] (actual) – [Conclusión] peron
@@ Línea 1: / Línea 1: @@
 ====== Tutorial de BASIC: "Crea tu propia aventura" ======
-Este tutorial te presenta generalidades, pero está pensado siguiendo el dialecto GW-BASIC. Puedes usar [[PC-BASIC]].
+Este tutorial sencillo te presenta generalidades del [[basic|lenguaje de programación BASIC]] para realizar un microprograma [[HISTORIA.BAS]]. Con ello podrás realizar un  [[aventuras de texto|juego de aventura de texto]] sencillo. Utilizarás uno de nuestros [[interpretes_de_basic|intérpretes de BASIC]].
-¿Alguna vez has leído uno de esos libros de cuentos de "Sigue tu propia aventura"? En ellos leías algunos párrafos y luego debías tomar una decisión por el personaje principal. Luego pasas a otra página del libro y continuabas la historia. Podías interactuar así con las aventuras que seguía el personaje. Este tipo de libros son divertidos. Lo que es aún más divertido es escribir tu propio programa BASIC para hacer lo mismo.
+===== Introducción =====
-El programa que abordaremos en este tutorial presentan una pantalla llena de historias y luego se te pide que tomes una decisión. Tu decisión hará que aparezca otra pantalla de la historia. En el camino, aprenderemos algunas declaraciones BÁSICAS más. Verá cómo se toman las decisiones en un programa de computadora y cómo la ejecución puede saltarse dentro de un programa.
+¿Alguna vez has leído uno de esos libros de cuentos de "Sigue tu propia aventura"? En ellos leías algunos párrafos y luego debías tomar una decisión por el personaje principal. Luego pasas a otra página del libro y continuabas la historia. Podías interactuar así con las aventuras predeterminadas que podía Seguir el personaje. Este tipo de libros son divertidos, y lo que es aún más divertido aún es escribir tu propio relato y tu propio programa de BASIC capaz de "darle vida".
-Para comenzar, ingrese estas primeras veintiocho líneas del programa exactamente como están escritas. Asegúrese de presionar ENTER después de cada línea. Una pista: después de escribir la línea 70 y presionar ENTER, puede mover el cursor hacia atrás hasta el número de línea, cambiarlo a 80 y presionar ENTER nuevamente. Esto ahorra mucho escribir. Use LIST con frecuencia para verificar su progreso.
+=== Propuesta ===
+El microprograma [[historia.bas]] que abordaremos en este tutorial presentan una pantalla el relato, y te solicitará que tomes la decisión. Tu decisión hará que aparezca una segunda pantalla con la continuación de relato de la historia. En el camino, aprenderemos algunas órdenes y declaraciones de BASIC; verás cómo se toman las decisiones en un programa de computadora y cómo la ejecución saltar dentro de un programa.
+==== ¡A programar! ====
+Para iniciar, abre el intérprete en tu [[emulador_de_terminal|terminal]]. Podrás utilizar [[bwbasic]]. Introduce el comando:
-<code basic>
+<code>
+bwbasic
+</code>
+Para comenzar podrías tipear estas primeras veintiocho líneas del código BASIC exactamente como están escritas en tu intérprete de BASIC (por ejemplo, [[bwbasic|BwBASIC]])... ¡pero esto es engorroso! Simplemente //copia y pega//. Asegúrese de presionar **Intro** después de cada línea.
+> Si deseas teclear el código BASIC, te doy una ayuda para ahorrar tiempo: luego de escribir la línea 70 y presionar **Intro**, puedes mover el cursor hacia atrás hasta el número de línea, cambiarlo a 80 y presionar Intro nuevamente. Esto ahorra mucho escribir. Ingresa el comando **LIST** con frecuencia para verificar tu progreso.
+== Primera parte del código fuente en BASIC ==
+<code freebasic>
   REM *************************************************************
   REM *  HISTORIA                                                 *
@@ Línea 43: / Línea 55: @@
 ===== Comentarios =====
+Observa las líneas 10 a 40. ''REM'' es una declaración de BASIC que no hace nada, significa "comentario". El propósito de ''REM'' es agregarle comentarios al programa. Estos comentarios ayudan al programador a comprender cómo funciona el programa. Las palabras a continuación de ''REM'' no se imprimen en pantalla durante la ejecución. Solo son visibles listando el código fuente.
-Observa las líneas 10 a 40. REM es una declaración de BASIC que no hace nada, significa "comentario". El propósito de REM es agregarle comentarios al programa. Estos comentarios ayudan al programador a comprender cómo funciona el programa. Las palabras a continuación de REM no se imprimen en pantalla durante la ejecución. Solo son visibles listando el código fuente.
+> Los comentarios son importantes. Cuando termines de escribir tu programa, probablemente comprendas todo de él. Sin embargo, transcurridos unas semanas te resultará irreconocible Los comentarios ayudan. A diferencia de la era del [[DTSS|BASIC de Darthmouth]], hoy la memoria es prácticamente gratuita! Por lo tanto ¡Usa ''REM'' generosamente!
-> Los comentarios son importantes. Cuando termines de escribir tu programa, probablemente comprendas todo de él. Sin embargo, transcurridos unas semanas te resultará irreconocible Los comentarios ayudan. A diferencia de la era del [[DTSS|BASIC de Darthmouth]], hoy la memoria es prácticamente gratuita! Por lo tanto ¡Usa REM generosamente!
 El pequeño rectángulo hecho de asteriscos se llamaba //caja de flores//. Se acostumbraba colocar el nombre del programa, en este caso, //HISTORIA//, junto con una breve descripción del cometido del programa. Generealmente la caja de flores solía tener 40 caracteres de ancho. De hecho, algunos programas contenían más comentarios que describen el programa que líneas de instrucciones de BASIC a interpretar. Los asteriscos no tienen relevancia alguna en este caso. Podrás utilizar cualquier carácter. El propósito es únicamente proporcionar un atractivo cartelón informativo.
-==== VARIABLES ====
+==== Variables ====
-La línea 270 es una instrucción **INPUT**. INPUT detiene el programa y espera la entrada del teclado. Lo ingresado con el teclado, en la línea 270, se almacenará en una //variable// denominada //OPCION%//. Dado que las variables juegan rol importante en la programación, debemos examinarlas en detalle.
+La línea 270 es una instrucción **INPUT**. ''INPUT'' detiene el programa y espera la entrada del teclado. Lo ingresado con el teclado, en la línea 270, se almacenará en una //variable// denominada ''OPCION%''. Dado que las variables juegan rol importante en la programación, debemos examinarlas en detalle.
 === Nombres de Variables ===
-Los nombres de variables deben crearse de acuerdo con ciertas reglas en BASIC. Por ejemplo, los nombres de variables deben comenzar con una letra del alfabeto y no puede tener más de cuarenta caracteres. El nombre puede incluir números. Estas son las reglas de BASIC, y no son muy estrictas. ¡Pero es igual de importante inventar nombres de variables que sean significativos para los seres humanos! Después de todo, BASIC funciona igual de bien con una variable llamada TKBRYIOPESFG% que con una llamada OPCION%. Pero, ¿cuál crees que sería más fácil de entender?
+Los nombres de variables deben crearse de acuerdo con ciertas reglas en BASIC. Por ejemplo, los nombres de variables deben comenzar con una letra del alfabeto y no puede tener más de cuarenta caracteres. El nombre puede incluir números. Estas son las reglas de BASIC, y no son muy estrictas. ¡Pero es igual de importante inventar nombres de variables que sean significativos para los seres humanos! Después de todo, BASIC funciona igual de bien con una variable llamada ''TKBRYIOPESFG%'' que con una llamada ''OPCION%''. Pero, ¿cuál crees que sería más fácil de entender?
-La elección de los nombres de las variables es importante ya que un programa puede tener muchas de ellas. Si usas nombres son confusos, podrías confundir accidentalmente una variable con otra. Por demás, resiste la tentación de inventar nombres de variables lindos e ingeniosos. Nombres como RENGO$ y PORDIOSERA$ son divertidos de imaginar pero difíciles para seguir. Un buen programa debe ser fácil de entender, por lo cual emplea nombres de variables obvios. NOMBRE$ no puede sonar muy épico, pero al menos es evidente qué datos incorpora.
+La elección de los nombres de las variables es importante ya que un programa puede tener muchas de ellas. Si usas nombres son confusos, podrías confundir accidentalmente una variable con otra. Por demás, resiste la tentación de inventar nombres de variables lindos e ingeniosos. Nombres como ''RENGO$'' y ''PORDIOSERA$'' son divertidos de imaginar pero difíciles para seguir. Un buen programa debe ser fácil de entender, por lo cual emplea nombres de variables obvios. ''NOMBRE$'' no puede sonar muy épico, pero al menos es evidente qué datos incorpora.
-Ciertas palabras no se pueden utilizar como nombres de variables. Estas se llaman PALABRAS RESERVADAS e incluyen todos los comandos de BASIC. Por ejemplo, sabemos que PRINT y CLS son instrucciones de BASIC. Por lo tanto, no podrás utilizarlos también como nombres de variables ya que confundirían al intérprete computarizado. La lista de palabras reservadas es bastante larga. Entre estas palabras se incluyen palabras como NAME y PRINT. Si bien no es posible duplicar exactamente estas palabras como nombres de variables, puede usar nombres que incluyan la palabra reservada, por ejemplo NAMES o PRINTER, que podrían utilizarse perfectamente.
+Ciertas palabras no se pueden utilizar como nombres de variables. Estas se llaman PALABRAS RESERVADAS e incluyen todos los comandos de BASIC. Por ejemplo, sabemos que ''PRINT'' y ''CLS'' son instrucciones de BASIC. Por lo tanto, no podrás utilizarlos también como nombres de variables ya que confundirían al intérprete computarizado. La lista de palabras reservadas es bastante larga. Entre estas palabras se incluyen palabras como ''NAME'' y ''PRINT''. Si bien no es posible duplicar exactamente estas palabras como nombres de variables, puede usar nombres que incluyan la palabra reservada, por ejemplo ''NAMES'' o ''PRINTER'', que podrían utilizarse perfectamente.
-Aunque BASIC consta de una larga lista de palabras reservadas para el idioma inglés, es probable casi ninguna sea molesta en castellano. La mayoría son declaraciones bastante extrañas que no serían muy útiles como nombres de variables. Cuando utilices una palabra reservada como nombre de variable, BASIC emitirá su inefable error de sintaxis "SYNTAX ERROR". A menudo, este tipo de errores son desconcertantes. La línea de BASIC podría parecer correcta en todos los sentidos. BASIC ni siquiera insinúa que has utilizado una palabra reservada. BASIC solo entiende que tu programa ha estipulado un comando BASIC incorrectamente. Prueba un programa con la declaración INPUT DATE$ para comprender cómo se ve este error.
+Aunque BASIC consta de una larga lista de palabras reservadas para el idioma inglés, es probable casi ninguna sea molesta en castellano. La mayoría son declaraciones bastante extrañas que no serían muy útiles como nombres de variables. Cuando utilices una palabra reservada como nombre de variable, BASIC emitirá su inefable error de sintaxis "**SYNTAX ERROR**". A menudo, este tipo de errores son desconcertantes. La línea de BASIC podría parecer correcta en todos los sentidos. BASIC ni siquiera insinúa que has utilizado una palabra reservada. BASIC solo entiende que tu programa ha estipulado un comando BASIC incorrectamente. Prueba un programa con la declaración ''INPUT DATE$'' para comprender cómo se ve este error.
 Aquí hay una lista de las reglas para tu nombre de variable:
@@ Línea 76: / Línea 87: @@
-Compara la declaración INPUT en la línea 270 con la declaración INPUT del capítulo uno. Observe los nombres de las variables utilizadas en cada programa. En el primer programa usamos el nombre QUIEN$. En la línea 270 tenemos OPCION%. Ambos nombres son variables. Sin embargo, son diferentes. QUIEN$ y OPCION% son ejemplos de dos //tipos diferentes de variables// utilizadas en BASIC.
+Compara la declaración ''INPUT'' en la línea 270 con la declaración ''INPUT'' del capítulo uno. Observe los nombres de las variables utilizadas en cada programa. En el primer programa usamos el nombre QUIEN$. En la línea 270 tenemos ''OPCION%''. Ambos nombres son variables. Sin embargo, son diferentes. ''QUIEN$'' y ''OPCION%'' son ejemplos de dos //tipos diferentes de variables// utilizadas en BASIC.
-Anteriormente definimos un nombre de variable como un casilla de correo. Disponíamos de varios tipos de buzones. Dos números de espera. El otro tiene caracteres y números. Por lo tanto, cuando se define una variable, debes decidir qué tipo de buzón será. El tipo de variable está determinado por el último carácter del nombre de la variable. Esto explica la diferencia entre QUIEN$ y OPCION%.
+Anteriormente definimos un nombre de variable como un casilla de correo. Disponíamos de varios tipos de buzones. Dos números de espera. El otro tiene caracteres y números. Por lo tanto, cuando se define una variable, debes decidir qué tipo de buzón será. El tipo de variable está determinado por el último carácter del nombre de la variable. Esto explica la diferencia entre ''QUIEN$'' y ''OPCION%''.
-Un nombre de variable terminado con signo de porcentaje (%) se denomina **variable entera**. Este tipo de variable solo puede contener números enteros. Esto significa que OPCION% solo puede contener números tales como 2, 45, 611 o 10451. No puede contener números fraccionales como 2,5 o 25,75. Por lo tanto, al programar con la instrucción INPUT OPCION%, el usuario solo podrá ingresar un número entero. Si ingresase letras, BASIC emitiría el mensaje:
+Un nombre de variable terminado con signo de porcentaje (''%'') se denomina **variable entera**. Este tipo de variable solo puede contener números enteros. Esto significa que ''OPCION%'' solo puede contener números tales como 2, 45, 611 o 10451. No puede contener números fraccionales como 2,5 o 25,75. Por lo tanto, al programar con la instrucción ''INPUT OPCION%'', el usuario solo podrá ingresar un número entero. Si ingresase letras, BASIC emitiría el mensaje:
 <code>
@@ Línea 86: / Línea 97: @@
 </code>
-...y el programa no continuaría sino hasta que ingresase números enteros. Por otro lado, si el usuario ingresa un número que no es entero, BASIC lo redondeará al entero más cercano. Por ejemplo, si se ingresa 23.6 al pedido de OPCION%, BASIC asignará 24 a dicha variable, sin emitir mensaje de error alguno. Las variables enteras no pueden contener números no mayores de 32.767 ni menores de -32.768.
+...y el programa no continuaría sino hasta que ingresase números enteros. Por otro lado, si el usuario ingresa un número que no es entero, BASIC lo redondeará al entero más cercano. Por ejemplo, si se ingresa ''23.6'' al pedido de ''OPCION%'', BASIC asignará ''24'' a dicha variable, sin emitir mensaje de error alguno. Las variables enteras no pueden contener números no mayores de ''32.767'' ni menores de ''-32.768''.
 Para explorar cómo BASIC maneja las variables enteras, intente ingresarle a la variable varios números, tanto enteros como fraccionales, así como con letras. a este sencillo programa:
-<code>
+<code freebasic>
 PRINT "Ingresa algo:"
 INPUT OPCION%
@@ Línea 96: / Línea 107: @@
 </code>
-Un segundo tipo de variable se denomina **Variable de Precisión**, y van terminadas en un signo de exclamación (!). Estas puede contener números fraccionarios como 35,9 o 3,14159, así como números enteros. Podrá contener casi cualquier valor que necesitemos en nuestros programas. Dado que la variable de precisión puede contener números enteros al igual que las variables enteras, cabría preguntarse para qué usaríamos las variables enteras... nomás para molestar. Pero existen dos razones. En primer lugar, los programas escritos con variables enteras se interpretaban más velozmente que aquellos que utilizaban variables de precisión simple. En segundo lugar, es más fácil escribir un programa que utilice unicamente números enteros. Esto se hará evidente a medida que aprendamos más sobre la programación.
+Un segundo tipo de variable se denomina **Variable de Precisión**, y van terminadas en un signo de exclamación (!). Estas puede contener números fraccionarios como ''35,9'' o ''3,14159'', así como números enteros. Podrá contener casi cualquier valor que necesitemos en nuestros programas. Dado que la variable de precisión puede contener números enteros al igual que las variables enteras, cabría preguntarse para qué usaríamos las variables enteras... nomás para molestar. Pero existen dos razones. En primer lugar, los programas escritos con variables enteras se interpretaban más velozmente que aquellos que utilizaban variables de precisión simple. En segundo lugar, es más fácil escribir un programa que utilice unicamente números enteros. Esto se hará evidente a medida que aprendamos más sobre la programación.
 > Sigue esta regla: usa variables enteras toda vez que puedas. Usa variables de precisión sólo cuando debas.
-El último tipo de variable que exploraremos es la **Variable de Cadena** (STRING). El nombre de una variable de cadena termina con un signo peso ($). QUIÉN$ es una variable de cadena. Estas variables de cadena contienen caracteres en lugar de números. Una sola variable de cadena puede contener hasta 255 caracteres. Estos caracteres pueden ser cualquiera de caracteres alfanuméricos, incluidos espacios y números (sin incluir letras acentuadas ni eñes).
+El último tipo de variable que exploraremos es la **Variable de Cadena** (STRING). El nombre de una variable de cadena termina con un signo peso (''$''). ''QUIÉN$'' es una variable de cadena. Estas variables de cadena contienen caracteres en lugar de números. Una sola variable de cadena puede contener hasta 255 caracteres. Estos caracteres pueden ser cualquiera de caracteres alfanuméricos, incluidos espacios y números (sin incluir letras acentuadas ni eñes).
 He aquí una pequeña posibilidad de confusión que debes atender.
-Las cifras, no los números, pueden ser caracteres. Considera la diferencia entre numerales y números. El número romano V, la palabra cinco y el número 5 representan el mismo número. Sólo se diferencian en la manaera de escribirlo. Cada vez que almacenas un número como una variable de cadena, será solo un NOMBRE para un número. Esto será importante al hacer aritmética con variables. Podrías tomar dos variables enteras, por ejemplo, y sumarlas. Si intentases esto con variables de cadena, BASIC emitirá un mensaje de error. BASIC está imposibilitado de hacer aritmética con variables de cadena incluso si estas variables contienen nombres de números.
+Los caracteres pueden ser cifras, no numéricas. Considera la diferencia entre numerales y números. El numeral romano ''V'', la palabra ''cinco'' y el número ''5'' representan el mismo número. Sólo se diferencian en la manara de escribirlo. Cada vez que almacenas un //número// como una //variable de cadena//, __será solo un //NOMBRE//__ para dicho número. Esto será importante al hacer aritmética con variables. Podrías tomar dos variables enteras, por ejemplo, y sumarlas. Si intentases esto con variables de cadena, BASIC emitirá un mensaje de error. BASIC está imposibilitado de hacer aritmética con variables de cadena incluso si estas variables contienen nombres de números.
 Suena más complicado de lo que es en realidad.
@@ Línea 110: / Línea 121: @@
 > Recuerda: si necesita una variable que contenga caracteres, use una variable de cadena. Si, en cambio, necesita realizar un cálculo, usa un número entero o una sola variable de precisión.
-=== Ejemplos de Variables ===
-Study these example of variables to check your understanding.
-Name 	Contents 	Description
-Team1$ 	Hokies 	Horrect.
-DATE$ 	  	Incorrect. DATE$ is a reserved word.
-NUMBER% 	123 	Correct.
-STREET% 	10 downing 	incorrect. Integer variables can only contain a number.
-STREET$ 	10 Downing 	correct
-STPLACE$ 	  	Incorrect. Variable names must begin with a letter.
-COUNT% 	45321 	Incorrect. Numbers larger than 32,767 cannot be held in an integer variable.
-GASLEFT! 	855.66 	Correct.
-TONE% 	600.8 	BASIC will round TONE% to 601.
-WHO$ 	Elmer P. Fudd 	Correct.
 ===== IF - THEN - ELSE =====
-At line 280 we finally arrive at the real power of programming: the ability to make decisions. BASIC uses the IF-THEN-ELSE statement to make choices, and even change the way the program runs depending on certain conditions. Since the result depends on conditions, the IF statement is called a conditional instruction. Contrast line 280 with all the lines that are listed before it. In every case, BASIC will carry out whatever the instruction asks. But at line 280, BASIC is testing our integer variable CHOICE% to see if it holds the number two. If it does, one result happens. If it does not, another action is taken.
+En la línea 280 llegamos finalmente al verdadero poder de la programación: la capacidad de tomar decisiones. BASIC usa la declaración ''IF''-''THEN''-''ELSE'' para tomar decisiones e incluso cambiar la forma en que se ejecuta el programa dependiendo de ciertas condiciones. Como el resultado depende de las condiciones, la instrucción ''IF'' se denomina //instrucción condicional//. Observa la línea 280 y compárala con las líneas que se enumeradas anteriormente. En todos los casos, BASIC ejecutará lo ordenado por la instrucción. Pero al dar con la línea 280, BASIC evaluará la variable entera ''OPCION%'' para determinar si contiene el número dos. Si la tiene, ocurrirá un resultado. Si no es así, realizará otra acción.
-The IF statement has three parts:
+La declaración ''IF'' consta de tres partes:
-IF condition THEN alternative 1 ELSE alternative 2
+<code freebasic>
+IF condición THEN alternativa1 ELSE alteranativa2
+</code>
-The three parts are the condition, alternative 1, and alternative 2. The condition is some relationship that BASIC tests to see if it is true. On line 280, the conditional test is whether CHOICE% equals 2. Alternative 1 and alternative 2 are the two choices BASIC can make. If the condition is true, then alternative 1 is executed. If the condition is not true, then alternative 2 is executed. In other words, if the person running our STORY program enters a 2 in response to line 270, then the condition is true, and GOTO 600 is executed (Don't worry about what GOTO means, we'll cover it soon). If the person enters anything other than a 2, GOTO 300 is executed.
+Las tres partes son la //condición//, la //alternativa1// y la //alternativa2//. La condición es una relación que BASIC evalúa para determinar su validez. En la línea 280, la evaluación condicional delimita si ''OPCION%'' es igual a ''2''. La //alternativa1// y la //alternativa2// son las dos opciones que BASIC puede correr. Si la condición es verdadera, entonces ejecutará la //alternativa1//. Si la condición no es verdadera, entonces se ejecuta la //alternativa2//. En otras palabras, si el usuario de nuestro programa HISTORIA ingresa ''2'' como respuesta a la línea 270, entonces la condición será verdadera y se ejecuta ''GOTO 600'' para ir a la línea 600. Si la persona ingresa algo que no sea un ''2'', se ejecutará GOTO 300.
-The two alternatives listed inside of the IF statement can be any ordinary BASIC commands. In this case, both are GOTO statements. They could just as readily be PRINT or CLS commands. For example:
+Ambas //alternativas// enumeradas dentro de la declaración ''IF'' podrían ser cualquier comando BASIC ordinario. En este caso, ambas son instrucciones ''GOTO''. Podrían ser fácilmente comandos ''PRINT'' o ''CLS''. Por ejemplo:
-<code>
-IF CHOICE% = 2 THEN CLS ELSE PRINT "Hey Cool"
-</code>
-In our example, CHOICE% is a integer variable. Other variable types may also be used. We could change CHOICE% to CHOICE! and still see if it equalled 2. String variables can likewise be tested.
+<code freebasic>
+IF OPCION% = 2 THEN CLS ELSE PRINT "Ok! Perfecto!"
-<code>
-IF WHO$ = "Brian" THEN PRINT "Hi" ELSE PRINT "Who are you?"
 </code>
-Notice that the character string Brian is enclosed in quotation marks. Remember our discussion of the PRINT statement from chapter one. Quotation marks tell BASIC to use the characters exactly as we have written them. If Brian were not in quotation marks, BASIC would try to use it as a variable name. When the program runs, the person at the keyboard does not have to enter quotation marks.
+En nuestro ejemplo, ''OPCION%'' es una variable entera. También es posible utilizar los otros tipos de variables. ¡Podríamos cambiar ''OPCION%'' a ''OPCION''! y todavía ver si es igual a ''2''. También podríamos probar las variables de cadena.
-One further note about testing string variables: computers are dumb. They only do exactly what you tell them to do. If you ran the above line of BASIC and entered brian or BRIAN, the program would print
-<code>
+<code freebasic>
-Who are you?
+IF QUIEN$ = "Laura" THEN PRINT "Hola" ELSE PRINT "Quien eres tu?"
 </code>
-BRIAN is not the same as Brian. A character string inside of quotation marks must EXACTLY match the contents of the variable. The letters, capitalization, even the number of blank spaces, if any, must exactly match. This can be very challenging to a programmer.
+Observa que la cadena de caracteres ''Laura'' está entre comillas. Las comillas instruyen a BASIC que use los caracteres exactamente tal como los has escrito. Si ''Laura'' no estuviera entre comillas, BASIC intentaría usarla como un //nombre de variable//. Al ejecutar el programa, la persona en el teclado no debe que ingresar comillas.
+> las computadoras solo cumplen exactamente lo que les instruye que hagan.
-The last part of the IF-THEN-ELSE statement is not always required. The ELSE may be omitted along with the second alternative. This would leave us with an IF-THEN command. We could write line 280 as:
+Si corres la línea anterior de BASIC e ingresas ''laura'' o ''LAURA'' en lugar de ''Laura'' ¡el programa no sabría quién eres e indicaría:
 <code>
-IF CHOICE% = 2 THEN GOTO 600
+Quien eres tu?
 </code>
-If CHOICE% does not equal two, then the first alternative would not be executed. Instead, BASIC would continue with the next line after 280. If that line happened to be line 300 the two IF statements would produce the same result! Thus, every IF statement has an ELSE even if the ELSE is not written as part of the instruction.
+Para el intérprete de BASIC, ''LAURA'' no es lo mismo que ''Laura''. Una variable de cadena entrecomilladas indica que debe cumplirse __exactamente tal cual__ el contenido proporcionado de la variable: deben ser iguales todas las letras, las mayúsculas, y la cantidad de eventuales espacios en caso que los hubiese. Esto puede ser desafiante para los programadores.
-In all of our examples so far, we have tested to see if a variable is equal to some value. Other tests can be used. We can use all of the ordinary arithmetic comparisons such as greater than, less than, or not equal. Here is how these OPERATORS, as they are called, are written:
+La última parte de la instrucción ''IF''-''THEN''-''ELSE'' no siempre es necesaria. El ''ELSE'' puede omitirse junto con la segunda alternativa. Esto nos dejaría con un tren de instrucciones mucho más sencillo: ''IF''-''THEN''. Podrías escribir la línea 280 como:
-=	equal to
+<code freebasic>
+IF OPCION% = 2 THEN GOTO 600
+</code>
-<	less than
+Si ''OPCION%'' no es igual a ''2'', entonces no se ejecutaría //alternativa1//. En cambio, BASIC continuaría con la siguiente línea después de la 280. Si esa línea fuese la línea 300, ¡las dos declaraciones ''IF'' producirían el mismo resultado! Por lo tanto, cada declaración ''IF'' tiene un ''ELSE'' incluso si ''ELSE'' forma parte de la instrucción.
->	greater than
+En todos nuestros ejemplos hasta ahora, hemos probado para ver si una variable es igual a algún valor. Podrás utilizar otras comprobaciones. Usar todas las comparaciones aritméticas ordinarias, incluyendo //mayor que//, //menor que// o //no igual//. Estos **operadores** se escriben de la siguiente manera:
-<=	less than or equal to
+<code>
+=	Igual a
+<	Menor que
+>	Mayor que
+<=	Igual o menor que
+=>	Igual o Mayor que
+<>	No igual a
+</code>
-=>	greater than or equal to
+Con la excepción del último, todos los operadores deberías estar familiarizado con estos operadores. Al utilizar operadores en BASIC los operadores que constan de más de un  (como''=>'') deben escribirse sin espacio entre los dos caracteres. He aquí algunos ejemplos de declaraciones ''IF''-''THEN''. Revise cada una para verificar su comprensión.
-<>	not equal to
-With the exception of the last, these operators should be familiar. When used in a BASIC program, the operators that have more than one character, such as =>, are written without a space between the two characters. Here are some sample IF-THEN statements.Review each one to check your understanding.
+<code freebasic>
+IF OPCION% = 2 THEN GOTO 600 ELSE GOTO 300
-<code basic>
+IF OPCION% <> 2 THEN GOTO 300 ELSE GOTO 600
-IF CHOICE% = 2 THEN GOTO 600 ELSE GOTO 300
+IF ADIVINADO% = NUMERO% THEN GOTO 140
-IF CHOICE% <> 2 THEN GOTO 300 ELSE GOTO 600
+IF ADIVINADO% > NUMERO% THEN PRINT "Muy alto"
-IF GUESS% = NUMBER% THEN GOTO 140
+IF ADIVINADO% < NUMERO% THEN PRINT "Muy bajo"
-IF GUESS% > NUMBER% THEN PRINT "Too High"
-IF GUESS% < NUMBER% THEN PRINT "Too Low"
 IF SUB! <= 0 THEN GOTO 500
 IF SUB! => 4 THEN GOTO 500
-IF ANSWER$ = "y" THEN ANSWER$ = "Y"
+IF RESPUESTA$ = "s" THEN RESPUESTA$ = "S"
-IF QUANTITY% - SUB% < 1 THEN GOTO 600
+IF CANTIDAD% - SUB% < 1 THEN GOTO 600
-IF X% = 2 THEN TWOS% = TWOS% + 1
+IF X% = 2 THEN DOS% = DOS% + 1
 </code>
-These statements are not a real program. Don't bother to enter them on your computer. They are for examples, only. Let's discuss some. Line 290 above is a different way of writing line 280 in our STORY program. Note that it has exactly the same effect. Compare the two lines.
+Estas instrucciones no constituyen un programa real. No te molestes en ingresarlos en el [[interpretes_de_basic|intérprete de BASIC]]. Solo son ejemplos. Hablemos de algunos. La línea 290 anterior es una forma distinta de escribir la línea 280 del programa HISTORIA. Ten en cuenta que producirá exactamente el mismo efecto. Compara ambas.
-In line 300, we compare two variables! Also, note that line 300 does not use an ELSE command. Line 300, and the rest of the examples, are simple IF-THEN statements. Line 310 asks if the number contained in GUESS% is greater than the number contained in NUMBER%. Line 320 tests if GUESS% is less than NUMBER%.
+¡En la línea 300, comparamos dos variables! Además, ten en cuenta que la línea 300 no usa una instrucción ''ELSE''. La línea 300 y el resto de los ejemplos resultan ser declaraciones simples de ''IF''-''THEN''. La línea 310 preguntará si el número contenido en ''ADIVINA%'' es mayor que el número contenido en ''NUMERO%''. La línea 320 prueba si ''ADIVINA%'' es menor que ''NUMERO%''.
-Lines 330 and 340 use less than or equal to and greater than or equal to.
+Las líneas 330 y 340 usan menor o igual que y mayor o igual que.
-Line 350 is interesting. This checks what is held inside string variable ANSWER$. If it is a lower case "y" then the program changes it to an upper case "Y" inside the variable. Remember that the condition is tested first, and then, only if true, will alternative 1 be executed. This is why the same variable name, ANSWER$, can be used in the conditional test and then changed in the alternative.
+La línea 350 es interesante. Esto verifica lo que se contiene dentro de la variable de cadena ''RESPUESTA$''. Si es una "''s''" minúscula, el programa la cambia a una "''S''" mayúscula dentro de la variable. Recuerde que primero se prueba la condición y luego, solo si es verdadera, se ejecutará la //alternativa1//. Esta es la razón por la cual el mismo nombre de variable, ''RESPUESTA$'', puede usarse en la prueba condicional y luego cambiarse en la alternativa.
-Line 360 is an advanced example. BASIC subtracts SUB% from QUANTITY% and then checks to see if this number is less than one. We will explore arithmetic more later. Just consider this example as one of the more powerful uses of the IF-THEN statement.
+la Linea 360 es un ejemplo avanzado. BASIC resta SUB% de CANTIDAD% y luego verifica si este número es menor a ''1''. Solo considere este ejemplo como uno de los usos más poderosos de la instrucción ''IF''-''THEN''.
-GOTO
-When we first looked at the IF-THEN-ELSE statement in line 280 of our STORY program, we saw that both alternative 1 and alternative 2 used GOTO statements. Now it is time to discuss GOTO.
+==== GOTO ====
-Fortunately, GOTO is much simpler than IF-THEN-ELSE. When running a program, the BASIC interpreter usually executes statements in line number order. However, when a GOTO is discovered, execution BRANCHES to whatever line number is written as part of the GOTO statement. Line 280 contains two GOTO commands.
+Cuando observamos por primera vez la sentencia ''IF''-''THEN''-''ELSE'' en la línea 280 de nuestro programa HISTORIA, vimos que tanto la //alternativa1// como la //alternativa2// usaban sentencias GOTO.
-<code basic>
+Afortunadamente, ''GOTO'' es mucho más simple que ''IF''-''THEN''-''ELSE''. Cuando se ejecuta un programa, el intérprete BASIC generalmente ejecuta declaraciones en orden de número de línea recibido. Sin embargo, cuando se descubre un ''GOTO'', la ejecución se desplazará a cualquier número de línea que esté escrito como predicado de la instrucción ''GOTO''. La línea 280 contiene dos comandos ''GOTO''.
-IF CHOICE% = 2 THEN GOTO 600 ELSE GOTO 300
+<code freebasic>
+IF OPCION% = 2 THEN GOTO 600 ELSE GOTO 300
 </code>
-If CHOICE% is 2 then the next line to execute is line 600. If CHOICE% is not 2, then the next line to execute is line 300.
+Si ''OPCION%'' es ''2'', la siguiente línea a ejecutar será la línea 600. Si ''OPCION%'' no es ''2'', la siguiente línea a ejecutar será la línea 300.
-The GOTO command is useful inside of an IF-THEN statement. It can also be used by itself. To fully understand how this statement works, experiment with the following program:
+El comando ''GOTO'' cobra gran utilidad dentro de una instrucción ''IF''-''THEN''. También se puede usar un solo ''GOTO''. Para comprender cómo funciona esta declaración, experimenta con el siguiente programa:
-<code basic>
+<code freebasic>
-PRINT "This is line 10"
+PRINT "Esta es la línea 10"
 GOTO 50
-PRINT "This is line 30"
+PRINT "Esta es la línea 30"
 GOTO 70
-PRINT "This is line 50"
+PRINT "Esta es la línea 50"
 GOTO 30
 END
 </code>
-GOTO provides the ability to skip around in a program. When our little program runs, it will execute the lines in this order:
+> GOTO te da la posibilidad de trampolinear dentro del programa.
-<code>
+Cuando el programita corra, se ejecutará siguiendo este orden:
-PRINT "This is line 10"
+<code freebasic>
+PRINT "Esta es la linea 10"
 GOTO 50
-PRINT "This is line 50"
+PRINT "Esta es la linea 50"
 GOTO 30
-PRINT "Esto es la línea 30"
+PRINT "Esta es la línea 30"
 GOTO 70
 END
 </code>
-If you made a mistake in entering this program, you may have discovered something called a LOOP. A loop occurs when the program does not end. Examine this program:
+Si has cometido un error al ingresar este programa, es posible que haya dado con algo llamado **bucle** ("loop"). Se produce un bucle cuando el programa no termina nunca. Examina este programa:
-PRINT "Esto es la línea 10"
+<code freebasic>
+PRINT "Hola Humanoide!"
 GOTO 10
+</code>
-Line 10 will be executed over and over. Indeed, you must press the CTRL-Break key to end the program. In this example, the cause of the loop is clear. Line 20 asks BASIC to execute line 10. Then BASIC executes line 20 again. BASIC does not know that it already executed line 20. Remember, your computer will only do exactly what you tell it to do.
+La línea 10 se ejecutará una y otra vez. De hecho, debe presionar las teclas **CTRL-c** para interrumpir la interpretación y ejecución del programa. En este ejemplo, el motivo del bucle es evidente. La línea 20 le pide a BASIC que ejecute la línea 10. Luego, BASIC ejecuta la línea 20 nuevamente. BASIC no sabe que ya ejecutó la línea 20. Recuerda: "El ordenador cumplirá las órdenes que le han dado". ¡Asegúrate de correr tu propio código!. Usa software libre.
-Unfortunately, the cause of loops is not always as clear as in this last example. In long programs, many GOTO statements might be used and it is difficult to see exactly how a loop was created. For this reason, try to avoid using GOTO. Think carefully about your program and plan it so that a GOTO is used only when necessary. A program using many GOTOs is called SPAGHETTI CODE. Understanding spaghetti code is like following a noodle in a plate of spaghetti.
+Desafortunadamente, la causa de los bucles no siempre es tan evidente como en este último ejemplo. Es común usar muchas secuencias ''GOTO'' en programas largos, y esto puede hacer difícil ver el sentido del bucle. Por este motivo, trate de evitar el uso de ''GOTO''. Piensa detenidamente en tu programa y planifícalo de manera que se use un ''GOTO'' solo cuando es absolutamente necesario.
-===== PROGRAM LOGIC =====
+> Los programas que utilizaban muchas instrucciones ''GOTO'' recibían el apodo de CÓDIGO ESPAGUETI. ¡Dilucidar código espagueti era como seguir un fideo en un plato!
+===== Lógica del Programa =====
-With the IF-THEN and GOTO statements, we introduced the ability to make decisions and change direction. These are powerful capabilities. We know that, although the computer is going to run one line after another, these statements may not necessarily run in line number order. Because of this we must spend some effort thinking about the LOGIC of our programs. This is the part where clear thinking is needed.
+Con las declaraciones ''IF''-''THEN'' y ''GOTO'', introdujimos la capacidad de tomar decisiones y saltar a distintos sectores del programa BASIC. ¡Son capacidades poderosas!. Aunque el ordenador ejecute una línea tras otra, sabemos entonces que es muy posible las estas declaraciones no necesariamente se ejecuten en el orden estipulado por número de línea. Por tal motivo debes esforzarte en pensar en la __lógica de los programas__. Esta es la parte donde se requiere un pensamiento preclaro.
-Consider line 280 once again:
+Considere la línea 280 una vez más:
-<code basic>
+<code freebasic>
-IF CHOICE% = 2 THEN GOTO 600 ELSE GOTO 300
+IF OPCION% = 2 THEN GOTO 600 ELSE GOTO 300
 </code>
-In our PRINT statements in lines 200 and 210, we asked the person running STORY to enter a 1 or a 2. But in line 280 we only check to see if they entered a 2. Why?
+En las instrucciones ''PRINT'' de las líneas 200 y 210, le pedimos al usuario de HISTORIA que ingrese un 1 o un 2. Pero en la línea 280 solo verificamos si ingresaron un 2. ¿Por qué sucede esto?
-The reason: you cannot trust humans! Just because we asked for a 1 or 2 does not mean people will enter a 1 or 2. What if they enter zero or three? We are protected, however, because we built our program to handle any reply. In this case, choice 1 is the default choice. If they just press ENTER, or enter any number other than 2, they will GOTO 300. A default is what happens when someone does not make a decision.
+La razón es simple ¡Rebeldía humana! El hecho de que hayas pedido un 1 o un 2 no significa que alguien vayan a ingresar necesariamente un ''1'' o un ''2''. ¿Qué sucedería si ingresa un cero o un tres? ¿O un insulto enjundioso? Sin embargo, estamos protegidos porque construimos nuestro programa para manejar cualquier respuesta. En este caso, la respuesta 1 es la opción predeterminada. Si simplemente presionan la **tecla Intro**, o ingresan cualquier número que no sea 2, se desplazará a la línea 300. El valor predeterminado es lo que sucede cuando el usuario no toma una decisión.
-When you write your IF-THEN and GOTO statements, always plan for any input. Don't trust humans. If you ask for a 1, 2, or 3, you can be sure that someone will try a 4. If you do not want to plan for a default choice, you might write an IF-THEN statement that traps the bad choices and simply asks the question again. We could, for example, write:
+Cuando escribas tus declaraciones ''IF''-''THEN'' y ''GOTO'', siempre planifica para recibir cualquier entrada. Imagina lo peor y desconfía de los humanos. Si pide un ''1'', ''2'' o ''3'', puedes estar seguro de que alguien probará introducir un ''4''. Si no desea planificar una opción predeterminada, podrías escribir una declaración ''IF''-''THEN'' que intercepte las respuestas indeseadas a ''OPCION%'' y simplemente vuelva a interrogar nuevamente. Podríamos, por ejemplo, escribir:
-<code>
-IF CHOICE% = 2 THEN GOTO 600
+<code freebasic>
-IF CHOICE% = 1 THEN GOTO 300
+IF OPCION% = 2 THEN GOTO 600
-IF CHOICE% < 1 THEN GOTO 50
+IF OPCION% = 1 THEN GOTO 300
-IF CHOICE% >> 2 THEN GOTO 50
+IF OPCION% < 1 THEN GOTO 50
+IF OPCION% >> 2 THEN GOTO 50
 </code>
-There is nothing wrong with using these lines in our STORY program. It is a matter of taste. The original line 280 handles all possible replies in only one line of BASIC code. The above solution uses four lines and the purpose is not as clear. Nevertheless, do what you think is best. Keep in mind our goal of writing understandable programs.
+No hay nada de malo en usar estas líneas adicionales en el programa HISTORIA. Es cuestión de gustos. La línea original 280 gestiona todas las respuestas posibles usando una única línea de código BASIC. La solución anterior usa cuatro líneas su propósito no resulta tan claro como el original. Sin embargo, puedes hacer tu voluntad.
-When planning programs you not only have to watch out for humans, you must also think like a computer. Just as we saw in the loop, your computer is going to do what you tell it to do. This may not be what you want it to do! As a human, it is easy to see that "Leonardo" is practically the same as "leonardo." But the computer is not practical.
+> Ten en cuenta las [[reglas_de_diseno_unix|reglas de diseño Unix]]. Escribir programas comprensibles.
-Consider this example:
+Al planificar tus programas, no solo debe tener cuidado con los humanos, sino que también debe pensar como una computadora. Tal como has visto, tu ordenador hará lo que le digan que haga. ¡Créeme! Normalmente no será esto lo que quieres que haga! Como humano, es fácil entender que "''Leonardo''" es prácticamente lo mismo que "''leonardo''". Pero la computadora no es práctica.
-<code basic>
+Considere este ejemplo:
-IF CHOICE% < 1 THEN GOTO 500
-IF CHOICE% > 1 THEN GOTO 700
+<code freebasic>
+IF OPCION% < 1 THEN GOTO 500
+IF OPCION% > 1 THEN GOTO 700
 </code>
-We might believe we are checking to see if someone is cheating on an INPUT statement. But what happens if someone enters a 1? Is the computer doing what we asked? Certainly. Is it doing what we want? That depends. Whenever your program misbehaves, it might help to carefully review each statement IN ORDER OF EXECUTION. On a note pad, write down the names of the variables and keep track of what they should hold as you run the program step-by-step in your imagination.
+Podríamos creer que estamos comprobando si alguien está haciendo trampa en una instrucción ''INPUT''. Pero, ¿qué sucedería si alguien ingresa un ''1''? ¿La computadora está haciendo lo que le pedimos? Ciertamente. ¿Está haciendo lo que deseamos? Ahora no es tan clara la respuesta... ¡Depende!.
+Cada vez que tu programa se comporte mal, podría ser útil revisar cuidadosamente cada declaración __siguiendo su orden de ejecución__.
+> Se utilizaba tabular los nombres de las variables en un bloc de notas y realizar un seguimiento de lo que debían contener mientras ejecuta el programa paso a paso. A esto se llamaba "ejecución in mente".
-===== THE REST OF THE PROGRAM =====
+===== El resto del programa =====
+Este tutorial comenzó con la promesa de un programa que contaría una historia y te permitiría crear tu propio final. Ahora que has explorado estos comandos BASIC utilizados en las primeras veintiocho líneas, es hora de ingresar al resto del programa.
-This chapter began with the promise of a program that would tell a story and allow you to create your own ending. Now that we have explored the new BASIC commands used in the first twenty eight lines, it is time to enter the rest of the program.
+Al ingresarlo, intente escribir una historia simplona. Observe que muchas líneas son idénticas o muy parecidas. Por ejemplo, las líneas 60, 260, 320 y 520 son iguales. Después de presionar Intro para ingresar en línea 60, simplemente movías el cursor hacia arriba, cambiabas el número de línea y presionabas Intro de nuevo. Se utiliza el comando **LIST** para comprobar el listado.
-As you enter this program, try to type as little as possible. Notice that many lines are either identical or very much alike. For example, lines 60, 260, 320, and 520 are the same. After you press ENTER for line 60, just move the cursor up, change the line number, and press ENTER again. Use LIST to check your progress.
-<code basic>
+<code freebasic>
 REM *****  PANTALLA 1A  *****
 CLS
@@ Línea 309: / Línea 321: @@
 PRINT "*                                                        *"
 PRINT "*                                                        *"
-PRINT "*       Choose one:                                      *"
+PRINT "*       Elije otro:                                      *"
 PRINT "*                                                        *"
-PRINT "*         1 - if you want to go down one path            *"
+PRINT "*         1 - Quiero seguir un destino                   *"
-PRINT "*         2 - if you want to go another way              *"
+PRINT "*         2 - Quiero buscar otro destino                 *"
 PRINT "*                                                        *"
 PRINT "*                                                        *"
@@ Línea 318: / Línea 330: @@
 PRINT "*                                                        *"
 PRINT "**********************************************************"
-INPUT CHOICE%
+INPUT OPCION%
-IF CHOICE% = 2 THEN GOTO 900 ELSE GOTO 1200
+IF OPCION% = 2 THEN GOTO 900 ELSE GOTO 1200
 REM *****  PANTALLA 1B  *****
 CLS
@@ Línea 334: / Línea 346: @@
 PRINT "*                                                        *"
 PRINT "*                                                        *"
-PRINT "*       Choose one:                                      *"
+PRINT "*       Elije otro mas:                                  *"
 PRINT "*                                                        *"
-PRINT "*         1 - if you want to go down one path            *"
+PRINT "*         1 - Quiero seguir un destino                   *"
-PRINT "*         2 - if you want to go another way              *"
+PRINT "*         2 - Quiero buscar otro destino                 *"
 PRINT "*                                                        *"
 PRINT "*                                                        *"
@@ Línea 343: / Línea 355: @@
 PRINT "*                                                        *"
 PRINT "**********************************************************"
-INPUT CHOICE%
+INPUT OPCION%
-IF CHOICE% = 2 THEN GOTO 1500 ELSE GOTO 1800
+IF OPCION% = 2 THEN GOTO 1500 ELSE GOTO 1800
 END
 END
@@ Línea 351: / Línea 363: @@
 </code>
-At long last, we get to see where the GOTO 300 and GOTO 600 statements will take us. Check each IF-THEN and GOTO to insure you understand how the program works. A diagram of the branches might be useful. Note that the last four lines of the program introduce a new BASIC statement. That is END. Its purpose is obvious. Whenever BASIC discovers an END statement, it stops running the program. This happens even if the END is found in the middle of a program.
+Por fin, podemos ver a dónde nos llevarán las declaraciones GOTO 300 y GOTO 600. Marca cada ''IF''-''THEN'' y ''GOTO'' para asegurarse de que comprendes cómo funciona el programa. Podría ser útil Un diagrama arbolado. Ten en cuenta que las últimas cuatro líneas del programa introducen una nueva instrucción BASIC. Se trata de **END**. Su propósito es obvio, dar por finalizado el programa. Cada vez que BASIC llega a una instrucción ''END'', deja de correrlo. Esto sucede incluso si encuentra ''END'' en medio de un programa.
+Este programa muestra una pantalla que inicia la historia y tiene otras dos como opciones. De estas otras dos se podría ramificar a otras cuatro. Sin embargo, en lugar de enumerar un programa con muchas casillas vacías, podrás terminarlo por tu cuenta. Crea cuadros de historias adicionales que comiencen en las líneas 900, 1200, 1500 y 1800. Inventa tantos como necesites. Siéntete libre de completar una historia real en los recuadros. Simplemente realiza un listado de cada //caja de flores// (introduciendo el comando **LIST 320-520**, por ejemplo) y complétalo con tu historia. Recuerda presionar la **tecla Intro** después de cada línea.
+Finalmente, dado que este programa representa mucho trabajo duro, asegúrese de gauardarlo en un archivo de disco antes de ingresar al SISTEMA.
+===== Conclusión =====
-This program displays one screen that starts the story and has two others as choices. From these others you could branch to another four. However, instead of listing a program with many empty boxes, I will let you finish it. Create additional story boxes that begin at lines 900, 1200, 1500, and 1800. Use as many as you need. Feel free to fill in a real story in the boxes. Just list each flower box (LIST 320 - 520, for example) and type in a story. Remember to press ENTER after each line.
+En este tutorial aprendimos sobre las variables y las instrucciones BASIC REM, ''IF''-''THEN''-''ELSE'', ''GOTO'' y ''END''. Con estos comandos, descubrimos cómo hacer elecciones en los programas y cómo desplazar el puntero de ejecución dentro del programa. También comimos algunos fideos (de código).
-Finally, since this program represents a lot of hard work, be sure to SAVE it in a disk file before you enter SYSTEM. Also, if you have a printer, you may want to use the LLIST command to print out a copy on paper.
+>¡Comparte tu ''[[historia.bas]]'' con el resto de la comunidad!
-In this tutorial we learned about variables and the BASIC REM, IF-THEN-ELSE, GOTO, and END statements. With these commands, we discovered how to make choices in programs and how to move execution around inside of a program. We also had some spaghetti (code, that is). The next chapter is just plain fun; it will be a reward for this effort.