Introducción a la Computación

Esta presentación es audiovisual

El Software

Lenguajes de bajo nivel

Lenguaje de máquina

Códigos binarios de instrucciones y datos
Direcciones de los datos en cinco bits
Desplazamientos de saltos en forma numérica

Lenguaje ensamblador o Assembler

Mnemónicos en lugar de códigos binarios
Rótulos o etiquetas como referencia de las direcciones
Rótulos o etiquetas como referencia de los saltos

## Lenguajes de bajo nivel ### Lenguaje de máquina o código máquina Hemos visto un conjunto de instrucciones y convenciones sobre cómo se utilizan los datos en el MCBE, que es el llamado **lenguaje de máquina** del MCBE. En este lenguaje, las operaciones y los datos se escriben como secuencias de dígitos binarios. Por supuesto, escribir un programa para el MCBE y **depurarlo**, es decir, identificar y corregir sus errores, es una tarea muy dificultosa, porque los códigos de operación, las direcciones y los datos, fácilmente terminan confundiéndonos. Para facilitar la programación, se ha definido un lenguaje alternativo llamado el **ensamblador** del MCBE. ### Lenguaje ensamblador Cuando escribimos un programa en el lenguaje **ensamblador** del MCBE, las instrucciones se corresponden una a una con las del programa en lenguaje de máquina. Pero en el lenguaje ensamblador del MCBE: * En lugar de códigos de tres bits usamos unas abreviaturas un poco más significativas (llamadas los **mnemónicos** de las instrucciones). * En lugar de direcciones de cinco bits para los datos, usamos unos nombres simbólicos (**rótulos o etiquetas**) que hacen referencia a esas direcciones. * Para las instrucciones de salto, en lugar de desplazamientos, también usamos rótulos o etiquetas para indicar la instrucción del programa adonde deseamos saltar. Cada CPU del mundo real tiene su propio lenguaje de máquina, y aunque mucho más poderosos y de instrucciones más complejas, se parecen bastante, en líneas generales, al lenguaje de máquina del MCBE. Igual que ocurre con el lenguaje de máquina, cada CPU del mundo real tiene su propio lenguaje ensamblador, basado en los mismos principios que el que mostramos aquí. El lenguaje de máquina de cualquier CPU, y su lenguaje ensamblador (o *Assembler*), son llamados en general **lenguajes de bajo nivel**.

Lenguaje Ensamblador

Mnemónico		Instrucción
LD	Load (cargar)	010	Mem → Ac
ST	Store (almacenar)	011	Ac → Mem
ADD	Add (sumar)	100	Ac ← Ac + Mem
SUB	Subtract (restar)	101	Ac ← Ac - Mem
JMP	Jump (saltar)	110	PC ← PC + despl
JZ	Jump if Zero (saltar si cero)	111	Ac == 0 ⇒ PC ← PC + despl
HLT	Halt (detener)	001	Parada
NOP	No Operation	000	No operación

Mnemónicos y rótulos

Lenguaje de máquina
Dirección	Instrucción
00000	01000111
00001	11100100
00010	01111111
00011	10100110
00100	11011101
00101	00100000
00110	00000001
00111	00000011

Lenguaje ensamblador
Dirección	Rótulo	Mnemónico	Argumento
00000		LD	CANT
00001	SIGUE:	JZ	FIN
00010		ST	OUT
00011		SUB	UNO
00100		JMP	SIGUE
00101	FIN:	HLT
00110	UNO:	1
00111	CANT:	3

### Rótulos Cuando necesitamos hacer referencia a una dirección, como en las operaciones de transferencia o en las aritméticas, el ensamblador nos permite independizarnos del valor de esa dirección y simplemente indicar un **nombre simbólico o rótulo** para esa dirección. Así, un rótulo equivale en lenguaje ensamblador a la **dirección de un dato**. Para que el programa quede completo, ese nombre simbólico debe aparecer en algún lugar del programa, al principio de la instrucción, y separado por un carácter ":" del resto de la línea. **Ejemplo** Dirección | Instrucción | Rótulo | Mnemónico | Argumento ----------|-------------|--------:|-----------|---------- 00000 | 01000111| | LD | CANT 00001 | 11100100|SIGUE: | JZ | FIN 00010 | 01111111| | ST | OUT 00011 | 10100110| | SUB | UNO 00100 | 11011101| | JMP | SIGUE 00101 | 00100000|FIN: | HLT | 00110 | 00000001|UNO: | 1 | 00111 | 00000011|CANT: | 3 | En este ejemplo, SIGUE, FIN, UNO y CANT son rótulos. El rótulo CANT, por ejemplo, nos permite referirnos en la primera instrucción, LD CANT, a un dato declarado más adelante con ese nombre. Del mismo modo, cuando la instrucción es de salto, podemos hacer referencia a la posición de memoria donde se hará el salto usando un rótulo, como en la quinta instrucción, JMP SIGUE. ### Rótulos en instrucciones de salto Es importante recordar que, de todas maneras, en la traducción de ensamblador a lenguaje de máquina **para las instrucciones de salto**, el rótulo se sustituye por un **desplazamiento**, y no por una dirección. **Ejemplo** - En el ejemplo existe un rótulo SIGUE que identifica a la instrucción en la posición 1. La instrucción del ejemplo JMP SIGUE, al ser ejecutada, deriva el control a la instrucción 1. Es decir, almacena un 1 en el registro PC, para que la siguiente iteración del ciclo de instrucción ejecute la instrucción en la dirección 1 de la memoria. Sin embargo, el argumento para la instrucción JMP **no vale 1** sino **-3**, como podemos corroborar en la columna "Instrucción" de la tabla. ### Rótulos predefinidos Los rótulos IN y OUT vienen predefinidos en el lenguaje ensamblador de MCBE y corresponden a las posiciones de memoria 30 (para entrada) y 31 (para salida) respectivamente. **Ejemplo** La instrucción en línea 2, ST OUT, almacena el contenido del acumulador en la posición 31, lo que equivale a escribir ese contenido en la salida del MCBE.

Traductores

Un programa

Recibe datos, opera con ellos y genera un resultado o salida

Un programa traductor

Recibe datos que son a su vez un programa en algún lenguaje de programación
Su resultado o salida es a su vez un programa en algún otro lenguaje de programación

## Traductores Uno puede pensar en un programa cualquiera como si se tratara de una máquina, cuyo funcionamiento es, en principio, desconocido. Todo lo que vemos es que, si introducimos ciertos datos, de alguna forma esta "máquina" devolverá un resultado. Si pensamos en una clase especial de estos programas, donde los datos que ingresan son a su vez un programa, y donde la salida devuelta por la máquina es, a su vez, un programa, entonces esa clase especial de programas son los **traductores**. ## Ensambladores Como hemos dicho anteriormente, una CPU como el MCBE sólo sabe ejecutar instrucciones de código máquina expresadas con unos y ceros. Cuando vimos el lenguaje ensamblador del MCBE lo propusimos simplemente como una forma de abreviar las instrucciones de máquina, o como una forma de facilitar la escritura, porque los mnemónicos y rótulos eran más fáciles de memorizar y de leer que las instrucciones con unos y ceros. Sin embargo, un programa escrito en ensamblador del MCBE podría ser traducido automáticamente, por un traductor, a código de máquina MCBE, ahorrándonos mucho trabajo y errores. Esta clase de traductores, que reciben un programa en lenguaje ensamblador y devuelven un programa en código de máquina, son los llamados **ensambladores** o **assemblers**.

Ensamblador x86


.globl  _start
.text				# seccion de codigo
_start:
        movl    $len, %edx	# carga parametros longitud
        movl    $msg, %ecx	# y direccion del mensaje
        movl    $1, %ebx        # parametro 1: stdout
        movl    $4, %eax        # servicio 4: write
        int     $0x80		# syscall

        movl    $0, %ebx        # retorna 0
        movl    $1, %eax        # servicio 1: retorno de llamada
        int     $0x80		# syscall
.data				# seccion de datos
msg:
        .ascii  "Hola, mundo!\n"
        len =   . - msg		# longitud del mensaje

### Ensamblador x86 Cada CPU tiene su propio lenguaje ensamblador, y existen programas traductores (ensambladores) para cada una de ellas. Por ejemplo, la familia de procesadores de [Intel](https://es.m.wikipedia.org/wiki/Intel_Corporation) para computadoras personales comparte el mismo ISA, o arquitectura y conjunto de instrucciones. Cualquiera de estos procesadores puede ser programado usando un ensamblador para la familia **x86**. Según la tradición, el primer programa que uno debe intentar escribir cuando comienza a aprender un lenguaje de programación nuevo es "Hola mundo". Es un programa que simplemente escribe esas palabras por pantalla. Aquí mostramos el clásico ejemplo de "Hola mundo" en el lenguaje ensamblador de la familia x86. ~~~~ .globl _start .text # seccion de codigo _start: movl $len, %edx # carga parametros longitud movl $msg, %ecx # y direccion del mensaje movl $1, %ebx # parametro 1: stdout movl $4, %eax # servicio 4: write int $0x80 # syscall movl $0, %ebx # retorna 0 movl $1, %eax # servicio 1: retorno de llamada int $0x80 # syscall .data # seccion de datos msg: .ascii "Hola, mundo!\n" len = . - msg # longitud del mensaje ~~~~

Procesador x86

Ensamblador ARM


.global main  
main:  
    @ Guarda la direccion de retorno lr 
    @ mas 8 bytes para alineacion
    push    {ip, lr}  
    @ Carga la direccion de la cadena y llama syscall
    ldr     r0, =hola
    bl      printf  
    @ Retorna 0
    mov     r0, #0 
    @ Desapila el registro ip y guarda
    @ el siguiente valor desapilado en el pc 
    pop     {ip, pc}  
hola:  
    .asciz "Hola, mundo!\n"

### Ensamblador ARM Por supuesto, los procesadores de familias diferentes tienen conjuntos de instrucciones diferentes. Así, un lenguaje y un programa ensamblador están ligados a un procesador determinado. El código máquina producido por un ensamblador no puede ser trasladado sin cambios a otro procesador que no sea aquel para el cual fue ensamblado. Las instrucciones de máquina tendrán sentidos completamente diferentes para uno y otro. Por eso, el código máquina producido por un ensamblador para x86 no puede ser trasladado directamente a una computadora basada en un procesador como, por ejemplo, [ARM](https://es.m.wikipedia.org/wiki/Arquitectura_ARM); sino que el programa original, en ensamblador, debería ser **portado** o traducido al ensamblador propio de ARM, por un programador, y luego ensamblado con un ensamblador para ARM. ~~~~ .global main main: @ Guarda la direccion de retorno lr @ mas 8 bytes para alineacion push {ip, lr} @ Carga la direccion de la cadena y llama syscall ldr r0, =hola bl printf @ Retorna 0 mov r0, #0 @ Desapila el registro ip y guarda @ el siguiente valor desapilado en el pc pop {ip, pc} hola: .asciz "Hola, mundo!\n" ~~~~

Procesador ARM

Ensamblador PowerPC


.data			  # seccion de variables
msg:
	.string "Hola, mundo!\n"
	len = . - msg	  # longitud de cadena
.text			  # seccion de codigo
	.global _start
_start:
	li 	0,4 	   # syscall sys_write
	li 	3,1	   # 1er arg: desc archivo (stdout)
			   # 2do arg: puntero a mensaje
	lis 	4,msg@ha   # carga 16b mas altos de &msg
	addi 	4,4, msg@l # carga 16b mas bajos de &msg
	li 	5,len	   # 3er arg: longitud de mensaje
	sc		   # llamada al kernel
# 
	li 	0,1	   # syscall sys_exit
	li 	3,1	   # 1er arg: exit code
	sc		   # llamada al kernel

Procesador PowerPC

Lenguajes de programación

Orientación a la máquina o al problema

Lenguaje de alto nivel

DEUDA = DEUDA - PAGO

Ensamblador

LD DEUDA; SUB PAGO; ST DEUDA

Código de máquina

01001010; 01101011; 10101010

## Lenguajes de programación ### Lenguajes de bajo nivel Como vemos, tanto el lenguaje de máquina como el ensamblador o **Assembler** son lenguajes **orientados a la máquina**. Ofrecen control total sobre lo que puede hacerse con un procesador o con el sistema construido alrededor de ese procesador. Por este motivo son elegidos para proyectos de software donde se necesita dialogar estrechamente con el hardware, como ocurre con los sistemas operativos. Sin embargo, como están ligados a un procesador determinado, requieren conocimiento profundo de dicho procesador y resultan poco **portables**. Escribir un programa para resolver un problema complejo en un lenguaje de bajo nivel suele ser muy costoso en tiempo y esfuerzo. ### Lenguajes de alto nivel Otros lenguajes, los de **alto nivel**, ocultan al usuario los detalles de la arquitectura de las computadoras y le facilitan la programación de problemas de software complejos. Son más **orientados al problema**, lo que quiere decir que nos aíslan de cómo funcionan los procesadores o de cómo se escriben las instrucciones de máquina, y nos permiten especificar las operaciones que necesitamos para resolver nuestro problema en forma más parecida al lenguaje natural, matemático, o humano. Una ventaja adicional de los lenguajes de alto nivel es que resultan más portables, y su **depuración** (el proceso de corregir errores de programación) es normalmente más fácil.

Niveles de lenguajes

Paradigmas de lenguajes de programación

Imperativo

Seguir una lista de órdenes o comandos

Lógico o declarativo

Responder una pregunta buscando una solución

Funcional

Evaluar una expresión y utilizar el resultado

Orientación a objetos

Comunicar mensajes entre objetos simulando una parte del mundo real

1. Paradigma imperativo

Lenguaje C


int factorial(int n)
{
	int f = 1;
	while (n > 1) {
		f *= n;
		n--;
	}
	return f;
}

2. Paradigma lógico

Lenguaje Prolog


factorial(0,X):- X=1.
factorial(N,X):- N1=N-1, factorial(N1,X1), X=X1*N.
factorial(N):- factorial(N,X), write(X).

### Paradigma lógico o declarativo El lenguaje Prolog representa el paradigma lógico y con frecuencia constituye el corazón de los sistemas de Inteligencia Artificial que realizan **razonamiento**. La definición de **factorial** en lenguaje Prolog que mostramos se compone de un hecho y dos reglas. El hecho consiste en que el **factorial** de 0 vale 1. La primera regla expresa que el factorial de un número **N** se calcula como el factorial de **N-1** multiplicado por N. Es una definición **recursiva** porque la definición de la regla se utiliza a sí misma. ~~~~ factorial(0,X):- X=1. factorial(N,X):- N1=N-1, factorial(N1,X1), X=X1*N. factorial(N):- factorial(N,X), write(X). ~~~~ El usuario de este programa puede usarlo de dos maneras. Podría preguntar el valor del factorial de un número N, o consultar si es cierto que el factorial de N es otro número dado Y.

3. Paradigma funcional

Lenguaje Lisp


(defun factorial (n)
  (if (= n 0)
      1
      (* n (factorial (- n 1))) ) )

4. Paradigma orientado a objetos

Lenguaje Python


class Combinatoria():
    def factorial(self,n): 
        num = 1
        while n > 1:
            num = num * n
            n = n - 1
        return num

c = Combinatoria()
a = c.factorial(3)
print a

### Orientación a objetos En un lenguaje **orientado a objetos**, definimos una **clase** que funciona como un molde para crear múltiples instancias de objetos que se parecen entre sí, ya que tienen los mismos datos que los componen y la misma funcionalidad. Los objetos creados se comunican entre sí por **mensajes**, disparando **métodos** o conductas de otros objetos. ~~~~ class Combinatoria(): def factorial(self,n): num = 1 while n > 1: num = num * n n = n - 1 return num c = Combinatoria() a = c.factorial(3) print a ~~~~ En el ejemplo de programación orientada a objetos en Python, definimos una clase **Combinatoria** que producirá objetos con la conducta **factorial**. El programa crea un objeto, instancia de la clase Combinatoria, llamado **c**, al cual se le envía el mensaje **factorial**, que dispara la conducta correspondiente especificada en el método del mismo nombre. Finalmente se imprime su valor.

Traductores

Compiladores

Traducen un programa fuente en un ejecutable en código máquina
La ejecución queda diferida para un momento posterior

Intérpretes

Traducen y ejecutan línea por línea un programa fuente
Traducción y ejecución son concurrentes

Traductores

Compiladores

La ejecución de un programa compilado es tan rápida como es posible
El programa queda compilado para una única arquitectura

Intérpretes

La ejecución del programa comparte la CPU con la traducción del fuente
El mismo programa fuente puede correr sin modificaciones en varias arquitecturas

### Velocidad de ejecución - Una ventaja comparativa de la compilación respecto de la interpretación es la mayor velocidad de ejecución. Al separar las fases de traducción y ejecución, un compilador alcanza la máxima velocidad de ejecución posible en un procesador dado. - Por el contrario, un intérprete alterna las fases de traducción y ejecución, por lo cual la ejecución completa del mismo programa tardará algo más de tiempo. ### Portabilidad - El código interpretado presenta la ventaja de ser directamente portable. Dos plataformas diferentes podrán ejecutar el mismo programa interpretable, siempre que cuenten con intérpretes para el mismo lenguaje. - Por el contrario, un programa compilado está en el código de máquina de alguna arquitectura específica, así que no será compatible con otras.

Terminología

Compilador
Archivo fuente
Archivo objeto
Bibliotecas
Programa ejecutable

## Ciclo de compilación ### Terminología - Cuando utilizamos un **compilador** para obtener un programa **ejecutable**, el programa que nosotros escribimos, en algún lenguaje, se llama **programa fuente**, y estará generalmente contenido en algún **archivo fuente**. - El resultado de la traducción será un archivo llamado **objeto** conteniendo las instrucciones de código máquina equivalentes. - Sin embargo, este archivo objeto puede no estar completo, ya que el programador puede hacer uso de rutinas o funciones que vienen provistas con el sistema, y no necesita especificar cómo se realizan esas funciones. - Al no aparecer en el programa fuente, esas funciones no aparecerán en el archivo objeto. - Por ejemplo, cualquier programa "Hola Mundo", en cualquier lenguaje, imprime en pantalla un mensaje; pero la acción de imprimir algo en pantalla no es trivial ni sencilla, y la explicación de cómo se hace esta acción **no está contenida en esos programas**. En su lugar, existe una llamada a una función de impresión cuya definición reside en algún otro lugar. - Ese otro lugar donde están definidas funciones disponibles para el programador son las **bibliotecas**. Las bibliotecas son archivos conteniendo grupos o familias de funciones. - El proceso de **vinculación**, que es posterior a la traducción, debe buscar en esas bibliotecas la definición de las funciones faltantes en el archivo objeto. - Si la vinculación resulta exitosa, el resultado final es un programa **ejecutable**.

Esta presentación es audiovisual

El Software

Lenguajes de bajo nivel

Lenguaje Ensamblador

Mnemónicos y rótulos

Traductores

Ensamblador x86

Procesador x86

Ensamblador ARM

Procesador ARM

Ensamblador PowerPC

Procesador PowerPC

Lenguajes de programación

Niveles de lenguajes

Paradigmas de lenguajes de programación

1. Paradigma imperativo

Lenguaje C

2. Paradigma lógico

Lenguaje Prolog

3. Paradigma funcional

Lenguaje Lisp

4. Paradigma orientado a objetos

Lenguaje Python

Traductores

Traductores

Terminología

Ciclo de compilación

Ciclo de compilación

Ciclo de compilación

Ciclo de compilación

Ciclo de compilación

Ciclo de compilación

Ciclo de compilación

Entorno integrado de desarrollo (IDE)

Referencias