Learn to program with Rockerfer Basic. Execute your exercises on-line!

Your first program

Directly from Rockerfer Basic site's Main Page, you will be able to write your first program.

Inside the window, write the following line:

print "Hello, World"

Run this program by clicking on "Run!". The line "Hello World" will be shown when the web page reloads. This means the program was run correctly.

The print instruction allow your programs to show information in the computer screen. If you use several print instructions, one following the other, you will note the printed sentences will be shown one below the other. For example:

print "One"
print "Two"

Will show:

One
Two

However, if the sentence is ended with a comma (,), the next print sentence will print in the same line as the previous one.

print "One",
print "Two"

Will show:

OneTwo

You can separate several to-be-printed elements using commas:

print "One","Two","Three"

OneTwoThree

Synonims

In Rockerfer Basic there are a few synonims, so you can write one instruction more than one way. Thus, print can be written as say, write, and the symbol '?'. In the next example, all the sentence do exactly the same action:

print "Three"
say "Three"
write "Three"
? "Three"

Three
Three
Three
Three

Which one to use? The one you feel like using. That's the idea! That way you will be able to design for programs comfortably, without worrying about cumbersome syntaxis.

Variables and Datas

Rockerfer Basic has three types of data: Integer, floating and string. The integer type represents any real, integer (no decimals) number, positive or negative. The floating type accepts any real number (with decimals. Scientific notation may be used). The string type represents any series of alphanumeric characters (letters, numbers and symbols).

Integer
Floating
String

45,-6,0
3.1415,-6E15
"Hello","a"

Data in Rockerfer Basic can be handled literally, or stored in variables. Literal handling refers to direct use of data inside a sentence. Next you will find examples of literal handling inside the print sentence:

print 3
print "hello"+" goodbye"
print sin(2*3.1415926)

Variables are individual data storage areas identified by an associated name. Variables can store data of any allowed type in Rockerfer Basic, that is, there are variables that store integer data (called integer variables), there are variables that store floating data (floating variables) and there are variables that store string data (string variables). Integer or floating variables are also referred as numeric variables. String variables are also referred as alphanumeric variables.

Variables are identified with a name. Examples of variable names follow:

C,Age,Position1Payment_Percentage,NAME,SeLecTiOn

Variables can only store data of the type it was assigned. For example, a numeric variable can not store alphanumeric strings (such as letters or words).

There are two ways to declare a variable. The first one is by using the declare instruction:

declare variable string MyString
declare variable integer AnInteger
declare variable floating AMOUNT

If the type is omitted, integer will be assumed.

Arrays

There are special variables that can store more than one value of the same type at the same time. These are the matrixes or arrays.

Arrays are collections of data stored in variables of the same type and under the same name. How can you identify a piece of data in particular, if all variables in the array have the same name? Each variable has a numeric attribute called index. The index is unique for every piece of data; thus, we can refer to a variable that is member of the array by its name and index. An array of 5 integers is shown next:

Array of 5 integers: 4,8,-3,0,1

Let's say the array uses the identification name "Values". That way you can refer to any value by writing the variable name along with its index in parenthesis:

Values(1) = 4
Values(2) = 8
Values(3) = -3
Values(4) = 0
Values(5) = 1

In the previous example, it can be noted that array indexes are sequential, and are counted starting from 1. For example, an array of 25 strings has its values arranged from 1 to 25.

Arrays can be used in any context where a regular variable can be used. Here are a few examples:

declare variable array integer C(8)
let C(4) = 20
let C(2) = 30
print C(2)+C(4)

The print sentence will show '50'.

declare variable array employees(200)
let B = 10
print employees(20+B)

The print sentence will print the contents of variable 'employees(20+B)', that is, the contents of
'employees(30)'

As you can see, in order to declare arrays you just have to add array and the index between parenthesis in the declaration sentence.

Assigning data to variables

What is the second way to declare variables? First, let's review the way data is assigned to variables. This is done with the let sentence. In the next example, the string "Hello" will be assigned to the string variable Greetings.

let Greetings = "Hello"
print Greetings

The print sentence will show 'Hello'.

Variables can be assigned values as many times as required. Values can only be the same type of the variable. If you try to assign a string to a floating variable, Rockerfer Basic will report an error. The exception is when you assign an integer to a floating variable. In that case, it will work, although the integer value will be converted implicitly to the floating type. The other way around will work, too, but if the floating value has decimals, these will be silently deleted.

declare variable string MyString
let MyString = 90	Error
let MyString = "Hello"	Correct
declare variable string MyString
declare variable floating Amount
let Amount = 45	Correct
declare variable integer Age
let Age = 20.3	Correct, but Age will have 20.

You can omit the Let instruction when assigning:

Let Color = "Blue"
Color = "Blue"

Back to the second method of declaring variables: If you assign a value to a variable that was not previously declared, it will be automatically created and will be the type of the assigned value:

declare variable string Model Model = "Ferrari" end
Model = "Ferrari" fin	Both programs are equivalent: A string variable Model will be declared and the string "Ferrari" will be assigned to it.
Size = 40	Implicit declaration of the integer variable Size and its corresponding assignment.
Amount = 50.45	Implicit declaration of the floating variable Amount and its corresponding assignment.
Time = 30.0	Implicit declaration of the floating variable Time and its corresponding assignment.
Features = "none" Features = 40	The second sentence will report an error because Features was implicitly declared as a string variable.

Arrays must always be declared before assigning values to them.

Programming Structures

Rockerfer Basic provides a set of sentences to create programming structures, where the program flow changes according to a series of conditions. These structures are studied in every introductory programming course. The most common will be discussed here. To review them all, see the Complete Reference.

for / to /end for

This structure allows to execute a section of the program as many times as specified. For example, next sentence:

print "Hello"

will print "Hello" once. If you require to print "Hello" 100 times, there are various alternatives. The first one is to execute the program 100 times. The second one is to write a program with 100 print "Hello" sentences. Both alternatives are extremely inefficient. The third alternative is to use a for / to / end for structure:

Let Count = 1
for Count from 1 to 100 do
print "Hello"
end for

If you execute the previous program, "Hello" will be printed 100 times. The for / to / end for has various options. See the Complete Reference for more information.

if / then / end if

This structure allows the program to decide whether or not to execute a program section (or block), depending of a certain condition. For example:

Let Age = 17
if Age > 10, then
print "You can enter the park"
end if
[...other instructions...]

When Rockerfer Basic reaches the second line of this program, it will check the condition of the structure (in this case, it will check if the value of the variable Age is greater than 10). If the condition is true, it will execute the section starting the third line (in our example, it will be executed because the condition is indeed true, that is, Age, which is 17, is greater than 10). If Age would have had the value 9 instead of 17, Rockerfer Basic wouldn't have executed the third line. It would have skipped it and continue the execution starting the line after the end if.

repeat / until

This structure executes a program block repeatedly until a certain condition is proven true. For example:

repeat
print "Enter the password:"
read Password
until Password = "secret"
print "The password is correct"
[...other instructions...]

The previous program will ask a password to the user. Let's assume the user provides a password different to "secret". When Rockerfer Basic reaches the fourth line, it will verify if the condition is true (that is, is Password equals "secret"). Is it is not true, then it will execute the sentences starting from repeat again. When the user provides the word "secret" as a password, and Rockerfer Basic reaches the until sentence, it will continue with the remaining instructions, since the condition is now true (Password = "secret").

The structures here superficially discussed have more options that allow to write programs more flexibly. The Complete Reference will show you those options as well as the other programming structures.

Built-in Functions

Rockerfer Basic has a set of functions to perform common programming tasks. Each function has its own name (related to its task), and it works on data provided by the user (these data are known as parameters).

For example, to print the first n characteres of a string, the right() function is used:

sea Let Name = "Alexandria"
print right(Name,3)

The previous program will print "Ale".

right() has its counterpart, left(). Example:

print left("Greetings",2)

The previous program will print "gs".

Functions can be used in any expression that requires a value:

Let Word1 = "What day is it today?"
Let Word2 = "Who are you?"
Let Expression = right(Word1,4)+left(Word2,4)
Print Expression

The previous Program will print the string "Whatyou?".

Functions not only return alphanumeric values. As an example, the len function will return the number of characters contained in a string:len("hello") will return 5. cos() will return the cosine of a number. abs() will return the absolute value of a number.

For a complete list of functions available in Rockerfer Basic, read the section List of Rockerfer Basic's Built-in Functions.

Back to table of contents

Complete Reference

El lenguaje Rockerfer Basic está especialmente diseńado para el aprendizaje de conceptos vistos en las etapas iniciales de los cursos de programación. Está basado en el lenguaje de pseudocódigo, lo cual significa que su juego de instrucciones representa una generalización de los juegos de instrucciones de otros lenguajes.

Structure of a Rocker Basic Program
Data Types
Variables
. - Matrixex (or arrays)
Instructions
List of Instructions (in alphabethical orer)
List of Functions (in alphabethical order)
Synonyms Quick Reference

Structure of a Rocker Basic Program

Las declaraciones de variables y datos pueden aparecer en cualquier parte del programa, pero es común colocarlos en el principio del mismo.

Typical structure of a Rocker Basic Program:

Las declaraciones de variables y datos pueden hacerse en cualquier lugar del programa, aunque es recomendable que todas estén en el principio. De esta manera están más accesibles en momentos de depuración y modificación.

<declaraciones de variables y datos>
.
<instrucciones de programa>

Data Types

Rockerfer Basic posee tres tipos de datos:

Entero: Representa cantidades numéricas, no decimales, cuyo rango está fijado entre -65536 y 65535.
Flotante: Representa cualquier cantidad numérica real, cuyo rango está fijado entre -10x10^100 hasta 10x10^100.
Cadenas: Representa series de caracteres (letras, símbolos y números) disponibles en el juego de caracteres del computador. Pueden almacenar cadenas de hasta 255 caracteres de longitud.

Los datos en Rockerfer Basic pueden representarse mediante cualquiera de estos tres tipos de datos, y pueden almacenarse en variables (véase a continuación) o ser utilizados directamente en instrucciones, tales como "imprimir".

Variables

Las variables son espacios de almacenamiento de datos con nombre. Se les puede hacer referencia usando su nombre. Los nombres de variables pueden ser de cualquier longitud hasta 64 caracteres, y pueden utilizarse letras, números, y el símbolo del subrayado "_", aunque no está permitido que el nombre comience con un número o el símbolo del subrayado. Rockerfer Basic no distingue las mayúsculas de las minúsculas en los nombres de variables por lo que, a manera de ejemplo, los tres nombres de variables "EDAD", "edad" y "Edad" representan todos a la misma variable.

Rockerfer Basic tampoco permite el uso de nombres de variables que coincidan con nombres de instrucciones o funciones. Por ejemplo, el nombre de variable "imprimir" no está permitido, ya que imprimir es una instrucción.

Ejemplos de nombres válidos:

cuenta

Nombre_Alumno

USUARIO21

p1

Ejemplos de nombres no válidos:

_usuario21

4estudiante

para (es una instrucción de Rockerfer Basic)

Rockerfer Basic posee un tipo de variable por cada tipo de dato, más las variables matrices (véase más adelante). Es decir, que están disponibles las variables de tipo entero, las de tipo flotante y las de tipo cadena.

Para asignar valores a las variables, se utiliza la siguiente sentencia:

Sea <nombre> igual a <valor>

Donde <nombre> es un nombre de variable, y <valor> es el valor a asignársele.

Ejemplo:

Sea X igual a 1

Esto asignará 1 a la variable X.

Las siguientes dos sentencias también realizan la misma función de asignar 1 a la variable X:

X es igual a 1
X = 1

Es de preferencia del usuario escoger qué sentencias utilizar.

Matrixes (or arrays)

Las matrices son colecciones de variables del mismo tipo, a las cuales pueden referirse utilizando un índice numérico. Por ejemplo, si tenemos una colección de cadenas:

"uno", "dos", "tres", "cuatro", "cinco",

éstas pueden almacenarse en una matriz. Llamemos "numeros" a esa matriz, y asignémosle las cadenas.

numeros(1) = "uno"
numeros(2) = "dos"
numeros(3) = "tres"
numeros(4) = "cuatro"
numeros(5) = "cinco"

Podemos referirnos a cualquiera de esos elementos utilizando el número de índice, que es el número ubicado entre paréntesis. Por ejemplo, las siguientes dos sentencias:

Sea I igual a 2
Imprime numeros(I)

Hará que Rockerfer Basic imprima "dos" en la ventana de salida.

La forma de declarar matrices en Rockerfer Basic, es usando la sintaxis siguiente:

Declarar variable <tipo> [de arreglos] <nombre_de_variable>(<indice>)

Como ejemplo, para declarar una matriz B de 10 elementos enteros, utilizamos:

Declarar variable de enteros B(10)

Otra alternativa:

Declara variable entera de arreglos B(10)

Si no se coloca el tipo, Rockerfer Basic asume el tipo entero.

Declara variable B(10)

La sentencia anterior declara una matríz B de 10 elementos que van desde B(1) hasta B(10).

Instructions in Rockerfer Basic

Rockerfer Basic cuenta con un rico juego de instrucciones, todas en espańol, que permiten realizar las más diversas tareas relacionadas con el mundo de la programación: entrada, salida y manipulación de datos, cálculos numéricos, iteraciones, bloques de decisión y bucles. Las instrucciones pueden escribirse sin tomar en cuenta las mayúsculas y minúsculas, por lo que 'Imprimir' se puede escribir 'IMPRIMIR', 'imprimir' o incluso 'iMpRiMiR'.

Una característica esencial del lenguaje Rockerfer Basic es su sintaxis flexible. Muchas de sus instrucciones pueden escribirse de más de una forma, de tal manera que el usuario no tenga que amoldarse a un solo estilo, pudiendo poner su atención en la búsqueda de la solución de sus ejercicios. Por ejemplo, la sentencia de asignación:

Edad = 0

Puede escribirse como:

Sea Edad igual a 0

O incluso:

Edad es igual a 0

Otro ejemplo, es la sentencia "imprimir", la cual puede escribirse como "imprime", "escribe", "escribir", o incluso "decir" o "dí".

Para más información, revisa la sección siguiente, "Lista de instrucciones de Rockerfer Basic".

List of Rockerfer Basic's Instructions and Sentences (in alphabethical order)

Esta lista contiene la descripción de cada una de las instrucciones del lenguaje Rockerfer Basic. Si encuentra el vocabulario empleado un tanto complicado, asesórate con tu tutor, o contáctanos.

Las palabras encerradas entre paréntesis representan alternativas a la sintaxis original.

cases/case/end cases

Sintaxis:

casos [para] <variable>
caso <expresion1>
<sentencias1>
... caso <expresionN>
<sentenciasN>
caso [por] omisión
<sentenciasO>
fin casos

Rockerfer Basic evaluará cada una de las expresiones hasta que una de ellas concuerde con el valor de <variable>. Al encontrar un valor coincidente, Rockerfer Basic ejecutará las sentencias correspondientes a ese caso. Si hay dos o más valores iguales, Rockerfer Basic ejecutará sólo las sentencias del primer valor. Si no consigue ningún valor, el intérprete ejecutará <sentenciasO>, de
existir.

Ejemplo:

sea r igual a 3
casos para r
caso 1
imprime "Es uno"
caso 2
imprime "Es dos"
caso 3
imprime "Es tres"
caso por omisión
imprime "No es ni 1, ni 2 ni 3"
fin casos

Comment symbol ('#')

Sintaxis:

# <comentario>

Especifica que el resto de la línea es un comentario de programa y que el intérprete deberá ignorar. De esa manera, el intérprete continuará con la siguiente línea de programa. 'comentario' es útil para colocar observaciones, comentarios, explicaciones y anotaciones dentro del código del programa.

Ejemplo:

# La siguiente sentencia imprime "Hola"
imprime "Hola"

declare variable (create)

Sintaxis:

declarar [la] variable ([[de]arreglo]|[matriz])|([[de]enteros]|[entera])|[flotante]|[[de]cadena] <variable>['('indice')']

Esta sentencia es utilizada para crear variables del tipo especificado. Si el tipo no se especifica, se asume el tipo entero.

Ejemplo:

declarar variable de enteros C(10)

end (finish)

Utilizado para denotar el final del programa. Todo lo que venga después no será tomado en cuenta. Si se omite, el intérprete asumirá el final del programa como el final del archivo.

Ejemplo:

imprime "Este programa finalizará pronto"
fin

print (say, write, '?')

Sintaxis:

Imprimir <expresión1>,
<expresión2>,...
[,]

Se utiliza para mandar información a la salida en pantalla del usuario.
Si al final de la sentencia se agrega una coma, el cursor no pasará a una nueva línea, sino que se quedará en la misma línea esperando por otra sentencia a imprimir. Pero si se omite esa coma al final, la próxima sentencia imprimir imprimirá en la siguiente línea.

Ejemplo:

Sumando1 es igual a 45
Sumando2 es igual a 55
imprime "El resultado de sumar ",
imprime Sumando1," y ",Sumando2," da: ",
imprime Sumando1+Sumando2
imprime "Es todo"

input (read,enter)

Sintaxis:

lee <var1>,<var2>,<var3>,...

Se utiliza para asignar valores entrados por teclado a las variables especificadas. Rockerfer Basic esperará a que el usuario presione la tecla ENTER para asignar un valor a una variable, y después esperará por la siguiente variable.

Ejemplo:

dí "Escribe tu nombre: ",
lee Nombre
dí "ĄHola, ",Nombre,"!"

while / do / end while

Sintaxis:

mientras <expresión> hacer
<sentencias>
fin mientras

Rockerfer Basic evaluará <expresión> y a continuación ejecutará <sentencias1>. Esto lo hará repetidas veces hasta que <expresión> se evalúe como verdadera. Si <expresión> es falsa en la primera evaluación, <sentencias1> nunca se ejecutará.

Ejemplo:

sea Nombre igual a ""
mientras Nombre = "" hacer
dí "Escribe tu nombre:"
fin mientras
imprime "Hola, ",Nombre

for / to / end for

Sintaxis:

para <variable>
de <expresión1>
hasta <expresión2>
[pasos [de] <expresion2>]
[,] hacer

<sentencias1>

fin para

Rockerfer Basic inicializará <variable> con <expresión1>, e incrementará su valor hasta que sea igual o supere a <expresión2>. Por cada incremento, ejecutará las sentencias encerradas entre 'hacer' y 'fin'.<variable> será incrementada en una unidad, a menos de que se especifique el incremento con 'pasos'. Si <expresión1> sobrepasa en la primera pasada a <expresión2>, el código no se ejecuta. <variable> puede utilizarse dentro del ciclo. Adviértase que <variable> no puede ser parte de un arreglo.

Ejemplo:

para E de 1 hasta 20 hacer
imprime "E vale: ",E
fin para

repeat / until

Sintaxis:

repetir <sentencias1>
hasta que <expresion1>
fin repetir

El intérprete ejecutará <sentencias1> y a continuación evaluará <expresión1>. De resultar falsa, el intérprete vuelve al principio de <sentencias1> y repite el mismo proceso. <sentencias1> se ejecutará al menos una vez.

Ejemplo:

sea Suma igual a 0
declarar variable entera Entrada
repetir
imprime "Introduce un número"
lee Entrada
Suma=Suma+Entrada
hasta que Suma>100
imprime "La suma de todas las entradas sobrepasa a 100"

let ('=')

Sintaxis:

sea <variable> igual a <expresión>

'sea/igual a' es un operador de asignación de variables. Puede ser utilizado para crear e inicializar variables (pero no se pueden crear arreglos). Si se especifica un índice, entonces se crea un arreglo (o matriz) de tantas variables como lo especifique dicho índice.

Ejemplo:

sea TipoCasa igual a "mansión"
sea Dueńo igual a "Pedro"
imprime Dueńo," tiene una ",TipoCasa

if / then / end if

Sintaxis:

si <expresion>
([,]entonces|,[entonces])
<sentencias1>
[[en] caso contrario|sino]
<sentencias2>
fin si

El intérprete evaluará <expresion>, y de resultar verdadera, ejecutará <sentencias1>. Si resulta falsa entonces, de existir, ejecutará <sentencias2>. Si no se especifica <sentencias2>, sencillamente pasará a ejecutar la siguiente sentencia.

Ejemplo:

decir "Dime tu nombre:"
lee Nombre
si Nombre es igual a "José", entonces
decir "ĄHola! ĄYo te conozco!"
en caso contrario
decir "No te conozco"
fin si

end (finish)

Sintaxis:

(terminar|finalizar) [programa]

Este comando le indica a Rockerfer Basic que termine con la ejecución del programa. Rockerfer Basic dejará de ejecutar instrucciones una vez que encuentre una instrucción terminar.

List of Rockerfer Basic's Built-in Functions (in alphabethical order)

Estas funciones pueden ser utilizadas en cualquier expresión válida de Rockerfer Basic.

abs(n)

n puede ser un valor numérico cualquiera (flotante o entero).

Devuelve el valor absoluto de n.

Ejemplo: abs(-3) devuelve 3.

rnd()

Devuelve un número flotante aleatorio mayor o igual que 0 y menor que 1.

Ejemplo: aleatorio() devuelve 0.23452347

str(n)

n puede ser un valor numérico cualquiera (flotante o entero).

Devuelve n como una cadena alfanumérica.

Ejemplo: cadena(34) devuelve "34" (como cadena).

cos(n)

n puede ser un valor numérico cualquiera (flotante o entero), representando un valor en radianes.

Devuelve el coseno de n, donde n es un ángulo en radianes..

Ejemplo: coseno(0) devuelve 1.

right(s,n)

s es una cadena. n es un entero.

Devolverá los n caracteres por la derecha de s.

Ejemplo: derecha("Hola",2) devuelve "la".

int(n)

n puede ser un valor numérico cualquiera (flotante o entero).

Devuelve la parte entera de n.

Ejemplo: entero(67.89) devuelve 67.

exp(n)

n puede ser un valor numérico cualquiera (flotante o entero).

Devuelve el valor exponencial de n.

Ejemplo: exp(1) devuelve 2.71828182845905 (e).

left(s,n)

s es una cadena. n es un entero.

Devolverá los n caracteres por la izquierda de s.

Ejemplo: izquierda("Hola",2) devuelve "Ho".

log10(n)

n puede ser un valor numérico cualquiera (flotante o entero).

Devolverá el logaritmo en base 10 de n.

Ejemplo: log10(10) devuelve 1.

logn(n)

n puede ser un valor numérico cualquiera (flotante o entero).

Devolverá el logaritmo natural (o neperiano) de n.

Ejemplo: logn(1) devuelve 0.

len(s)

s es una cadena.

Devolverá el número de caracteres contenidos en s (recuerde que los espacios en blanco cuentan como caracteres).

Ejemplo: longitud("Hola") devuelve 4.

sqr(n)

n puede ser un valor numérico cualquiera (flotante o entero).

Devuelve la raíz cuadrada de n.

Ejemplo: raizc(9) devuelve 3.

sin(n)

n puede ser un valor numérico cualquiera (flotante o entero).

Devuelve el seno de n, donde n es un ángulo en radianes.

Ejemplo: seno(0) devuelve 0.

sgn(n)

n puede ser un valor numérico cualquiera (flotante o entero).

Devolverá 1 si n es mayor que 0, 0 si n es 0, y -1 si n es menor que 0.

Ejemplo: signo(-15) devuelve -1.

mid(s,n,m)

s es una cadena. n y m son valores enteros.

Devolverá los m caracteres consecutivos de s, partiendo desde n. Si m es omitido, devolverá todos los caracteres de s partiendo desde n.

Ejemplo: subcadena("Hola",2,2) devuelve "ol".
subcadena("Matemáticas",3) devuelve "temáticas".

tan(n)

n puede ser un valor numérico cualquiera (flotante o entero).

Devuelve la tangente de n, donde n es un ángulo en radianes.

Ejemplo: tangente(0) devuelve 0.

val(s)

s es una cadena.

Devuelve el equivalente numérico de s.

Ejemplo: valor("34.5") devuelve 34.5.

Synonyms Quick Reference

Instruction Name	Synonym(s)
declare (variable)	create (variable)
end	finish
print	write, say, '?'
input	read, enter
let X = Y	X = Y

Back to table of contents

TODO: TRANSLATE REST OF DOCUMENT. THIS IS A WORK IN PROGRESS. I APOLOGIZE FOR THE INCONVENIENCE.

THE TITLES, KEYWORDS AND FUNCTION NAMES WERE TRANSLATED, SO YOU KNOW ABOUT THEM.