La Sombra de Dijkstra

Una buena idea

ediaz — Fri, 29 Jul 2011 11:23:04 +0000

GIT es una gran herramienta de control de versiones distribuido, podemos trabajar en la casa y en la oficina y sincronizar nuestros repositorios de código fuente. Pero está siempre el problema de donde alojar un servidor central donde colocar nuestro repositorio.

GitHub permite arrendar espacio en sus servidores para alojar nuestros repositorios, y hay otros servicios por ahí. Pero una alternativa bastante ingeniosa es usar DropBox, alojar nuestros repositorios en la carpeta compartida de Dropbox, crear repositorios limpios (bare repositories) y hacer git pull/pull localmente sobre esa carpeta compartida. La idea aparece en este post (en inglés), y es bastante simple y potente.

Supongo que esto también puede servir con otros gestores de control de versiones, como Mercurial o Bzr, pero incluso es una buena idea que se podría aplicar con gestores más tradicionales como Subversion. Si alguien lo implementa con esos sistemas lo invito a comentar y compartir la experiencia.

Capítulo 20, dispositivos

ediaz — Sun, 24 Jul 2011 00:57:12 +0000

Ya se encuentra disponible el capítulo 20 de nuestro curso de programación, dispositivos.

http://www.programando.org/aprende-a-programar/segunda-parte/arquitectura-de-computadores/dispositivos.html

Este capítulo cierra la parte dedicada a la arquitectura de computadores. A continuación retomaremos el objetivo de la segunda parte del curso, que es construir una versión gráfica de nuestro juego.

Capitulo 19, interpretando el código de máquina

ediaz — Wed, 22 Jun 2011 02:40:53 +0000

He completado el capitulo 19 del curso. Tal como les adelanté, estoy usando el nuevo formato para el curso, así que para leerlo deben ir a la siguiente dirección:

http://www.programando.org/aprende-a-programar/segunda-parte/arquitectura-de-computadores/interpretando-el-codigo-de-maquina.html

En este capítulo implemento el interprete del lenguaje assembler que hemos definido para nuestra máquina virtual (definida en el capítulo 17: Código de Máquina).

Lo interesante es que implementamos un interprete de una forma totalmente funcional, lo que permite mayor flexibilidad y un código más simple y “mantenible”.

Los comentarios los pueden dejar en este post.

Disculpas por la demora, vamos a retomar el ritmo del curso en estas semanas.

Nueva versión del curso

ediaz — Wed, 08 Jun 2011 03:45:04 +0000

Ya terminé la traducción a Sphinx de los posts del curso, los 18 capítulos publicados hasta ahora se encuentran en su nuevo formato, pueden acceder en esta dirección: http://www.programando.org/aprende-a-programar/

En los próximos días retomo los capítulos que siguen. Dado que a partir de ahora sólo usaré sphinx para escribir el curso usaremos el blog para anunciar la incorporación de nuevos capítulos, y para que ustedes hagan sus comentarios.

Esta es la versión 0.1a del texto, agradeceré sus comentarios y correcciones. El layout, estilo gráfico irá cambiando, está con las opciones por default. Además faltan varios elementos de indexado. Si algún lector conoce Sphinx y quiere ayudarme en crear los marcadores para los índices agradeceré su colaboración.

Cambio de formato

ediaz — Mon, 16 May 2011 02:09:34 +0000

He recibido algunos comentarios en el sentido de que es dificil seguir el curso de programación en el blog. Efectivamente, cuando uno está leyendo un tutorial o curso se hace necesario poder seguir el orden de los capítulos, acceder a la tabla de contenidos y saber que viene antes y que viene después. El formato del blog no permite esto. Así que con el fin de remediar esta incomodidad he decidido traspasar el texto del curso a un formato distinto.

He decidido que voy a usar Sphinx, una herramienta bastante popular entre los desarrolladores Pyhton, de hecho es usada para escribir la documentación de Python.

Esto tiene varias ventajas adicionales, entre otras:

Podré mantener el texto en un repositorio Git.
Es facil con Sphinx generar otros formatos, como PDF, por ejemplo.
Permitirá separar el contenido del blog con el del curso.

Así que les pido un poco de paciencia, mientras hago este cambio, pronto retomaremos el curso. Lo bueno es que podremos tocar otros temas en el blog.

Cargando el código de máquina

ediaz — Wed, 27 Apr 2011 12:01:45 +0000

Si recuerdan en el capítulo anterior, de nuestro curso de programación, definimos una máquina virtual con un código, o lenguaje de máquina bien preciso. En el diagrama sin embargo aparece una componente que no explicamos, se trata del módulo loader. Acá está la figura para que la recuerden:

El módulo loader se encarga de cargar un programa, escrito en el lenguaje ensamblador, a la memoria de nuestra máquina virtual, para su posterior ejecución.

Si recuerdan, uno de los ejemplos que vimos es este programa ensamblador que despliega la tabla de multiplicad del 5:

```
AR0
```
```
5
```
```
AR1
```
```
0
```
```
INCR1
```
```
RMUL
```
```
IMPR
```
```
RES
```
```
50
```
```
SSC
```
```
13
```
```
SALTA
```
```
4
```
```
ALTO
```

Notarán algunos cambios. Las lineas las empezamos a contar a partir de cero (0), esto obliga a modificar las direcciones de los saltos.La función del módulo loader es traducir de este lenguaje con instrucciones y números al código binario que entiende la máquina.

Para programar nuestra máquina virtual escribiremos varios programas en archivos, al igual como lo hacemos con nuestros programas en python. Si los archivos que contienen código en python los grabamos con la extensión ‘.py’, nuestros programas los almacenaramos en archivos con la extensión ‘.a’, por assembler.

En cada linea de estos archivos escribiremos las instrucciones o números de nuestro programa. El programa de arriba se almacena en un archivo que llamaremos ‘tabla_cinco.a’, es importante notar que este archivo no lleva los números. El contenido del archivo sería el siguiente:

AR0 5 AR1 0 INCR1 RMUL IMPR RES 50 SSC 13 SALTA 4 ALTO

Una instrucción por linea. A las instrucciones también se les llama códigos nemotécnicos, o simplemente nemónicos. AR1 es un nemónico que significa ‘almacena el valor que sigue en el registro R1′

Los nemónicos en nuestro lenguaje ensamblador están resumidos en esta tabla:

0: ALTO
1: LIM
2: ACUM
3: MUL
4: RES
5: DIV
6: IMPR
7: LEER
8: ALM
9: RR0
10: RR1
11: RSUM
12: RMUL
13: RRES
14: RDIV
15: AR0
16: AR1
17: INC
18: DEC
19: INCR0
20: DECR0
21: INCR1
22: DECR1
23: SALTA
24: SSC
25: SSN
26: SSN
27: SRMA
28: SRME
29: SRIG

La definición de cada uno de estos comandos o nemónicos, está en el capítulo código de máquina.

Vamos a almacenar estos nemónicos en un lista en python, del siguiente modo:

nemonicos = ['ALTO','LIM','ACUM','MUL','RES','DIV','IMPR',
        'LEER','ALM','RR0','RR1','RSUM','RMUL','RRES','RDIV',
        'AR0','AR1','INC','DEC','INCR0','DECR0','INCR1','DECR1',
        'SALTA','SSC','SSN','SSN','SRMA','SRME','SRIG']

De este modo si ejecutamos las siguiente instrucciones obtenemos el código de máquina correspondiente al nemónico:

>>>nemonicos.index('DEC')
18
>>>nemonicos.index('SRME')
28

Esto nos da una idea de que hacer para leer nuestro archivo, en esencia, el algoritmo para leer el archivo con instrucciones en assembler sería:

Abrir el archivo
Leer todas las lineas en el archivo
Por cada linea leida:

Si la linea es un nemónico, entonces traducir la linea al código numérico respectivo
De lo contrario debe ser un número
almacenar ese resultado en la memoria

Vamos re escribiendo ese algoritmo a python por partes:

def loader(nombre_archivo):
   # archivo = abrir archivo(nombre_archivo)
   # lineas = leer lineas en archivo
   for linea in lineas:
      if linea in nemonicos:
         # agregar_a_memoria (nemonicos.index(linea))
      else:
          # agregar_a_memoria( int(linea))

La memoria es simplemente una lista de enteros:

memoria = []

Así que agregar a memoria es bastante simple: memoria.append(codigo).

Por otro lado, un archivo en Python se maneja usando el tipo predefinido file, un objeto de tipo file tiene un método que permite leer todas las lineas de un archivo las que se retornan en una lista, con esto nuestro código para loader queda así:

memoria = []

def loader(nombre_archivo):
   archivo = open(nombre_archivo)
   lineas = archivo.readlines()
   archivo.close()
   for linea in lineas:
      codigo = linea.strip()
      if codigo in nemonicos:
         memoria.append(nemonicos.index(codigo))
      else:
          memoria.append( int(codigo) )

La función open() ‘abre’ un archivo para ser leido. Retorna un objeto de tipo file.
El objeto retornado tiene un método readlines() que lee todas las lineas y las retorna en una lista, que almacenamos en el arreglo lineas. Después de leer las lineas ‘cerramos’ el archivo. Esto es importante, más adelante aprenderemos sobre los recursos del sistema operativo y porque es importante esto de cerrar el archivo.

Notarán que usé una variable auxiliar llamada codigo, lo que pasa es que los archivos almacenan cada linea con un carácter especial invisible, conocido como fin de linea, este carácter debe ser eliminado para poder buscarlo en la lista de nemónicos, o de lo contrario no podrá ser identificado. Esto se logra usando linea.strip().

He subido a mi repositorio en GitHub el código de la función loader, junto con un archivo de ejemplo, pueden descargarlo desde acá.

Ejercicio

El siguiente programa hace lo mismo que el anterior pero de un modo avanzado:

nemonicos = ['ALTO','LIM','ACUM','MUL','RES','DIV','IMPR','LEER','ALM','RR0','RR1','RSUM','RMUL','RRES','RDIV',
        'AR0','AR1','INC','DEC','INCR0','DECR0','INCR1','DECR1','SALTA','SSC','SSN','SSN','SRMA','SRME''SRIG']

def traduce(codigo):
	return nemonicos.index(codigo) if codigo in nemonicos else int(codigo)

def loader(nombre_archivo):
	with open(nombre_archivo) as archivo:
		return map(traduce, [linea.strip() for linea in archivo.readlines()]) 

memoria = loader('tabla_cinco.a')

¿Puedes explicar qué hace este programa? Pistas: la documentación de Python 3 se encuentra acá. Averigua sobre qué hace la función map().

La instrucción with es muy útil con recursos que deben ser liberados, como pasa con los archivos.

with open(nombre_archivo) as archivo:
    instrucciones...

es equivalente a hacer esto:

archivo = open(nombre_archivo)
instrucciones...
archivo.close()

Código de Máquina

ediaz — Sat, 23 Apr 2011 10:43:59 +0000

En el capítulo anterior de nuestro curso de programación vimos algo de la historia del desarrollo del computador digital. Pero, ¿cómo funciona un computador? Para responder esta pregunta vamos a simular el funcionamiento de un computador usando Python. Lo que vamos a construir es un modelo de máquina, un híbrido entre máquina de Turing y de Von Neumann.

Si recuerdan bien, la idea de Turing era construir una máquina que opera leyendo símbolos desde una larga cinta de papel, y escribiendo en esta misma cinta los resultados de las operaciones, las que dependen obviamente de la interpretación de estos símbolos. En el caso de la arquitectura de Von Neumann tenemos una memoria principal, esta memoria contiene las instrucciones a ejecutar. Lo que hace una computadora es ir interpretando las instrucciones que están almacenadas en la memoria una por una.

¿Cómo son estas instrucciones?

Bueno, depende del tipo de computador. Hay computadores más sofisticados que otros, y esto define el tipo de instrucciones. De todas maneras, estas instrucciones son bastantes primitivas.

Por ejemplo, imaginemos un conjunto de instrucciones para sumar 20 y 45 en una máquina hipotética:

```
LIMPIAR
```
```
ACUMULAR
```
```
20
```
```
ACUMULAR
```
```
45
```
```
IMPRIMIR
```
```
ALTO
```

La instrucción LIMPIA en la linea 1 coloca en cero algún área interna usada para guardar resultados intermedios, como la memoria de una calculadora, por ejemplo. La instrucción ACUMULA de la linea 2 indica al computador que deberá sumar el dato que sigue en la memoria de trabajo. La linea 3 contiene el primer dato, en este caso 20. La instrucción ACUMULA de la linea 4 indica al computador que deberá sumar el dato que sigue a la memoria de trabajo. La linea 5 contiene el segundo dato: 45. La instrucción IMPRIME de la linea 6 le pide a la máquina que muestre por algún dispositivo de salida (la pantalla, por ejemplo), el resultado guardado en el area intermedia. La instrucción ALTO en la linea 7 le indica a la máquina que debe detenerse.

Este es un ejemplo de lo que llamamos código de máquina. Este es el código que entienden directamente las computadoras. Aunque en realidad lo escrito arriba es una representación para que podamos entender, a esta representación la llamamos código ensamblador, o assembly, el verdadero código de máquina está representado por números, porque la computadora sólo procesa números, los que se escriben en binario. Supongamos que en nuestra máquina cada instrucción esta codficada de acuerdo a la siguiente tabla:

INSTRUCCION VALOR   EN BINARIO (*)
ALTO:           0   0000 00000
LIMPIAR:        1   0000 00001
ACUMULAR:       2   0000 00010
IMPRIMIR:       3   0000 00011

Entonces nuestra lista de instrucciones para sumar 20 y 45 se codificaría como la lista de números siguiente: 1,2,20,2,45,3,0, la que se expresaría en código de máquina en binario de la siguiente forma:

(*) Hablamos de los números binarios en este capítulo.

Nuestra propia máquina virtual

Nuestro objetivo es construir un programa en Python que simule una máquina que interprete este tipode de código de máquina. Para simplificar vamos a definir una máquina imaginaria, esquemáticamente nuestra máquina tendrá la siguiente arquitectura:

Diagrama de Bloques de nuestra máquina virtual

La figura corresponde a un diagrama de bloques, un tipo de dibujo muy usado en el modelamiento de sistemas informáticos. La posición de cada bloque, o caja, nos indica el grado de dependencia de cada parte del sistema.

El primer bloque, o componente, de nuestra máquina es la memoria. Imaginen que la memoria es como una gran cajonera. Dentro de cada cajón de nuestra memoria se almacenan palabras (word en inglés), que corresponden a instrucciones o datos. Además imaginaremos que cada cajón ha sido numerado partiendo, como siempre, desde cero. (Estos cajones son llamados también celdas de memoria).

La unidad de control (CU por Control Unit, en inglés) es como un sirviente que va abriendo los cajones, uno por uno, y lee las palabras que se encuentra en cada cajón. ¿Cómo sabe la CU cuál cajón abrir? Para eso nuestra máquina tiene una variable especial que llamaremos el puntero de instrucciones (instruction pointer, IP). Si el IP es cer0, entonces la siguiente palabra a leer está en la cajonera cero.

La CU va interpretando estas palabras, si la palabra es una instrucción se ejecuta, si la palabra es un dato este dato puede ser el argumento de una instrucción. Cuando se ejecuta una instrucción el IP cambia su valor, este nuevo valor va a depender del tipo de instrucción, hay instrucciones que simplemente incrementan el IP en 1, hay otras que permiten cambiar el valor del IP con un valor arbitrario, estas son conocidas como instrucciones de salto. Otras instrucciones requieren argumentos, los que se encuentran en celdas de memoria contigua. Por ejemplo, si una función necesita un dato adicional entonces esta instrucción lee el dato desde la posición IP+1 e incrementa el valor IP en 2. Todo esto va a quedar más claro cuando construyamos nuestro simulador.

Hay instrucciones que representan operaciones aritméticas o lógicas, estas son ejecutadas por la Unidad Aritmético Lógica, o ALU por sus siglas en inglés: Aritmetic Logic Unit. Nuestra ALU cuenta con varios cajones especiales, hay uno que llamaremos el acumulador. El acumulador sólo guarda valores enteros. Inicialmente, al encenderse nuestra máquina, el acumulador tiene el valor cero (0). Hay dos cajones adicionales: R0 y R1, son los registros auxiliares, muy útiles en otras instrucciones.

Con esto tenemos todos los elementos básicos de nuestra máquina. Por cierto, esta máquina tiene mecanismos para recibir datos, y para leer datos. Estas instrucciones son manejadas con los módulos input y output.

Lo que vamos a construir se conoce como una máquina virtual, una simulación de una máquina o computadora real, implementada mediante software. Lo que aprenderemos en este y el próximo capítulo es la base conceptual de cosas tan avanzadas como la Java Virtual Machine, o el ambiente CLR de Microsoft.Net. Como veremos más adelante el mismo Python utiliza este tipo de mecanismos.

En los párrafos anteriores describimos brevemente las componentes de nuestra máquina. Lo que falta es describir el tipo de instrucciones específicas que soporta nuestra máquina.

Nuestro código de máquina

Vamos a ver que para poder realizar cálculos relativamente complejos se requiere un conjunto bastante pequeño de instrucciones. Por ahora, y para simplificar nuestro diseño, nuestra máquina sólo operarará con números enteros, por lo tanto nuestro set de instrucciones se remite a este tipo de datos y opera sobre los elementos de la arquitectura descrita anteriormente.

Nuestra computadora tendrá las siguientes instrucciones (las abreviaturas van entre paréntesis):

ALTO: Detiene la máquina.
LIMPIAR (LIM): coloca el acumulador en cero. Se abrevia LIM
ACUMULAR (ACUM): suma la palabra que sigue al acumulador. Se abrevia ACUM
MULTIPLICAR (MUL): multiplica el valor del acumulador por la palabra que sigue.
RESTAR (RES): resta el valor de la siguiente palabra de memoria del acumulador.
DIVIDIR (DIV): divide el valor del acumulador por el valor de la próxima palabra.
IMPRIMIR (IMPR): imprime el valor del acumulador en pantalla.
LEER: lee un valor desde el teclado y lo guarda en el acumulador
ALMACENAR (ALM): almacena el valor del acumulador en la posición de memoria indicada por la siguiente palabra.
RECUPERAR R0 (RR0): almacena el valor en la posición de memoria indicada por la siguiente palabra en el registro R0
RECUPERAR R1 (RR1): almacena el valor en la posición de memoria indicada por la siguiente palabra en el registro R1.

Hay versiones de las operaciones matemáticas que operan con los registros R0 y R1 y dejan el resultado en el acumulador

RSUM: suma los valores en los registros R0 y R1 y deja el resultado en el acumulador
RMUL: multiplica los valores en registros R0 y R1 y deja el resultado en el acumulador
RRES: resta al valor del registro R0 el valor del registro R1 y deja el resultado en el acumulador
RDIV: divide el valor del registro R0 por el valor del registro R1 y deja el resultado en el acumulador

Hay 2 instrucciones especiales que sirven para guardar valores en R0 y R1:

AR0: almacena el valor que sigue en el registro R0
AR1: almacena el valor que sigue en el registro R0

Y hay instrucciones especiales con los registros:

INC: incrementa en 1 el acumulador
DEC: decrementa en 1 el acumulador
INCR0: incerementa en 1 el registro R0
DECR0: decrementa en 1 el registro R0
INCR1: incrementa en 1 el registro R1
DECR1: decrementa en 1 el registro R1

Hay instrucciones de salto, estas permiten cambiar el valor del IP, es decir, cambiar desde que posición en memoria se leerá la siguiente instrucción:

SALTA: Salta a la posición definida por la palabra siguiente. Es decir, cambia el valor del IP.
SALTA SI CERO (SSC): Salta a la posición definida por la palabra siguiente si el valor del acumulador es cero.
SALTA SI NEGATIVO (SSN): Salta a la posición definida por la palabra siguiente si el valor del acumulador es negativo.
SALTA SI POSITIVO (SSN): Salta a la posición definida por la palabra siguiente si el valor del acumulador es positivo (mayor que 0).
SRMA: Salta a la posición definida por la palabra siguiente si el registro R0 es mayor que el registro R1
SRME: Salta a la posición definida por la palabra siguiente si el registro R0 es menor que el registro R1
SRIG: Salta a la posición definida por la palabra siguiente si el registro R0 es igual al registro R1

Ejemplos

Los siguientes son “programas” escritos en el código de máquina de nuestra máquina:

Ejemplo 1: este programa suma 2+3:

```
ACUM
```
```
2
```
```
ACUM
```
```
3
```
```
IMPR
```
```
ALTO
```

La instrucción de la linea 1 ACUM hace que la CU lea la siguiente palabra, en este caso 2, y la almacene en el acumulador. La instrucción de la linea 3 ACUM hace que se sume el valor de la siguiente palabra, en este caso el número 3, al acumulador. La instrucción de la linea 5 imprime el valor del acumulador (5), y la instrucción de la linea 6 detiene la máquina.

Ejemplo 2: Multiplica un número ingresado por el usuario por 2:

```
LEER
```
```
MUL
```
```
2
```
```
IMPR
```
```
ALTO
```

La instrucción en la linea 1 permite ingresar un número y guardarlo en el acumulador. Luego la instrucción MUL seguida de la palabra “2″, permiten multiplicar el valor ingresado por 2. La instrucción en la linea 4 imprime el valor del acumulador. Y la instrucción 5 detiene la máquina.

Ejemplo 3: Multiplicar 2 números ingresados por el usuario

```
LEER
```
```
ALMACENAR
```
```
20
```
```
LEER
```
```
ALM
```
```
21
```
```
RECUPERAR R0
```
```
20
```
```
RR1
```
```
21
```
```
RMUL
```
```
IMPRIMIR
```
```
ALTO
```

Este ejemplo es más complejo. La linea 1 solicita al usuario que ingrese un número. La instruccion ALMACENAR en la linea 2 lleva el valor del acumulador a la celda de memoria número 20. La instrucción en la linea 4 solicita al usuario que ingrese otro número, el que es almacenado en la celda de memoria número 21. La instrucción 7 recupera el valor en la celda de memoria 20 en el registro R0 (este es el primer número ingresado por el usuario). La instrucción en la linea 9 recupera el valor de la celda de memoria 21 y lo deja en el registro R1 (este es el segundo número ingresado por el usuario). En la lina 11 multiplicamos ambos registros, y el resultado queda en el acumulador. La instrucción de la linea 12 imprime el resultado, y la instrucción de la linea 13 detiene la máquina.

Ejemplo 5: imprime la tabla del 5 por pantalla.

```
AR0
```
```
5
```
```
AR1
```
```
0
```
```
INCR1
```
```
RMUL
```
```
PRINT
```
```
RES
```
```
50
```
```
SSC
```
```
14
```
```
SALTA
```
```
5
```
```
ALTO
```

Este es otro ejemplo complejo que usa instrucciones de salto. La instrucción de la linea 1 almacena en el registro 0 el número 5. La instrucción de la linea 3 almacena en el registro 1 el valor 0. Luego, en la linea 5 incrementamos el valor del registro 1. En la linea 6 multiplicamos los registros R0 y R1 entre sí, el valor queda en el acumulador. La instrucción 7 imprime el resultado. En la linea 8 restamos 50 al valor del acumulador. Esta resta valdrá cero sólo cuando el acumulador llegue a valer 50, eso se produce cuando multipliquemos 5 * 10, es decir, esta es la condición que nos permite terminar el programa (la tabla va desde el 5 al 50). La linea 10 chequea si el valor del acumulador es 0, si eso se da entonces salta a la instrucción 14. Si no la linea 12 instruye que se salte a la linea 5. Esto es una manera de implementar un loop usando código de máquina.

Vamos a realizar una traza, es decir, vamos a simular el comportamiento del programa del ejemplo 5. Vamos es escribir en una tabla los valores del registro en la medida que se ejecuta el programa:

```
Al inicio: ACUM = 0; R0 = ?; R1 = ?.
```

Después de ejecutamos linea 1, ACUM = 0; R0 = 5; R1 = ?.

Ejecutamos linea 3: ACUM= 0; R0 = 5; R1 = 0.

Ejecutamos linea 5: ACUM = 0; R0 = 5; R1 = 1.

Ejecutamos linea 6: ACUM = 5; R0 = 5; R1 = 1.

```
Linea 7 imprime 5 en pantalla.
```

Ejecutamos linea 8: ACUM = -45; R0 = 5; R1 =1.

Linea 10  compara acumulador con 0, como ACUM=-45,
la condición no se cumple entonces pasa a la linea 12.

```
Linea 12, salta a la linea 5.
```

Ejecutamos linea 5: ACUM = -45; R0 = 5; R1 = 2.

Ejecutamos linea 6: ACUM = 10; R0 = 5; R1 = 2.

```
Linea 7 imprime 10 en pantalla.
```

Ejecutamos linea 8: ACUM = -40; R0 = 5; R1 =2.

Linea 10  compara acumulador con 0, como ACUM=-45,
la condición no se cumple entonces pasa a la linea 12.

```
Linea 12, salta a la linea 5.
```

Ejecutamos linea 5: ACUM = -40; R0 = 5; R1 = 3.

Ejecutamos linea 6: ACUM = 15; R0 = 5; R1 = 3.

```
Linea 7 imprime 15 en pantalla.
```

Ejecutamos linea 8: ACUM = -35; R0 = 5; R1 =3.

...... continua así hasta que en algun momento R1 = 9

Ejecutamos linea 5: ACUM = -5; R0 = 5; R1 = 10.

Ejecutamos linea 6: ACUM = 50; R0 = 5; R1 = 10.

```
Linea 7 imprime 50 en pantalla.
```

Ejecutamos linea 8: ACUM =0; R0 = 5; R1 =10.

Linea 10  compara acumulador con 0, como ACUM=0,
la condición esta vez se cumple entonces pasa a la linea 14

Linea 14: ALTO, la máquina se detiene, ACUM = 0; R0 = 5, R1 = 10.

Programación de bajo nivel

Como pueden ver programar en lenguaje de máquina es una tarea bastante ardua. Afortunadamente no tenemos que hacerlo, por eso contamos con lenguajes como Python, los llamados lenguajes de alto nivel. Cuando programamos instrucciones de máquina directamente decimos que estamos programando a bajo nivel.

Creo que hemos visto muchas cosas en este capítulo, y asimilarlas puede ser complejo, eso lo reconozco, pero es así como funcionan realmente los computadores, y es bastante dificil simplificar aún más los conceptos. Si quieres aprender más de esto te recomiendo leer:

La página en wikipedia sobre lenguaje ensamblador, es un buen punto de partida.
El ASM Book es un esfuerzo para escribir un libro comunitario donde se explica el lenguaje ensamblador.
El libro Code: The Hidden Language of Computer Hardware and Software (Código: El Lenguaje Oculto del Hardware y Software del Computador), es una excelente introducción sobre como funcionan las cosas. En ese libro se profundiza aún a más bajo nivel lo expuesto en este capítulo, pero de una manera gradual y bastante didáctica.

Ejercicios

Asigna un código numérico a cada una de las instrucciones que definimos y transcribe los ejemplos como listas de números. Luego expresa esos números en binario.
Escribe un programa en nuestro código de máquina que le pida al usuario 2 números y los divida. Asegurate de no dividir por cero.
Escribe un programa, en nuestro código de máquina, que solicite al usuario primero un número indicando el tipo de operación que desea realizar: 1 para sumar, 2 para restar, 3 para multiplicar y 4 para dividir. Si el usuario ingresa 0 (cero) entonces el programa se detiene. Una vez elegida la operación el programa debe solicitar los dós números y ejecutar la operación deseada, finalmente debe mostrar el resultado y volver a empezar.

La máquina universal

ediaz — Sun, 17 Apr 2011 19:11:55 +0000

En la primera parte de nuestro curso de programación aprendimos los elementos básicos para construir programas simples. Fuimos aprendiendo esto en la medida que ibamos construyendo un juego de naipes. Pero este juego tiene una interfaz de usuario bastante básica basada en texto. Aunque ustedes no lo crean un programa idéntico a este fue usado en un proyecto de juegos para telefonía móvil usando SMS. Del mismo modo se podría usar para jugar en twitter, las posibilidades están abiertas a vuestra imaginación como desarrolladores.

Sin embargo, creo que sería más interesante contar con una interfaz gráfica de usuario para nuestro juego, y después podemos extender nuestro juego para que sea jugado por muchas personas a través de la web. Así que la segunda parte de nuestro curso tiene por objetivo construir una versión gráfica del juego de BlackJack, para ser jugada en un computador personal con un sistema operativo moderno (como Ubuntu, Mac OSX, o Windows 7). En la tercera parte del curso llevaremos nuestro juego a la web.

Para poder lograr nuestro objetivo tenemos que aprender un poco más de cómo funcionan los computadores, y a esta exploración vamos a dedicar nuestras siguientes lecciones.Vamos a partir con un poco de historia, no se preocupen, no es aburrida, involucra algo de acción y espionaje, y drama humano

Alan Turing el padre de la computación

La máquina universal

En 1931 un joven de 24 años, Alan Turing decidió reformular ciertos resultados de la lógica matemática expresando las formulaciones de teoremas en términos de algoritmos que podían ser interpretados por una máquina teórica.

Un algoritmo es ”un conjunto preescrito de instrucciones o reglas bien definidas, ordenadas y finitas que permite realizar una actividad mediante pasos sucesivos que no generen dudas a quien deba realizar dicha actividad.” O sea, un programa

Lo que pretendía Turing era estudiar los límites de las máquinas que realizaban cálculos automáticos. Era un tiempo en que se estaban sentando las bases de cómo serían los computadores. Ya era posible contar con los elementos para construir estas máquinas y Turing quería ver cual era el poder de estas máquinas. Hasta que punto estas máquinas serían capaces de ayudarnos a resolver problemas complejos.

Turing describió una máquina teórica que manipula los símbolos escritos una larga cinta de acuerdo a una tabla de reglas. La máquina de Turing consta de un cabezal que puede leer y/o escribir en una cinta infinita de papel. La máquina puede realizar sólo las siguientes operaciones: avanzar el cabezal hacia la dercha, avanzar el cabezal hacia la izquierda, leer el contenido de una celda de la cinta, borrar el contenido de una celda y escribir en la cinta.

Representación artística de la Máquina de Turign

Con este dispositivo tan simple Turing tuvo éxito en su empeño. No sólo sentó las bases teóricas para la construcción de estas máquinas, sino que estableció la formalización del concepto de algoritmo, lo que llevaría al desarrollo de los lenguajes de programación, descubrió la manera de determinar la complejidad de los problemas que pueden ser abordados por una máquina de este tipo, e incluso planteó un tipo de test para verificar operacionalmente una máquina es inteligente, el famoso Test de Turing.

Es a partir de los trabajos de Turing que contamos con el concepto de máquina universal, capaz de resolver cualquier problema. Una máquina que es capaz de emular muchos de nuestros procesos mentales. Turing pensaba que era posible un día descubrir los algoritmos que gobiernan nuestra forma de ser y pensar, y que eso podría ser transferido a una máquina.

Polémico y todo, esta idea ha sido el motor de gran parte del desarrollo de la inteligencia artificial. Personalmente creo que Turing se equivocaba en esta idea, y probablemente, como plantea Jaron Lanier, los traumas y problemas de la vida personal de Turing fueron los impulsores de esta obsesión del grán lógico inglés. Pero estamos divagando.

Lo importante es que entendamos que este concepto de máquina universal se concretó y hoy tenemos computadores en todas partes, en el refrigerador, en nuestros televisores, en el automóvil y nuestros teléfonos móviles. Todos tienen un computador, una máquina universal de Turing que gobierna sus acciones, que decide en forma algorítimica como reaccionar ante el nuevo estímulo que recogen desde el exterior.

Enigma y la guerra que lo cambió todo

La máquina Enigma

Durante la segunda guerra mundial Turing se vió involucrado en un proyecto secreto de alto impacto, tan importante se considera este proyecto que se dice que gran parte del resultado de la guerra, y la derrota final de los Nazis, se debe al trabajo de este selecto equipo de científicos. Durante ese tiempo Turing y el equipo de Bletchey Park trabajaron descifrando los mensajes secretos del ejército alemán. Durante ese tiempo las fuerzas germánas contaban con máquinas de encriptación muy poderosas, como Enigma y la máquina Lorenz. La máquina Enigm era usada principalmente por la armada y los famosos submarinos u-boat alemanes. El grupo Hut 8 era el encargado de decodificar estos mensajes y a cargo de este estaba Alan Turing.

Durante ese tiempo el equipo de Bletchey Park construyeron una serie de máquinas para ayudar en el trabajo de descifrado automático de los mensajes captados por los servicios de inteligencia.

Entre las máquinas construidas por los ingleses se encontraba el Colossus Mark 2, probablemente el primer computador digital semi programable.

Colossus Mark II

Mucho del trabajo de estas máquinas se mantuvo en secreto por años, y por esta razón fueron ignorados por mucho tiempo.

En esos tiempos los ingléses desarrollaron una serie de computadores, y el mismo Turing trabajó en el desarrollo de algunos de estos.

Todos los computadores de ese tiempo eran programados mediante cableado, el concepto revolucionario vino desde el otro lado del atlántico y sentó las bases para la estructura de los modernos computadores.

Recordemos que en aquel tiempo los norteamericanos estaban desarrollando el famoso proyecto Manhattan que llevaría a la creación de la primera bomba atómica.

La computadora humana de Feynmann

Richard Feynmann cuenta que necesitaban hacer complicados cálculos matemáticos y mientras no contaran con un computador decidieron hacerlo con ayuda de personal humano:

“Desarrollamos el programa, pero no teníamos ninguna máquina para probarlo. De modo que lo que hicimos fue llenar una habitación con chicas, cada una de ellas con una Marchant [una calculadora]. Pero ella era el multiplicador, y ella era el sumador, y ésta elevaba al cubo; teníamos tarjetas, tarjetas con índices y todo lo que ella hacía era elevar al cubo un número y pasárselo a la siguiente. Ésta hacía de multiplicador, la siguiente hacía de sumador; recorríamos el ciclo, eliminábamos todos los errores. Bien, así lo hicimos. Y resultó que podíamos hacerlo a gran velocidad. Nunca antes se había hecho cálculo en serie; cualquiera que hubiera hecho cálculos antes alguna vez había realizado todos los pasos por si mismo. Pero Ford(*) tuvo una buena idea, la maldita cosa trabajaba mucho más rápidamente que de la otra forma, y con este sistema llegamos a alcanzar una velocidad igual a la predicha para la máquina IBM: exactamente la misma.”

(*) Se refiere a Henry Ford y su idea del producción en serie.

Entre los hombres que estaban en Los Alamos en aquel tiempo se encontraba un brillante matemático de origen Húngaro: John von Neumann. Considerado un halcón, por sus visiones políticas y su involucramiento en el desarrollo de armas atómicas (como la bomba de hidrógeno), John von Neumman estableció la primera arquitectura efectiva para construir computadores que pudieran ser programados en forma efectiva, es decir, sin tanto cableado.

La principal idea que propuso Von Neumann fue que los datos y los programas fueran ambos almacenados en la memoria principal de la computadora.

La arquitectura de Von Neumann se decribe en el artículo “The first draft report on the EDVAC” y corresponde, esencialmente, a la arquitectura usada por la mayor parte de las computadoras que usamos en la actualidad:

Von Neumann estableció que la memoria es una sola unidad que contiene el programa y los datos sobre los que actuará el computador. Existe un módulo que llamó la unidad de control (CU por control unit) que lee las instrucciones desde la memoria y las ejecuta una a una. Otra unidad llamada la unidad de lógica y aritmética (ALU por su sigla en inglés) se encarga de los cálculos. La ALU lee los datos de un cálculo y escribe los resultados en la memoria. Juntas la unidad de control (CU) y la unidad aritmético lógica (ALU) conforman la Unidad Central de Proceso (CPU). Para comunicarse con el exterior la CPU se enlaza a los dispositivos de entrada (INPUT), como los teclados, sensores, mouse, unidades de disco, etc, y a los dispositivos de salida (OUTPUT) como las pantallas, impresoras, parlantes, etc.

Más adelante vamos a aprender sobre este modelo en más detalle pues es esencial para lograr cumplir con los futuros proyectos de nuestro curso.

Los destinos diversos de dos hombres notables.

A pesar de que las contribuciones de Turing y Von Neumann fueron fundamentales para el desarrollo de las computadoras, no se puede imaginar dos tipos de personajes tan distintos.

Von Neumann desarrollo principalmente computadores para mejorar los cálculos necesarios para desarrollar la bomba atómica. Aunque hizo notables contribuciones en el ámbito de las matemáticas y la ciencia de la computación. Ayudó a desarrollar el método de Montecarlo y varias técnicas de simulación con números seudoaleatorios (el algoritmo de números aleatorios que usamos en nuestro juego viene de los trabajos de este matemático). Es probablemente el científico que más influyó en el establecimiento del concepto de destrucción mutua asegurada, que estableció el equilibrio en términos nucleares entre las super potencias durante el periodo de la guerra fría. El favorecía la idea de un ataque nuclear preventivo a la Unión Sovietica para evitar que esta potencia adquiriera la bomba atómica. Von Neumann murió de cancer. Sus biógrafos han escrito: ”cuando von Neumann se enteró de que estaba incurablemente enfermo, su lógica le forzaba a darse cuenta de que cesaría de existir, y por tanto que cesaría de tener pensamientos…Su amigo Edward Teller dijo, ‘Pienso que von Neumann sufrió más cuando su mente dejo de funcionar que lo que había nunca visto sufrir a ningún ser humano’. El sentido de la invulnerabilidad de von Neumann, o simplemente el deseo de vivir se enfrentaba con hechos inalterables. Pareció tener un gran miedo de morir hasta el final… Ningún logro y ninguna clase de influencia podían salvarle ahora, como había tenido siempre en el pasado. Johnny von Neumann, que supo como vivir tan plenamente, no supo como morir.”

Alan Turing siguió investigando en diversos temas, en 1952 escribió un programa de ajedrez, pero era imposible correrlo en ningún computador de esa época, y el actuaba como CPU humana. Sus últimos años los dedicó a la biología matemática, tratando de entender por que se daban secuencias de números de fibonacci en las estructuras vegetales. Alan Turing era homosexual, una condición que era condenada en la Inglaterra de los 1950s. Durante el proceso en que se investigaba una denuncia que él mismo interpuso por robo, tuvo que confesar su homosexulidad y el acusador pasó a ser acusado de “indecencia grave y perversión sexual”. La opción era ir a prisión o someterse a un tratamiento hormonal, que incluía la inyección de estrógeno, lo que le provocó la aparición de pechos, impotencia y otras molestias. En 1954 muere por envenenamiento por cianuro al comer una manzana. El acto se considera oficialmente un suicidio, pero su madre insistió en que fue un accidente.

Los fundamentos

Si recuerdan la idea del computador humanos de Feynmann, podrán ver que las tarjetas que pasaban las operadoras corresponden a la memoria, las chicas con sus calculadoras correspondían a la unidad lógico aritmética, y Feynman y sus colegas actuaban como unidad de control. No es necesario saber de micro chips, o relés, para entender como funcionan los computadores.

Esta breve disgresión histórica tiene por objetivo presentarles un modelo de computador básico. El modelo de Von Neumman y la máquina de Turing sirven para entender en forma conceptual cómo operan los computadores. Seguiremos explorando esto en los próximos capítulos.

Lecturas recomendadas

The Annotated Turing: A Guided Tour Through Alan Turing’s Historic Paper on Computability and the Turing Machine por Charles Petzolds, para entender el artículo original de Alan Turing.
Una historia sobre la máquina Enigma se encuentra en este sitio: Kriptópolis la máquina Enigma
Este video es un fragmento de la película Breaking The Code, donde Turing explica el concepto detrás de la máquina de Turing.
Una biografía de Von Neumman se encuentra en este sitio, de donde sacamos algunas citas.
“El Placer de Descubrir” por Richard Feynman, Editorial Crítica Barcelona, año 2000.

Gracias

ediaz — Thu, 14 Apr 2011 00:56:28 +0000

Hemos completado lo básico en el curso de programación y pronto vamos a retomarlo, les pido paciencia. Al respecto me gustaría que me ayudaran con sus comentarios, críticas, y observaciones. También quiero pedirles que me ayuden a difundir este material.

Ya llevo más de un mes con este nuevo proyecto, y les quiero agradecer el apoyo, los retweets, y los comentarios positivos que he recibido. También a los 22 primeros fans en la página de facebook.

Pueden enviarme sugerencia de otros temas técnicos que les gustaría que tratara. Este es un espacio para difundir información técnica en nuestro idioma, hay mucho que hacer. Si quieren ayudar aportando con temas, escribir algún artículo son bienvenidos, sólo déjenme un mensaje en los comentarios.

Este pequeño post es para agradecerles su paciencia y tiempo.

¿Qué se les ocurre que podríamos hacer para difundir más nuestro curso de programación?
¿Que les ha parecido el material publicado hasta ahora?

La lógica del juego de BlackJack

ediaz — Thu, 07 Apr 2011 12:50:22 +0000

En el capítulo anterior, de nuestro curso de programación, escribimos las rutinas necesarias para interactuar con el usuario. Además escribimos la función blackjack() que es la rutina principal de nuestro juego.

Ahora nos vamos a concentrar en la lógica del juego. Volvamos a revisar la función blackjack():

def blackjack(pozo, apuesta_minima):
     print ("Bienvenido al juego de black jack")
     apuesta = solicitar_apuesta(pozo, apuesta_minima)
     while apuesta_minima <= apuesta <= pozo:
         resultado = jugar_mano(apuesta, pozo)
         pozo  += resultado
         mostrar_resultado(resultado, pozo)
         apuesta = solicitar_apuesta(pozo, apuesta_minima)
     print ("Gracias por participar, su pozo final es: ", pozo)

Lo que vamos a escribir a continuación es la función jugar_mano().

Escribamos primero lo que debe hacer en una serie de frases:

Barajar las cartas.
Repartir cartas al jugador.
Repartir cartas al croupier.
Si la mano es un blackjack:
- Finalizar la mano y retornar como resultado el doble de la apuesta
En caso contrario solicitar al jugador su próxima jugada, la que puede ser: 'R' para retirarse, 'D' para doblar, 'O' para pedir otra carta, y 'M' para mantener sus cartas.

Dependiendo de la opción se le entregan más cartas al jugador.
Cuando el jugador ha dejado de pedir cartas entonces juega el croupier, solicitando cartas hasta completar 17.

Se determina el resultado del juego y se retorna la ganancia o pérdida obtenida

Todo lo anterior se refleja en la siguiente función jugar_mano():

def jugar_mano(apuesta, pozo):
	print ("Nueva mano, apuesta $", apuesta, " pozo $", pozo-apuesta, "\n")
	baraja = baraja_mezclada()
	mano_jugador, mano_couprier  = [next(baraja), next(baraja)], [next(baraja), next(baraja)]
	ganancia = 0
	if valor_mano(mano_jugador) == 21:
		mostrar_manos(mano_jugador, mano_couprier)
		print ("¡Jugador tienen black jack!")
		ganancia = (3*apuesta)//2
	else:
		jugada = 'I'
		while jugada in ['I', 'O']:
			mostrar_manos(mano_jugador, mano_couprier)
			jugada = solicitar_jugada(jugada)
			if jugada == 'M':
				mano_couprier = jugar_couprier(mano_couprier, baraja)
			elif jugada == 'D':
				mano_jugador.append(next(baraja))
				mano_couprier = jugar_couprier(mano_couprier, baraja)
			elif jugada == 'O':
				mano_jugador.append(next(baraja))
				if valor_mano(mano_jugador) > 21:
					jugada = 'R'
		mostrar_manos(mano_jugador, mano_couprier)
		ganancia = determinar_ganancia(mano_jugador, mano_couprier, apuesta, jugada)
	return ganancia

La función baraja_mezclada() en la línea 3 corresponde a una variación de la función con el mismo nombre que vimos en el capítulo 12, recuerden que esta función es una función generadora, esto nos permite usar la función primitiva next(). Con la función next() podemos obtener el siguiente elemento de un generador.

El if en la linea 6 sirve para controlar la situación en que tengamos 21 en la primera jugada, eso es un black jack, con lo que el resultado se paga 3 a 2.

A partir de la linea 10 tenemos el caso en que no hay black jack.

El ciclo while requiere atención. Fíjense que partimos con el valor de la variable jugada en 'I', con esto podemos "pasar" por la condición inicial del while y se ejecuta de inmediato las funciones mostrar_jugada() y solicitar_jugada(). Pero, atención, 'I' no es una opción de las posibles, la razón por la que usamos 'I' es que la función solicitar_jugada() tienen un comportamiento distinto al principio del juego (ver más abajo).

Determinar la condición adecuada para colocar en un ciclo while no es fácil y más adelante vamos a dedicar unos capítulos a entender este tema. Les sugiero revisar este ciclo while y simular su comportamiento con papel y lapiz, anoten el valor de la variable jugada y estudien qué pasa al principio del ciclo y como varía el comportamiento del programa dependiendo de la opción que elija el jugador.

Si recuerdan en el capítulo anterior escribimos una versión de la función solicitar_jugada(), bueno, la versión definitiva de esa función es la siguiente:

def solicitar_jugada(jugada):
	if jugada == 'I':
		prompt = "Jugada? ('R':Retirarse, 'D':Doblar, 'O':Otra carta, 'M': Mantener cartas) --> "
		opciones = ['R','D','O','M']
	else:
		prompt = "Jugada? ('R':Retirarse, 'O':Otra carta, 'M': Mantener cartas) --> "
		opciones = ['R','O','M']

	opcion = input(prompt).strip().upper()
	while opcion not in opciones:
		print("opción incorrecta")
		opcion = input(prompt).strip().upper()
        print("Opción elegida: ", opcion, "\n")
	return opcion

Queda claro que el menú es distinto al principio del juego, pues sólo se puede doblar la apuesta en ese instante, de ahí en adelante la opción 'D' ya no se puede usar.

La función mostrar_manos() es muy sencilla, sólo llama a la función mostrar_mano() del capítulo anterior, dos veces, una por la mano del jugador y otra para mostrar la mano del couprier.


def mostrar_mano(prompt, mano):
	print("\t", prompt,
	      " ".join ( str(carta[0])+"-"+carta[1] for carta in mano),
		  " ( Valor: ", valor_mano(mano), ")\n")

def mostrar_manos(mano_jugador, mano_couprier):
	mostrar_mano("Cartas Jugador:  ", mano_jugador)
	mostrar_mano("Cartas Couprier: ", mano_couprier)

La función jugar_couprier() respeta la regla de que el couprier pide cartas hasta completar 17:

def jugar_couprier(mano, baraja):
	while valor_mano(mano) < 17:
		mano.append(next(baraja))
	return mano

Por último la función determinar_ganancia() nos entrega la ganancia (o pérdida si es negativa) de acuerdo a la comparación del valor de las manos del jugador y el couprier:

def determinar_ganancia(mano_jugador, mano_couprier, apuesta, jugada):
	if jugada == 'R':
		ganancia = -apuesta
	else:
		jugador, couprier = valor_mano(mano_jugador), valor_mano(mano_couprier)
		ganancia = 0
		if jugador <= 21 < couprier or couprier < jugador <= 21:
			ganancia = apuesta
		elif couprier <= 21 < jugador or jugador < couprier <= 21:
			ganancia = -apuesta
		if jugada == 'D':
			ganancia *= 2
	return ganancia

Con esto completamos nuestro programa que juega black jack. Este es el código completo del programa, te sugiero grabarlo como blackjack1.py y probarlo en tu ambiente:

import random  

def baraja_mezclada():
	palos = ['C', 'D', 'T', 'P']
	valores = ['A'] + [v for v in range(2,11)] + ['J', 'Q', 'K']
	baraja = [(valor, palo) for palo in palos for valor in valores]
	random.shuffle(baraja)
	while len(baraja) > 0:
		yield baraja.pop(0)

def valor_mano(cartas):
	valor = 0
	ases = False
	for carta in cartas:
		valor_carta = carta[0]
		if  valor_carta in ('J','Q','K'):
			valor += 10
		elif valor_carta == 'A':
			ases = True
			valor += 1
		else:
			valor += valor_carta

	if ases and (valor + 10) <= 21:
		valor += 10

	return valor

def solicitar_jugada(jugada):
	if jugada == 'I':
		prompt = "Jugada? ('R':Retirarse, 'D':Doblar, 'O':Otra carta, 'M': Mantener cartas) --> "
		opciones = ['R','D','O','M']
	else:
		prompt = "Jugada? ('R':Retirarse, 'O':Otra carta, 'M': Mantener cartas) --> "
		opciones = ['R','O','M']

	opcion = input(prompt).strip().upper()
	while opcion not in opciones:
		print("opción incorrecta")
		opcion = input(prompt).strip().upper()
        print("Opción elegida: ", opcion, "\n")
	return opcion

def mostrar_mano(prompt, mano):
	print("\t", prompt,
	      " ".join ( str(carta[0])+"-"+carta[1] for carta in mano),
		  " ( Valor: ", valor_mano(mano), ")\n")

def mostrar_manos(mano_jugador, mano_couprier):
	mostrar_mano("Cartas Jugador:  ", mano_jugador)
	mostrar_mano("Cartas Couprier: ", mano_couprier)

def jugar_couprier(mano, baraja):
	while valor_mano(mano) < 17:
		mano.append(next(baraja))
	return mano

def determinar_ganancia(mano_jugador, mano_couprier, apuesta, jugada):
	if jugada == 'R':
		ganancia = -apuesta
	else:
		jugador, couprier = valor_mano(mano_jugador), valor_mano(mano_couprier)
		ganancia = 0
		if jugador <= 21 < couprier or couprier < jugador <= 21:
			ganancia = apuesta
		elif couprier <= 21 < jugador or jugador < couprier <= 21:
			ganancia = -apuesta
		if jugada == 'D':
			ganancia *= 2
	return ganancia

def jugar_mano(apuesta, pozo):
	print ("Nueva mano, apuesta $", apuesta, " pozo $", pozo-apuesta, "\n")
	baraja = baraja_mezclada()
	mano_jugador, mano_couprier  = [next(baraja), next(baraja)], [next(baraja), next(baraja)]
	ganancia = 0
	if valor_mano(mano_jugador) == 21:
		mostrar_manos(mano_jugador, mano_couprier)
		print ("¡Jugador tienen black jack!")
		ganancia = (3*apuesta)//2
	else:
		jugada = 'I'
		while jugada in ['I','O']:
			mostrar_manos(mano_jugador, mano_couprier)
			jugada = solicitar_jugada(jugada)
			if jugada == 'M':
				mano_couprier = jugar_couprier(mano_couprier, baraja)
			elif jugada == 'D':
				mano_jugador.append(next(baraja))
				mano_couprier = jugar_couprier(mano_couprier, baraja)
			elif jugada == 'O':
				mano_jugador.append(next(baraja))
				if valor_mano(mano_jugador) > 21:
					jugada = 'R'
		mostrar_manos(mano_jugador, mano_couprier)
		ganancia = determinar_ganancia(mano_jugador, mano_couprier, apuesta, jugada)
	return ganancia

def mostrar_resultado(resultado, pozo):
	if resultado > 0:
	   print("Jugador gana $", resultado)
	elif resultado < 0:
		print("Jugador pierde $", -resultado)
	else:
		print("Empate")
	print ("Su pozo es: $", pozo, "\n")

def solicitar_apuesta(pozo, apuesta_minima):
	valor = -1
	if pozo < apuesta_minima:
		print ("Su pozo no le alcanza para seguir jugando, inténtelo de nuevo en otra oportunidad")
	else:
		prompt = "\nIngrese su apuesta (min: "+str(apuesta_minima)+", max: "+str(pozo)+", 0 para finalizar juego): "
		while valor != 0 and not (apuesta_minima <= valor <= pozo):
			valor = int(input(prompt))
	print ("")
	return valor

# black jack
def black_jack(pozo, apuesta_minima):
	# ciclo principal del programa
	print ("Bienvenido al juego de black jack")
	apuesta = solicitar_apuesta(pozo, apuesta_minima)
	while apuesta_minima <= apuesta <= pozo:
		resultado = jugar_mano(apuesta, pozo)
		pozo += resultado
		mostrar_resultado(resultado, pozo)
		apuesta = solicitar_apuesta(pozo, apuesta_minima)
	print ("Gracias por participar, tu pozo final es: ", pozo)

# llamada a blackjack() con pozo inicial y apuesta minima
black_jack(500, 10) # este es el punto de entrada del programa

Son 134 líneas de código. Por cierto, este programa tiene algunos defectos que vamos a resolver más adelante (¿puedes identificarlos?)

Esta vez no habrá ejercicios, la tarea es analizar cómo funciona este programa y entenderlo, te sugiero probar cambiando algunas cosas de este programa. Si algo no quedó claro te pido que me hagas consultas en los comentarios. Si identifican algún error por favor escríbanlo en los comentarios. El código fuente se encuentra en GitHub y lo pueden descargar desde allá en esta dirección: https://github.com/lnds/programando.org/tree/master/curso-de-programacion-cap-15-blackjack