Programa un huevo frito y descubre la arquitectura de un computador
Dicen que no hay nada más fácil que freír un huevo. Pero todo en la vida se puede complicar lo suficiente como para que resulte interesante. Para una persona, «fríe un huevo» es una instrucción sencilla. Sabemos que hay que coger una sartén, añadir aceite, calentarlo, cascar el huevo y esperar hasta que esté hecho. Un ordenador no puede dar por supuesto ninguno de esos pasos. Ahí entra la programación.
Programar consiste, entre otras cosas, en traducir lo que queremos que haga una máquina a operaciones que pueda ejecutar. Para hacerlo utilizamos distintas capas de abstracción. En las más próximas a las personas encontramos los lenguajes de programación de alto nivel, como Python, Java o C++, que permiten expresar tareas complejas sin describir cada operación interna del procesador. A medida que descendemos de nivel, las instrucciones se vuelven más concretas y cercanas al hardware. En el extremo está el código máquina, formado por instrucciones codificadas mediante bits, que solo pueden tomar los valores 0 o 1. Esos valores representan estados físicos en los circuitos electrónicos del procesador, que los combina para almacenar datos, realizar cálculos, compararlos o decidir qué instrucción ejecutar a continuación.
Para programar nuestro huevo frito, empezaremos con una orden cotidiana y la iremos traduciendo paso a paso hasta llegar al código máquina. Por el camino veremos qué diferencia hay entre un algoritmo y un programa, qué significa programar a alto o bajo nivel y por qué una instrucción que parece sencilla puede convertirse en muchas operaciones diferentes. Empecemos por lo más fácil: ordenar los pasos necesarios para freír un huevo.
De una receta a un algoritmo
> TAREA CARGADA: FREIR UN HUEVO
> ORDENA LAS INSTRUCCIONES
Una persona entiende la orden «fríe un huevo». Un ordenador necesitaría que la tarea estuviera dividida en pasos y colocada en el orden correcto.
[ PROGRAMA COMPLETADO ]
.-------.
.-' '-.
/ ( ) \
| |
\ /
'-------------'
HUEVO FRITO.OK
Has convertido una intención en una secuencia ordenada de instrucciones.
Eso se parece a un algoritmo: una serie de pasos definidos para resolver una tarea. Todavía no hemos escrito código.
Ya hemos hecho algo fundamental: convertir una intención general en una secuencia ordenada de instrucciones. Eso es, en esencia, un algoritmo: una serie de pasos definidos para resolver una tarea. Pero todavía no hemos programado ningún ordenador. Para eso necesitamos expresar nuestro algoritmo mediante un lenguaje que pueda ser traducido posteriormente a instrucciones ejecutables por una máquina.
Los lenguajes de programación de alto nivel están pensados precisamente para facilitar ese trabajo. Permiten describir operaciones de una forma relativamente próxima a nuestra manera de razonar y esconden muchos de los detalles internos del ordenador. Una orden como freir_huevo() podría representar, por ejemplo, todo el conjunto de acciones que acabamos de ordenar.
Vamos a escribir nuestro primer programa
> MODO: LENGUAJE DE ALTO NIVEL
> PROGRAMA: HUEVO_FRITO
Esta única instrucción puede esconder muchos pasos. Completa las dos condiciones para que el programa funcione.
╔══════════════════════════════╗
║ PROGRAM EXECUTED ║
║ ║
║ HIGH LEVEL ║
║ OK ║
╚══════════════════════════════╝
Has utilizado una condición: el programa repite una acción mientras se cumple una determinada situación.
Lo importante es que todavía podemos leer el programa y comprender aproximadamente qué quiere hacer. En el siguiente nivel empezaremos a quitarle comodidad.
Nuestro programa ya tiene condiciones y repeticiones: espera mientras el aceite no está caliente y vuelve a comprobar si la clara sigue líquida. Para una persona, expresiones como esperar() o clara_liquida son fáciles de interpretar. El procesador, sin embargo, no sabe qué significa «esperar» ni qué entendemos por «caliente». Para acercarnos a su forma de trabajar tenemos que empezar a desmontar esas órdenes y condiciones en operaciones mucho más concretas.
Supongamos que una máquina dispone de un sensor capaz de medir la temperatura del aceite. «Espera hasta que esté caliente» podría transformarse entonces en una serie de acciones: leer el sensor, guardar el valor obtenido, compararlo con una temperatura determinada y decidir qué hacer después según el resultado. Cuanto más descendemos hacia el funcionamiento de la máquina, menos cosas podemos dar por supuestas.
Leer, guardar, comparar y saltar
> DESCENDIENDO NIVEL DE ABSTRACCION…
> MODO: ACERCANDONOS AL PROCESADOR
El procesador necesita convertir esa idea en operaciones mucho más pequeñas. En esta simulación utilizaremos un sensor para medir la temperatura y el registro R1 como memoria temporal. Selecciona las instrucciones en el orden correcto.
SISTEMA PREPARADO
______
| |
| CPU |
|______|
|
|
__|__
|_____|
╔══════════════════════════════╗
║ PROGRAMA COMPLETO ║
║ ║
║ TEMPERATURA: OK ║
╚══════════════════════════════╝
Acabas de utilizar tres ideas fundamentales: un registro, una comparación y un salto.
Ya no hemos escrito simplemente «espera». Hemos indicado dónde guardar el dato, con qué valor compararlo y qué debe hacer el programa según el resultado.
SISTEMA PREPARADO
______
| |
| CPU |
|______|
|
|
__|__
|_____|
SENSOR DE TEMPERATURA
.----------.
| SENSOR |
|----------|
| 162 C |
| |
| || |
| || |
| ( ) |
'----------'
|
|
_____|_____
/ \
/~~~~~~~~~~~~~\
ACEITE CALENTANDOSE
.----------------.
.-' '-.
/ ~ ~ ~ \
| ~ ~~~ ~~~ |
| ~ ~ ~ |
\ /
'----------------------'
||||||||||
||||||||||
FUEGO
NUEVA LECTURA
.----------.
| SENSOR |
|----------|
| 181 C |
| |
| || |
| || |
| ( ) |
'----------'
|
|
_____|_____
/ ~ ~ ~ ~ ~ \
/~~~~~~~~~~~~~\
TEMPERATURA CORRECTA
~ ~ ~
~ ~
.----------------.
.-' '-.
/ ~ ~ ~ ~ \
| ~ ~ ~ ~ ~ ~ |
\ /
'----------------------'
||||||||||
||||||||||
CONTINUAR PROGRAMA
~ ~
~
.----------------.
.-' '-.
/ .--------. \
| .' '. |
| / O \ |
| \ / |
\ '----------' /
'----------------------'
||||||||||
||||||||||
HUEVO EN MARCHA
ERROR DE SECUENCIA
.--------.
| ERROR |
'--------'
||
___||___
/ \
/ X X \
| __ |
\ /
'--------'
REVISA LAS INSTRUCCIONES
Ahora ya hemos manejado algunas de las operaciones básicas con las que trabaja un procesador: guardar un dato, compararlo y decidir qué instrucción ejecutar a continuación. Sin embargo, hasta aquí, hemos utilizado una representación simplificada para entender el proceso. Un lenguaje de bajo nivel real utiliza una sintaxis mucho más estricta. Uno de ellos es el lenguaje ensamblador.
En CODE-2, la arquitectura utilizada para enseñar estos conceptos en la UMH, la orden «suma el contenido de R1 y R2 y guarda el resultado en R3» se escribe:
ADDS r3,r1,r2
R1, R2 y R3 son registros: pequeñas zonas de almacenamiento situadas en el propio procesador. ADDS indica la operación que debe realizar.
Para nosotros, esa instrucción ya resulta bastante menos intuitiva que freir_huevo(). Sin embargo, el procesador todavía no recibe palabras como ADDS ni nombres como R1. El ensamblador sigue siendo una representación creada para que las personas podamos trabajar con las instrucciones de la máquina. De manera que todavía queda una traducción más. Para hablar como el procesador, tienen que desaparecer las palabras.
Hablar en 16 bits
Hasta ahora hemos utilizado números como 1, 2, 3 o 180 escritos en el sistema decimal, el que usamos habitualmente y que dispone de diez cifras, del 0 al 9. Los ordenadores pueden representar esos mismos números mediante el sistema binario, que solo utiliza dos valores: 0 y 1.
La clave está en la posición. En decimal, una cifra puede representar unidades, decenas o centenas. En binario ocurre algo parecido, pero cada posición vale el doble que la anterior. Si utilizamos cuatro posiciones, sus valores son, de derecha a izquierda:
8 · 4 · 2 · 1
Para escribir un número, basta con indicar con un 1 qué valores necesitamos y con un 0 cuáles no. Por ejemplo, para representar el número 3 necesitamos sumar 2 + 1:
0 · 0 · 1 · 1 → 0011
El 5 se obtiene con 4 + 1:
0 · 1 · 0 · 1 → 0101
Y el 6, con 4 + 2:
0 · 1 · 1 · 0 → 0110
Con cuatro bits podemos formar 16 combinaciones diferentes, desde 0000 hasta 1111.
Vamos a utilizar esa idea en una pequeña cocina informática. Nuestro Kitchen Computer ha asignado un número a cuatro órdenes: preparar, calentar, cocinar y servir. Esos números son una convención del juego; lo importante es descubrir cómo convertir cada uno en un grupo de cuatro bits.
Cuando hayas traducido las cuatro órdenes, tendrás cuatro grupos de cuatro bits. Juntos formarán una secuencia de 16 bits de información.
> DE ÓRDENES A 16 BITS
V
PREPARAR CALENTAR COCINAR SERVIR
| | | |
3 5 6 9
| | | |
0011 0101 0110 1001
\ \ / /
\ \ / /
'-------------+---------+-------------'
|
V
0011010101101001
|
V
.---------------------.
| KITCHEN COMPUTER |
| |
| EXECUTE |
'---------------------'
|
V
__________
.-' '-.
.' () '.
/ \
'--------------------'
En el juego hemos hecho una versión simplificada de este proceso: hemos partido de cuatro órdenes, les hemos asignado números y hemos convertido cada número en un grupo de cuatro bits. Al unirlos, hemos obtenido una secuencia de 16 bits.
CODE-2 también construye sus instrucciones combinando campos de bits, aunque cada uno tiene un significado concreto. Volvamos a nuestra instrucción:
ADDS r3,r1,r2
Los registros son fáciles de reconocer ahora. R3 corresponde al número 3 y, por tanto, puede representarse como 0011; R1 como 0001; y R2 como 0010.
Con ADDS ocurre algo diferente. No hay ninguna suma que nos permita deducir su código. Cada arquitectura decide qué patrón de bits identifica cada operación. En el repertorio de instrucciones de CODE-2, ADDS tiene asignado el código 0110.
Ya podemos reunir las cuatro piezas:
0110 | 0011 | 0001 | 0010
El primer grupo identifica la operación ADDS; los tres siguientes indican los registros que intervienen: R3, R1 y R2. Juntos forman una instrucción de 16 bits:
0110001100010010
Por tanto, ADDS r3,r1,r2 y 0110 0011 0001 0010 no son dos instrucciones diferentes. Son dos representaciones de la misma orden. La primera está escrita en lenguaje ensamblador y utiliza nombres y símbolos que una persona puede leer con relativa facilidad. La segunda es su codificación en lenguaje máquina.
¿Significa esto que dentro del ordenador circulan literalmente ceros y unos? No. Los ceros y unos son una forma de representar dos estados físicos. Un procesador contiene miles de millones de transistores que, combinados en circuitos, permiten distinguir y manipular esos estados.
A partir de operaciones extremadamente sencillas, esos circuitos pueden almacenar información, realizar cálculos, comparar valores y decidir qué instrucción ejecutar a continuación. Millones o miles de millones de estas operaciones realizadas a enorme velocidad hacen posible todo lo que vemos en la pantalla.
Nuestro huevo ha recorrido así todo el camino: comenzó como una intención expresada con palabras, pasó por instrucciones que una persona puede leer y terminó convertido en una secuencia de bits que el procesador puede ejecutar. Solo falta comprobar el resultado.
Huevo_frito.exe
Imprime tu huevo frito
Has llegado al final. Ahora el sistema traduce tu receta a una salida de impresora matricial. Cada vez que pulses, obtendrás una versión distinta del universo del huevo.
LISTA PARA IMPRIMIR. PULSA "IMPRIMIR" PARA GENERAR UNA SALIDA.
De una idea a una máquina
Evidentemente, el ordenador nunca ha sabido qué es un huevo frito. Tampoco ha entendido una receta como la entenderíamos nosotros. Lo que ha hecho es ejecutar una sucesión de operaciones cada vez más elementales.
La programación moderna permite que normalmente no tengamos que pensar en todos esos niveles. Los lenguajes de alto nivel ocultan gran parte de la complejidad que existe debajo y permiten concentrarse en el problema que queremos resolver. Entre una orden escrita por una persona y las señales eléctricas que circulan por un procesador pueden intervenir compiladores, ensambladores y otras capas de traducción.
Aprender qué ocurre cuando descendemos por esas capas permite entender algo fundamental: un ordenador puede ejecutar tareas extraordinariamente complejas, pero en el fondo todas ellas se construyen a partir de operaciones muy simples.
Uso educativo en la Comunitat Valenciana
Este minijuego puede utilizarse en ESO, especialmente en Tecnología y Digitalización y en las optativas Programación, Inteligencia Artificial y Robótica I y II, incluidas en el currículo de la Generalitat Valenciana. Permite trabajar el pensamiento computacional, los algoritmos, la secuenciación de instrucciones, las estructuras de control y la programación mediante una actividad breve y contextualizada que puede integrarse en una situación de aprendizaje y utilizarse también como evaluación formativa.
Para aprender más
- Stanford CS101: machine code, assembly y CPU
- Intel: The Transistor, Explained
- IBM: What is a Compiler?
Agradecemos al profesor de Arquitectura y Tecnología de Computadores de la UMH Federico García Crespi su colaboración en la revisión científica de este juego.