Saltar al contenido principal

Tu primer programa

Si has seguido Instalación, ya has creado un proyecto y lo has ejecutado. Aquí escribes un programa pequeño y haces con él lo que harás siempre en el IDE: ejecutarlo y ver lo que imprime, entender un error y parar el programa para mirar sus variables. Todo en Windows, sin placa.

Crear el proyecto​

  1. Abre el asistente de proyectos (Project Wizard). Sale al arrancar JARU IDE; si tienes un proyecto abierto, pulsa Home › Project › New.

  2. Pulsa New Project, escribe Tutorial en Project Name y pulsa Finish. El resto del formulario puede quedarse como está: cada campo se cuenta en Proyectos. Si ya has hecho antes este recorrido, ya tienes un proyecto Tutorial: Finish te lo dice y no lo toca. Usa otro nombre, como Tutorial2.

  3. El IDE crea la carpeta Documentos\JARUProjects\Tutorial y abre en el editor de código el fichero principal, Code/Tutorial.aru: el que compila y ejecuta Run. Trae una cabecera de comentarios y una línea de prueba, como la de la instalación. Bórralo todo y escribe este programa:

    var total = 0
    for (var i = 1; i <= 5; i = i + 1)
        total = total + i
        println("i = ", i, "  total = ", total)
    end
    println("Total: ", total)

  4. Guarda con Ctrl+S. Mientras haya cambios sin guardar, la pestaña lleva un asterisco detrás del nombre.

El programa suma los números del 1 al 5. En cada vuelta del for, println escribe sus argumentos uno detrás de otro y salta de línea. Las carpetas que tiene el proyecto se cuentan en Proyectos.

Ejecutarlo​

La pestaña Build de la cinta, con los grupos Target, Compiler (Compile, Run y Stop) y Debug

En la pestaña Build, el botón del grupo Target dice Target: Windows: el programa corre en la VM de Windows.

  1. Pulsa Run. El programa no está compilado, así que el IDE lo compila antes. El Output, abajo, cuenta cómo va y dice [Build completed successfully in … ms].

  2. Se abre una consola, y el programa corre en ella. Primero salen los mensajes con los que arranca la VM: su cartel, su versión y la carga del programa, que acaba en Checksum verified successfully. Detrás va lo que imprime el programa:

    i = 1  total = 1
    i = 2  total = 3
    i = 3  total = 6
    i = 4  total = 10
    i = 5  total = 15
    Total: 15

  3. Cuando el programa acaba, la consola dice Execution finished. Press any key to continue… y espera. Pulsa una tecla para cerrarla.

Lo que imprime el programa sale en su consola, no en el Output. Es también donde escribes si el programa te pide algo con readLine. Mientras la consola está abierta, el IDE cuenta el programa como en marcha: Compile, Run y Debug se apagan, y Stop cierra el programa y su consola.

Run compila antes cuando hace falta: si el programa no está compilado o si has guardado código después de compilarlo. Lo que no hayas guardado no entra, así que guarda antes de ejecutar. Para compilar sin ejecutar, pulsa Compile. Los botones de la pestaña están en La interfaz.

Un error a propósito​

Un programa puede fallar de dos maneras: al compilarlo, y entonces no llega a ejecutarse, o mientras corre.

Un error al compilar​

  1. Borra el último paréntesis de la línea 4, el que cierra el println:

    var total = 0
    for (var i = 1; i <= 5; i = i + 1)
        total = total + i
        println("i = ", i, "  total = ", total
    end
    println("Total: ", total)

  2. Medio segundo después, el editor subraya total, en la línea 4, con una onda roja: el IDE revisa el código mientras escribes, sin compilar. La Error List, en la pestaña de al lado del Output, lo apunta: Parser en Stage, 4 en Line y el mensaje Invalid function parameters, expected ")" not "total". Con doble clic en la fila, el editor va a ese sitio.

  3. Guarda y pulsa Run. El IDE vuelve a compilar, y esta vez el compilador se para. El programa no llega a ejecutarse: no se abre la consola. Al final del Output, en rojo:

    [ERROR] Parser (5:1): In file Code/Tutorial.aru, expect to be special: ')' not : end
    [Compilation failed with 1 errors. Time: 0 ms]
    First error: Parser (5:1): In file Code/Tutorial.aru, expect to be special: ')' not : end
    [Cannot run the program: build failed]
JARU IDE tras pulsar Run con un paréntesis de menos: la onda roja en la línea 4 y, en el Output, el error del compilador en rojo

Cómo se lee la primera línea:

  • Parser es la parte del compilador que ha encontrado el error. El fichero va detrás: In file Code/Tutorial.aru.
  • (5:1) son la línea y la columna donde el compilador se ha dado cuenta: el end de la línea 5.
  • expect to be special: ')' es lo que esperaba: el paréntesis que cierra el println. Detrás de not : va lo que ha encontrado en su lugar: el end.

El paréntesis falta al final de la línea 4, donde lo marca el editor. El compilador avisa donde encuentra algo que no espera, y eso puede estar en la línea siguiente: si no ves el fallo en la línea del error, mira la de antes.

Vuelve a poner el paréntesis y guarda: la onda roja desaparece.

Un error al ejecutar​

Otros errores solo salen con el programa en marcha, cuando llega a ellos. Por ejemplo, un nombre mal escrito.

  1. En la última línea, cambia println por prinln:

    var total = 0
    for (var i = 1; i <= 5; i = i + 1)
        total = total + i
        println("i = ", i, "  total = ", total)
    end
    prinln("Total: ", total)

  2. El editor lo subraya, y la Error List dice Call "prinln" is not defined., con Semantic en Stage. El compilador, en cambio, no lo comprueba: guarda y pulsa Run, y la compilación acaba bien. Detrás, el Output avisa en amarillo de lo que marca el editor:

    [Warning] The code editor marks 1 error(s) in the project that the compiler does not check; a program that gets to one stops there:
      Tutorial.aru (6:1): Call "prinln" is not defined.

  3. El programa arranca en su consola, escribe sus cinco vueltas y, al llegar a la línea 6, se para. Detrás de la línea JARU VM execution ended., la consola enseña el error:

    ====================================================================
      UNHANDLED EXCEPTION
    ====================================================================
    Type       : Unhandled exception.
    Exception  : ERR_NAME_NOT_FOUND
    Message    : Undefined variable 'prinln'.
    Location   : line 6 in <main>()

    ----------------------  EXECUTION TRACE  ----------------------
       1. line 6 in <main>()
    ------------------------------=====----------------------------

    [ JARU VM terminated execution due to a critical error ]
    ====================================================================

    El Output lo repite en rojo, debajo de [Run] The program wrote these errors (also in its console):.

Cómo se lee:

  • Exception es el tipo de error: ERR_NAME_NOT_FOUND, un nombre que no existe.
  • Message dice qué ha pasado. La VM busca las funciones como cualquier otro nombre, y por eso dice variable aunque sea una función.
  • Location dice dónde: en la línea 6, dentro de <main>(), que es el código que está fuera de las funciones.
  • EXECUTION TRACE es el camino hasta el error. Si salta dentro de una función, sale una línea por cada llamada, de la más interna a <main>().

La línea sale porque la casilla Line numbers, del grupo Target, está encendida, como viene de serie. Si la apagas, el error dice line -1.

Los demás errores al ejecutar salen igual. Dividir por cero, por ejemplo, da ERR_DIVISION_BY_ZERO con el mensaje Division by zero.

Corrige prinln, guarda y vuelve a pulsar Run.

Un punto de parada​

Un punto de parada detiene el programa en una línea, antes de ejecutarla, para que mires sus variables. Aquí va el primer uso; el depurador entero está en Depurador.

  1. Pon el cursor en la línea 3 (total = total + i) y pulsa F9, o haz clic en el borde izquierdo del margen, junto al número de la línea. Sale una marca roja.

  2. Pulsa Debug, en la pestaña Build, o F5 con el cursor en el editor. El IDE compila el programa y lo arranca en su consola, para depurarlo.

  3. El programa se para en la línea 3, todavía sin ejecutarla. El editor la resalta, el IDE se pone delante y el Output dice dónde está:

    [Paused at line 3 of Tutorial.aru. The game waits: Step or Continue it from the Build tab.]

  4. Haz clic en total, en el editor, y con el botón derecho elige Add Watch. Se abre la ventana Watch con la variable: total vale 0, porque la línea 3 aún no se ha ejecutado. Añade i igual: vale 1.

  5. Pulsa Step Over, en la pestaña Build (o F10 con el cursor en el editor). El programa ejecuta la línea 3 y se para en la 4. Watch dice que total vale ahora 1.

  6. Pulsa Continue (o F5). El programa sigue, la consola escribe i = 1 total = 1 y se para otra vez en la línea 3, en la vuelta siguiente: i vale 2.

  7. Quita el punto de parada con un clic en la marca roja, o con F9 en su línea, y pulsa Continue. El programa acaba, y el Output dice [Debug session ended]. Su consola espera una tecla para cerrarse. Para acabar antes, pulsa Stop: cierra el programa y su consola.

El programa parado en el punto de parada de la línea 3, con la ventana Watch (total vale 0, i vale 1) y el aviso del Output

En Watch, cada variable lleva también su tipo y su contexto. Cómo se añaden y se quitan variables, en Depurador.

Dónde queda el programa​

Al compilar, el IDE convierte tu código en el programa que ejecuta la VM de JARU: el fichero .jxr. Run y Debug no ejecutan el .aru, que es el texto, sino este fichero.

  • Queda en la carpeta Build/flash del proyecto, con el nombre del fichero principal: Documentos\JARUProjects\Tutorial\Build\flash\Tutorial.jxr. Al compilar, el Output lo dice en la línea [COMPILE] Output:, y el explorador lo enseña en su campo Output.
  • A su lado quedan Tutorial.jxd, con lo que el depurador necesita para saber por qué línea va el programa y cómo se llaman sus variables, y boot.cfg, los ajustes de la VM de Windows (Config › Platform › Windows), que el IDE copia ahí en cada Run en Windows. Si el proyecto tiene imágenes, sprites, mapas o música, al compilar el IDE deja en la misma carpeta lo que el programa necesita de ellos.
  • No hace falta tocarlo: el IDE lo rehace cada vez que compila.
  • Es el mismo programa para Windows y para una placa: la VM de la placa ejecuta el mismo .jxr. Con una placa elegida en Target, Run graba en ella la carpeta Build/flash, con el programa y sus ficheros. Cómo se hace, en Tu programa en una placa.

Siguientes pasos​