INTRODUCCIÓN
Este documento es una recolección de mis notas sobre Elena. La idea es dar una guía ordenada introductoria a este lenguaje descriptivo, aunque aun adolece de algunas limitaciones que seguramente se irán superando con el tiempo.
¿Qué es Elena?
Elena es un lenguaje originalmente ideado por un grupo de Estudiantes y docentes entusiastas de la USFX
UMRPSFXCH – Universidad Mayor Real y Pontificia de San Francisco Xavier de Chuquisaca – Bolivia. Nos referiremos a esta universidad solo como USFX.
con la intención de generar un lenguaje pseudocódigo, para facilitar el trabajo de estudiantes en cursos introductorios a la programación. Si bien su uso en principio fue pensado como un lenguaje dependiente de un intérprete, posteriormente se perfiló como proyecto independiente con la intención de generalizar un lenguaje de algoritmazo estándar para la USFX.
Definimos Elena como un lenguaje:
Algorítmico.
Orientado a Módulos.
Independiente de la plataforma.
Algunas de sus características son:
Es Descriptivo.
Auto-documentado.
No permite el uso de técnicas de programación inadecuadas.
Lenguaje Algorítmico.
Para mayor información sobre algoritmo o lenguaje, revisar el Anexo “A”
Es una serie de símbolos y reglas que se utilizan para describir de manera explicita un proceso. Estos se clasifican en lenguajes gráficos (diagramas de flujos) y no gráficos (pseudocódigo); Elena pertenece a estos últimos.
Lenguaje Orientado a Módulos.
¿Por qué puse “orientado a módulos” y no “modular”? Para destacar que, al contrario de otros lenguajes, no utiliza la modularidad como un recurso de la “programación estructurada”, sino que es un lenguaje creado para trabajar con módulos desde cero, de hecho el corazón de Elena son los módulos.
¿Qué es un Módulo?
Un módulo es un componente auto-contenido de un sistema; posee una interfase bien definida hacia otros componentes.
En ciencia computacional, un módulo es una entidad de software que agrupa un conjunto (típicamente cohesivo) de subprogramas y estructuras de datos. Los módulos son unidades que pueden ser compiladas separadamente, lo cual los hace reusables y permite a muchos programadores trabajar en diferentes módulos simultáneamente. Los módulos también promueven la modularidad y el encapsulamiento, lo cual puede hacer los programas complejos fáciles de entender.
¿Algoritmo o Módulo?
La primera respuesta que se me viene al a cabeza es: “ambos”.
Elena encierra cada algoritmo dentro de un módulo, y cada módulo puede solo contener un algoritmo. Así pues, se dice que, un módulo encapsula a un algoritmo.
Tanto algoritmo como módulo tienen una entrada y salida definidas (llamadas interfases en los módulos).
Todo elemento es cohesivo consigo mismo, por eso un módulo puede contener solo un algoritmo.
Un algoritmo se puede probar independientemente de otros, un módulo se puede compilar separadamente de otros.
Todo problema se puede resolver por segmentación en problemas simples (algoritmos y sub-algoritmos), cada uno un módulo, promoviendo así la modularidad.
Debido a todo esto, la mejor respuesta que se me viene a la cabeza es: “ambos”
A partir de ahora, nos referiremos de forma indistinta a algoritmo o módulo, a menos que se especifique lo contrario.
.
No es Orientado a Objetos.
Para denotar esto es suficiente mostrar las diferencias entre módulos y clases
Este no es un documento referente a la POO, se sobreentiende que el lector sabe de que se esta hablando.
:
Las clases pueden ser instanciadas para crear objetos, los módulos no necesitan esto.
Las clases pueden heredar comportamientos y datos de otras clases, los módulos no.
El polimorfismo permite cambiar en tiempo de ejecución las relaciones entre instancias de clases, los módulos son estáticos.
A pesar de ello, tiene similitudes:
Ambos pueden ser usados para esconder detalles de implementación de la vista del público.
Ambos pueden formar una jerarquía de módulos/clases.
Un ejemplo simple.
Para ir teniendo una idea, vamos a poner un ejemplo de un Módulo de Elena:
Primer Ejemplo
|
Módulo Mayor_de;
# Interfase del módulo
Entrada
Declarar n1 como entero;
Declarar n2 como entero;
Salida
Declarar mayor como entero;
# Cuerpo del módulo
Inicio
Si ( n1 > n2 ) Entonces
Mayor <- n1;
Caso Contrario
Mayor <- n2;
Fin Si;
Fin.
|
Este ejemplo no da una descripción completa de Elena, pero da una idea… Es un módulo que encapsula a un algoritmo para resolver el mayor entre dos números dados. Contiene una interfase que declara dos parámetros de entrada (n1 y n2), que, en el cuerpo del módulo serán comparados mutuamente, para retornar en “mayor” el numero mayor de entre ambos.
Independiente de la Plataforma.
Eso es completamente cierto. La realidad es que, siendo un lenguaje pseudocódigo, esta pensado para representar algoritmos de forma escrita, no con la intención de ser programados en alguna máquina en especial, sino describir las soluciones pensadas de forma natural, pero también sencillamente traducible a cualquier lenguaje de programación.
A pesar de ello, es intención del grupo que define Elena, proveer un software intérprete para probar dichos módulos de forma sencilla y sin ninguna complicación de traducción. El intérprete es descrito en su propio documento.
Aclaración.
En verdad, Elena
Elena, lleva la “E” por extendido.
es solo parte de un proyecto de “definición de lenguaje” llamado “LENA”
LENA – [LEN]guaje [A]lgorítmico.
que es un conjunto mínimo definido como intermediario entre Elena y su hermana melliza Milena
Milena, lleva “MI” por minimalista.
. Tanto Elena como Milena tienen su propósito de ser, pero no es concerniente al presente documento el describirlo para ambas.
LOS MÓDULOS EN ELENA
Bueno, antes de nada conviene saber que en Elena se supone la existencia de un montón de módulos genéricos y sencillos ya definidos y utilizables (a menos que uno quiera definir explícitamente uno de esos módulos, o su propia versión del mismo).
Estructura de un Módulo
Un módulo consiste en:
Estructura de unMódulo
|
Módulo Nombre_del_Módulo
[Entrada
Lista de parámetros de entrada]
[Salida
Lista de parámetros de salida]
Inicio
Cuerpo del Módulo
[Lista de variables y constantes]
Descripción de pasos a seguir - Operaciones
Fin.
|
Lo que está entre '[' y ']' es opcional.
Ya veremos que poner en “Lista de parámetros de entrada” y “Lista de parámetros de salida”, por ahora sigamos un poco más.
La “Lista de variables y constantes” sigue el siguiente formato para las variables, que son todas locales (Elena no permite las variables globales):
Declaración de Variables
|
Declarar Nombre_variable como Variable [tipo];
|
También tenemos las constantes, que sigue el siguiente formato:
Declaración de Constantes
|
Declarar Nombre_constante como Constante [tipo];
|
No se asigna ningún valor a una constante en el momento de su declaración, pero si, su primera ocurrencia dentro del cuerpo debe ser la asignación, y este valor no puede cambiar más durante la ejecución del módulo.
En cuanto a “Descripción de pasos a seguir – Operaciones”, siguen una sintaxis definida que será descrita posteriormente.
Finalmente, se aceptan solo comentarios de una línea, empezando desde el carácter “#” y hasta el fin de línea mas cercano.
ESTRUCTURA DE MÓDULOS
Vamos a comenzar analizando el módulo “Mayor_de”, para ir viendo las partes que forman un módulo una por una y en detalle.
Veamos la definición del Módulo “tan” o tangente:
Ejemplo – Módulo “tan”
|
# Cabecera del módulo
Módulo tan;
# Módulo para el cálculo de la tangente de un ángulo
# en base a la división del seno y coseno del mismo
# ángulo.
# Interfase del módulo – dentro de cabecera
Entrada
Declarar ángulo como real;
Salida
Declarar tan_a como real;
# Listado de módulos a usar
Usar mat:trigonometría:sen;
Usar mat:trigonometría:cos;
# Cuerpo del módulo
Inicio
# Declaración de variables y constantes (en caso de haberlas)
Declarar sen_a como variable real;
Declarar cos_a como variable real;
# Calculamos seno y coseno de ángulo.
Sen ( {ángulo}, {sen_a} );
Cos ( {ángulo}, {cos_a} );
# Con sen_ a y cos_a podemos calcular tan_a
tan_a <- ( sen_a / cos_a );
Fin.
|
Podemos determinar dos partes principales, la cabecera y el cuerpo.
Cabecera de un Módulo
La cabecera es principalmente informativa, contiene el nombre del módulo y su interfase.
Nombre del Módulo
El módulo se declara mediante la línea Módulo tan; lo cual significa que ese es el nombre de este módulo. En el caso más general, la declaración de un módulo puede contener los siguientes elementos:
Nombre de un Módulo
Como se ve, tanto Módulo como Nombre son obligatorios.
El nombre debe ser descriptivo, pero no largo, para una mayor descripción se pueden utilizar comentarios, tal como en el ejemplo. En caso de existir la necesidad de guardar el módulo en un formato electrónico, se debe utilizar un archivo utf-8 plano con el nombre del módulo como nombre del archivo y su extensión “.ela” (tan.ela)
Ela – [E]lena [L]enguaje [A]lgorítmico. Para mantener compatibilidad con sistemas que restringen la extensión de un archivo a 3 caracteres.
.
Interfase del Módulo
La interfase define como se comunica el módulo con otros módulos y/o su ambiente. Define: primeramente los datos de entrada y salida, luego los tipos definidos por el usuario y los módulos externos que son necesarios para su tarea.
Datos de Entrada y Salida
Están separados en dos secciones: Entrada y Salida, y se declaran así:
Entrada
|
Entrada
Declarar Nombre_valor_entrada [como tipo];
…
|
Salida
|
Salida
Declarar Nombre_valor_salida [como tipo];
…
|
Como podemos ver, ambas secciones son opcionales, y pueden ocurrir o no en un módulo específico, dependiendo de si este toma y retorna algún valor o no.
También se nota que la declaración de los valores es muy parecida a la declaración de variables/constantes; de hecho es la misma, solamente se omite las palabras “variable” y “consonante”
Es obvia la variación gramatical referente a género y número que se puede presentar por excluir una palabra; Elena soporta esta variación.
, esto debido a que un valor de entrada será siempre constante y un valor de salida será siempre variable.
Tipos Definidos por el Usuario
Con el termino “usuario” nos referimos al algoritmista que esta usando Elena. Estos tipos de datos refieren a estructuras nombradas que el usuario necesitará para trabajar con su algoritmo. En el ejemplo dado (tan) no aparece esta sección, debido a que en este ejemplo no es necesario. Se define así:
Tipo y Estructura
|
Declarar Nombre_Tipo como tipo;
Declarar Nombre_Tipo como {
Declarar Nombre_variable como Variable [tipo];
…
};
|
En la primera declaración estamos asignando un nuevo nombre a “tipo”, esto puede ser bueno en casos que se necesite trabajar con un nombre de tipo mas específico, pero que en pocas se trata de un tipo de dato básico.
En la segunda, definimos una estructura (explicadas posteriormente) como un tipo de dato.
Estos tipos pueden ser accedidos por otros módulos y también pueden ser usados en la interfase y dentro del cuerpo del módulo.
Módulos Externos (Usar)
La funcionalidad de la modularidad me permite segmentar un problema en problemas más pequeños y sencillos
Sub-algoritmos para los algoritmos.
. Así pues, tendremos que informar d que otros módulos utiliza nuestro módulo en particular. Para esto se tiene:
Usar otro Módulo
|
Usar Ruta:..:Nombre_Módulo;
…
|
Donde Ruta es la ubicación del módulo a usar, esta es, la jerarquía de paquetes con módulos pequeños y simples presupuestos por Elena. Si se desea Usar todo un paquete, se reemplaza “Nombre_Módulo” por solo “*” (asterisco).
Cuerpo de un Módulo
El cuerpo ya refiere a las operaciones realizaras por el módulo.
Siempre empieza con la línea “Inicio” y finaliza con “Fin.” Entre estas dos líneas se pueden posicionar los siguientes elementos:
Declaración de variables y constantes
Aquí corresponde definir todas las variables y constantes que vayamos a utilizar. En verdad estas se pueden definir en cualquier parte del cuerpo, pero es mucho mejor hacerlo al principio, pues así provee mejor lectura del módulo.
Recordemos como declararlas:
Declaración Variables
|
Declarar Nombre_variable como Variable [tipo];
|
También tenemos las constantes, que sigue el siguiente formato:
Declaración Constante
|
Declarar Nombre_constante como Constante [tipo];
|
El tipo es opcional, así, definimos una variable sin tipo, o más bien genérica, esta puede tomar cualquier valor sin importar su tipo de dato.
En Elena no hay variables globales; todas las variables se declaran dentro del cuerpo del módulo. Los cuadros anteriores muestran la declaración de variables/constantes con tipo básico o sin tipo (genéricas); pero también “tipo” puede ser un tipo definido por el usuario, una estructura (cuyos elementos se encierran entre ‘{‘ y ‘}’) o un tipo mas complejo como arreglos multidimensionales.
Los tipos en Elena
Como ya se dijo anteriormente, los tipos de datos disponibles en Elena son básicamente 4:
Tipos Básicos
Arreglos (arrays)
Estructuras
Tipos definidos por el usuario
Tipos Básicos
Los tipos básicos son:
|
Tipo
|
Descripción
|
Entero
|
Sin restricción de rango
|
Real
|
Sin restricción de rango, ni limite de precisión
|
Booleano
|
Dato lógico “verdad/verdadero” o “Falso”
|
Cadena
|
Cadena de caracteres sin limite de caracteres
|
Tipo Arreglo (array)
Son arreglos de cualquier tipo de dato (básico o no). Elena soporta tanto arreglos dinámicos como fijos.
Declaración de Arreglos
|
Declarar Nombre_arreglo como variable arreglo[dimensión] [tipo];
Declarar N_arr como variable arreglo[dimensión] [[dimensión]] [tipo];
|
Tanto para arreglos, como variables de tipo básico, se accede los valores asignados directamente, o a través de su(s) índice(s); no se conoce la dirección en memoria que ocupan dichos elementos. De hecho, en Elena no existen los tipos punteros o uniones. Las uniones no se hacen necesarias con un método de programación adecuado (además se evita malas practicas de programación con posibles accesos a datos incorrectamente).
Estructuras
Las estructuras permiten agrupar componentes de diferentes tipos y bajo un sólo nombre. Las estructuras en Elena se declaran así:
Declaración de una Estructura
|
Declarar Nombre_Estructura como {
Declarar Nombre_variable como Variable [tipo];
…
}
;
|
Las llaves en Elena se utilizan para agrupar elementos. Para acceder a un elemento dentro de una estructura, debemos reverenciarlo de la siguiente forma:
Referenciación
|
Nombre_estructura:Nombre_componente
|
El uso de los dos puntos ( : ) se utilizan para resolver el ámbito de los componentes y acceder a estos. Por ello también los vemos en el acceso a módulos externos.
Tipos definidos por el Usuario
Ya se mostró como declarar estos tipos:
Tipos definidos por el Usuario
|
Declarar Nombre_Tipo como tipo;
Declarar Nombre_Tipo como {
Declarar Nombre_variable como Variable [tipo];
…
};
|
Estos pueden ser utilizados como cualquier tipo básico, incluyendo en declaraciones de variables, datos de entrada, salida, etc.
Asignación
Se asigna un valor a una variable mediante el símbolo “<-“ (“menor que” y “guión”)
Asignación
|
Nombre_variable <- Valor Constante
Pi <- 3.14;
Nombre_variable <- Expresión
tan_a <- sen_a / cos_a;
Nombre_estrucura:Nombre_componente <- Valor Constante/Expresión
Cliente:Nombre <- “Juan”;
|
El último caso es válido si “Nombre” es un componente de la estructura “Cliente”.
Operaciones Matemáticas
Hay varios tipos de operadores:
Unarios: +, -, !,… etc. Se colocan antes del valor constante o expresión.
Binarios: +, -, *, /, %,… etc.
Van entre dos valores constantes o expresiones o combinación de ambos. El signo ‘+’ también sirve para concatenar cadenas de caracteres. Cuando se mezclan cadenas y valores numéricos, éstos últimos se consideran cadenas para la operación.
Operadores Lógicos
Elena implementa los siguientes operadores lógicos: ‘.y.’, ‘.o.’, ‘.x.’ y ‘.!.’; ‘y’ lógico, ‘o’ inclusivo, ‘o’ exclusivo y negación lógica respectivamente.
Precedencia de Operadores en Elena
La siguiente es la precedencia de los operadores en expresiones compuestas. De todos modos, como en todos los lenguajes, se recomienda usar paréntesis en caso de duda.
Postfijos… [], ({}, {}).
Operadores unarios… +expr, -expr, !expr.
Multiplicativos… *, /, %.
Aditivos… +, -.
Relacionales… <, >, <=, >=.
Igualdad… =, !=.
Negación lógica… .!.
Y lógico… .y.
exclusivo… .x.
inclusivo… .o.
Asignación… <-.
Llamada a otros módulos
Se llama a un módulo simplemente con el nombre del módulo y los parámetros entre paréntesis, separando los de entrada y salida en grupos de llaves, como se ve en el ejemplo:
Invocación de un Módulo
|
Nombre_Módulo ( {Lista datos entrada}, {Lista datos salida} );
sen ({ángulo}, {sen_a});
Mayor_de ({n1, n2}, {mayor, menor});
|
Notar que se puede pasar ‘n’ elementos de entrada, como también ‘m’ elementos de salida. Todo parámetro se pasador valor, no por referencia.
ESTRUCTURAS DE CONTROL
Las estructuras de control nos sirven para enriquecer el control que tenemos sobre las operaciones dentro del cuerpo de un módulo. Dentro de Elena, las estructuras de control son básicamente las mismas que otros lenguajes ofrecen, con excepción de “goto” (ir a), que no existe en el lenguaje.
Si…Entonces…[Caso contrario]…Fin Si
La más común de todas, permite ejecutar una instrucción (o secuencia de instrucciones) si se cumple una condición dada (o, mediante la cláusula “Caso contrario”, ejecutar otra secuencia en caso contrario).
Si…Entonces
|
Si ( Expresión booleana ) Entonces
Instrucciones si la expresión es verdadera
[Caso contrario
Instrucciones si la expresión es falsa]
Fin Si;
Si ( n1 > n2 ) Entonces
Mayor <- n1;
Caso contrario
Mayor <- n2;
Fin Si;
|
Según…Sea…Caso…[Caso Contrario]…Fin Según
Permite ejecutar una serie de operaciones para el caso de que una variable tenga un valor entero dado o pertenezca a un rango especificado. La estructura salta todos los casos hasta que encuentra uno que contenga el valor de la variable y ejecuta el contenido de ese caso, para luego salir de la estructura. El “caso contrario” permite poner una serie de instrucciones que se ejecutan siendo que ningún caso previo se haya ejecutado.
Según…Sea
|
Según Variable Entera Sea
Caso valor entero o rango Hacer
Instrucciones si el caso se cumple
Fin Caso;
…
[Caso contrario
Instrucciones si ningún caso se cumple
Fin Caso;]
Fin Según;
Según valor sea
Caso 0 hacer
Escribir (“El valor es 0”);
Fin Caso;
Caso 1 hacer
Escribir (“El valor es 1”);
Fin Caso;
Caso 2..10 hacer
Escribir (“El valor es mayor a 1”);
Fin Caso;
Caso Contrario
Escribir (“el valor no se encuentra entre 0 y 10”);
Fin Caso;
Fin Según;
|
Mientras…Hacer…Fin Mientras
Permite ejecutar un grupo de instrucciones mientras se cumpla una condición dada:
Mientras..Hacer
|
Mientras Expresión booleana Hacer
Instrucciones
Fin Mientras;
Acumulador <- 0;
Contador <- 1;
Mientras ( Contador <= 10 ) Hacer
Acumulador <- Acumulador + Contador;
Contador <- Contador + 1;
Fin Mientras;
|
Repetir…Hasta
Similar al anterior, solo que la condición se evalúa al final del ciclo y no al principio:
Repetir…hasta
|
Repetir
Instrucciones
Hasta Expresión booleana;
Acumulador <- 0;
Contador <- 1;
Repetir
Acumulador <- Acumulador + Contador;
Contador <- Contador + 1;
Mientras ( Contador <= 11 );
|
Desde…Hasta…[Paso]…Hacer…Fin Desde
También para ejecutar en forma repetida una serie de instrucciones; mientras la variable de control se encuentre entre los límites establecidos, la estructura seguirá repitiéndose.
Desde…Hasta
|
Desde N_var <- Val_Ini Hasta Val_fin [Incremento Inc] Hacer
Instrucciones
Fin Desde;
Desde i <- 0 Hasta 20 Incremento 1 Hacer
Acumulador <- Acumulador + i;
Fin Desde;
|
Ahora si podemos usar todo nuestro conocimiento sobre Elena para crear algunos algoritmos de ejemplo.
EJEMPLOS
Aquí tenemos unos cuantos ejemplos sobre algoritmos representados usando Elena y las capacidades descritas en este documento.
Ejemplo 1
|
Módulo Número_primo;
Entrada
Declarar número como entero;
Salida
Declarar respuesta como cadena;
Inicio
Declarar divisor, contador_divisor como variables enteras;
divisor<-0;
contador_divisor<-0;
Repetir
divisor<-divisor+1;
Si número % divisor = 0 Entonces
contador_divisor=contador_divisor+1;
Fin si;
Hasta divisor=numero;
Si contador_divisor=2 Entonces
respuesta<-”Primo”;
Caso contrario
respuesta<-”No Primo”;
Fin si;
Fin.
|
Ejemplo 2
|
Módulo dec_a_rad;
Entrada
declarar grados como real;
declarar minutos como real;
declarar segundo como real;
Salida
declarar radianes como real;
Inicio
declarar PI como constante real;
PI<-3.1416;
grados<-grados+minutos/60;
grados<-grados+segundo/3600;
radianes<-grados*PI/180;
Fin.
|
Ejemplo 3
|
Módulo Triángulo_Pascal;
Entrada
declarar pos_i, pos_j como enteros;
Salida
declarar coeficiente como real;
Usar factorial;
Inicio
declarar f, f1, f2 como variables enteras;
factorial({pos_i},{f});
factorial({pos_j},{f1});
factorial({pos_i-pos_j},{f2});
coeficiente<-f/(f1*f2);
Fin.
|
Ejemplo 4
|
Módulo factorial;
Entrada
declarar número como entero;
Salida
declarar resultado como entero;
Inicio
declarar auxiliar, cont como variables enteras;
auxiliar<-1;
Si número>0 Entonces
Desde cont=1 Hasta número Hacer
auxiliar<-factorial*cont;
Fin desde;
Fin si
resultado<-auxiliar;
Fin.
|
ANEXO A – CONCEPTOS BÁSICOS
Definición de Lenguaje
Lenguaje
Es una serie de símbolos que sirven para transmitir uno o más mensajes (ideas) entre dos entidades diferentes. A la transmisión de mensajes se le conoce comúnmente como comunicación.
Comunicación
Es un proceso complejo que requiere una serie de reglas simples, pero indispensables para poderse llevar a cabo. Las dos principales son las siguientes:
Los mensajes deben correr en un sentido a la vez.
Debe forzosamente existir 4 elementos: Emisor, Receptor, Medio de Comunicación y Mensaje.
Lenguajes de Programación
Es un conjunto de símbolos, caracteres y reglas (programas) que les permiten a las personas comunicarse con la computadora.
Los lenguajes de programación tienen un conjunto de instrucciones que nos permiten realizar operaciones de entrada/salida, calculo, manipulación de textos, lógica/comparación y almacenamiento/recuperación.
Definición de Algoritmo
La palabra algoritmo se deriva de la traducción al latín de la palabra árabe Alkhowarizmi, nombre de un matemático y astrónomo árabe que escribió un tratado sobre manipulación de números y ecuaciones en el siglo IX.
Un algoritmo es una serie de pasos organizados que describe el proceso que se debe seguir, para dar solución a un problema específico.
Definición de Lenguajes Algorítmicos
Es una serie de símbolos y reglas que se utilizan para describir de manera explícita un proceso.
Tipos de Lenguajes Algorítmicos
Gráficos: Es la representación gráfica de las operaciones que realiza un algoritmo (diagrama de flujo).
No Gráficos: Representa en forma descriptiva las operaciones que debe realizar un algoritmo (pseudocódigo).
Diseño del Algoritmo
Las características de un buen algoritmo son:
Debe tener un punto particular de inicio.
Debe ser definido, no debe permitir dobles interpretaciones.
Debe ser general, es decir, soportar la mayoría de las variantes que se puedan presentar en la definición del problema.
Debe ser finito en tamaño y tiempo de ejecución.
Codificación
La codificación es la operación de escribir la solución del problema (de acuerdo a la lógica del diagrama de flujo o pseudocódigo), en una serie de instrucciones detalladas, en un código reconocible por la computadora, la serie de instrucciones detalladas se le conoce como código fuente, el cual se escribe en un lenguaje de programación o lenguaje de alto nivel.