Diferencias

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

--- tutorial_de_aventuras_en_basic [2022/01/25 18:10] – creado 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 41: / Línea 53: @@
 </code>
-===== REMARKS =====
+===== 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.
-Observe 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 ===
+=== 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 tiene una larga lista de palabras reservadas, es probable que solo unas pocas sean molestas. La mayoría son declaraciones bastante extrañas que no serían muy útiles como nombres de variables. Asegúrese de revisar el apéndice. Cuando se utiliza una palabra reservada como nombre de variable, BASIC emitirá un mensaje de error de sintaxis. A menudo, este tipo de errores son desconcertantes. La línea de BASIC parece correcta en todos los aspectos. BASIC ni siquiera insinúa que haya usado una palabra reservada. BASIC solo sabe que su programa ha usado un comando BASIC incorrectamente. Pruebe un programa con la declaración INPUT DATE$ para ver 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 nombrar variables:
+Aquí hay una lista de las reglas para tu nombre de variable:
+  *     No uses mas de 40 caracteres.
+  *     El nombre de variable debe comenzar con una letra.
+  *     El nombre de variable puede contener letras y números.
+  *     Un nombre de variable no puede contener espacios.
+  *     El nombre no puede ser un comando de BASIC.
-  *     Use no more than 40 character.
+=== Tipos de Variable ===
-  *     The variable name must start with a letter of the alphabet.
-  *     The name may contain both letters and numbers.
-  *     A variable name may not contain blank spaces.
-  *     The name cannot be a reserved word.
-=== VARIABLE TYPES ===
+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.
-Compare the INPUT statement on line 270 with the INPUT statement from chapter one. Notice the variable names used in each program. In the first program we used the name WHO$. On line 270 we have CHOICE%. Both of these names are variables. However, they are different. WHO$ and CHOICE% are examples of two of the different TYPES of variables used in 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%''.
-Earlier we defined a variable name as a mailbox. We have several kinds of mailboxes. Two hold numbers. The other holds characters and numerals. Thus, when a variable is defined, you must decide which kind of mailbox it will be. The variable type is determined by the last character of the variable name. This explains the difference between WHO$ and CHOICE%.
+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:
-A variable name which ends with a percent sign (%) is called an INTEGER variable. This type of variable may only hold whole numbers. This means that CHOICE% may only contain numbers such as 2, 45, 611, or 10451. It cannot hold fractional numbers such as 2.5 or 25.75. Thus, when you write INPUT CHOICE%, the person using the program should only enter a whole number. If letters are entered, BASIC will issue the message:
 <code>
@@ Línea 87: / Línea 97: @@
 </code>
-and the program will not continue until they enter numbers. On the other hand, if a person enters a number, but the number is not a whole number, BASIC will round it to the nearest whole number. For example, if 23.6 is entered for INPUT CHOICE%, BASIC will put 24 into the variable. No error message is issued. Integer variables may hold numbers no larger than 32,767, and no smaller than -32,768. To explore how BASIC handles integer variables, try replying with several numbers, whole and fractional, as well as letters in response to this simple program:
+...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''.
-<code>
+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:
-PRINT "Enter something"
-INPUT CHOICE%
+<code freebasic>
-PRINT CHOICE%
+PRINT "Ingresa algo:"
+INPUT OPCION%
+PRINT OPCION%
 </code>
-A variable name which ends with an exclamation point (!) can hold fractional numbers such as 35.9 or 3.14159, as well as whole numbers. This type of variable is called a SINGLE PRECISION variable. It can hold most any value that we will need in our programs. Since a single precision variable may contain whole numbers the same way as integer variables, you might wonder why integer variables would be useful. There are two reasons. First, programs written using integer variables run somewhat faster than those using single precision variables. Secondly, and more importantly, it is easier to write a program that uses only whole numbers. This will become apparent as we learn more about programming.
+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.
-> Here is a good rule of thumb: use integer variables whenever possible.
+> Sigue esta regla: usa variables enteras toda vez que puedas. Usa variables de precisión sólo cuando debas.
-The final type of variable that we will explore is the STRING variable. A string variable name ends with a dollar sign ($). WHO$ is a string variable. String variables hold characters rather than numbers. A single string variable can hold up to 255 characters. These characters can be anything on your keyboard, including spaces and numerals. Here is a chance for confusion.
+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).
-Numerals, not numbers, may be characters. Consider the difference between numerals and numbers. The Roman numeral V, the word five, and the numeral 5, all represent the same number. Each is just a different way of writing. Whenever a numeral is stored in a string variable, it is just a NAME for a number. This becomes important when we learn how to do arithmetic with variables. We may take two integer variables, for example, and add them together. If we try this with string variables, BASIC issues an error message. BASIC cannot do arithmetic with string variables even if these variables hold numerals that look like numbers.
+He aquí una pequeña posibilidad de confusión que debes atender.
-This sounds more complicated than it is. Just remember, if you need a variable to hold characters, use a string variable. If, instead, you need to perform a calculation, use either an integer or a single precision variable.
+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.
-EXAMPLES OF VARIABLES
-Study these example of variables to check your understanding.
+Suena más complicado de lo que es en realidad.
+> 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.
-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.
-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:
+> las computadoras solo cumplen exactamente lo que les instruye que hagan.
+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.
+> Ten en cuenta las [[reglas_de_diseno_unix|reglas de diseño Unix]]. Escribir programas comprensibles.
-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.
+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.
-Consider this example:
+Considere este ejemplo:
-<code basic>
+<code freebasic>
-IF CHOICE% < 1 THEN GOTO 500
+IF OPCION% < 1 THEN GOTO 500
-IF CHOICE% > 1 THEN GOTO 700
+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!.
-===== THE REST OF THE PROGRAM =====
+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".
-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.
+===== El resto del programa =====
-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.
+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.
-<code basic>
+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.
+<code freebasic>
 REM *****  PANTALLA 1A  *****
 CLS
@@ Línea 302: / 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 311: / 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 327: / 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 336: / 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 344: / 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.