Guia de Lectura Paradigmas FaMAF-UNC

Guı́a de lectura para la materia
Paradigmas de la Programación
Licenciatura en Ciencias de la Computación

FaMAF-UNC
2016
Nota de descargo
Esta guı́a es un documento de apoyo a la materia Paradigmas de la Programación de

la Licenciatura en Ciencias de la Computación de la Facultad de Matemática, Astronomı́a
y Fı́sica de la Universidad Nacional de Córdoba.
No es un texto autocontenido ni suficiente para el estudio y aprobación de la
materia, sino que deberá ser complementado con la lectura del material bibliográfico reco-
mendado, principalemente el libro Concepts in Programming Languages de John Mitchell,
la asistencia a clases, la realización de los ejercicios prácticos y los proyectos de laboratorio.
El contenido de este apunte está fuertemente basado en el libro Concepts in Programming
Languages.
Las condiciones de aprobación de la materia incluyen la presentación en tiempo y forma
de los proyectos de laboratorio y la aprobación de los exámenes teóricos. Para información
sobre el cursado y condiciones de aprobación y promoción vigentes, consultar la página de
la materia: http://cs.famaf.unc.edu.ar/materias/paradigmas/.
1
Índice general
1. Introducción y Motivación 4
1.1. Nuestro objeto de estudio . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2. Cuestiones fundamentales . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.3. Objetivos del curso “Paradigmas de la Programación” . . . . . . . . . . . . 4
1.4. Para qué sirve esta materia . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.5. Estructura de este apunte . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2. Qué es y qué puede hacer un lenguaje de programación 6

2.1. Sintaxis y semántica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.2. Alcance de los lenguajes de programación . . . . . . . . . . . . . . . . . . . 6
2.3. Sintaxis a través de gramáticas . . . . . . . . . . . . . . . . . . . . . . . . 7
2.4. Semántica operacional vs. lambda cálculo o denotacional . . . . . . . . . . 9
2.5. Para saber más . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.6. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3. Cómo funcionan los lenguajes de programación 16

3.1. Estructura de un compilador . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.2. Estructuras de datos de bajo nivel . . . . . . . . . . . . . . . . . . . . . . . 16
3.2.1. Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.3. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
4. Estructura en bloques 19
4.1. Código estructurado vs. código spaghetti . . . . . . . . . . . . . . . . . . . 19
4.2. Estructura de bloque . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
4.3. Activation records . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
4.3.1. Detalle de ejecución de un activation record . . . . . . . . . . . . . 25
4.4. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
5. Control de la ejecución 30
5.1. Funciones y procedimientos . . . . . . . . . . . . . . . . . . . . . . . . . . 30
5.2. Pasaje de parámetros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
5.2.1. Semántica de pasaje por valor (call-by-value) . . . . . . . . . . . . . 31
5.2.2. Semántica de pasaje por referencia call-by-reference . . . . . . . . . 32
2
5.2.3. Sutilezas entre pasaje por valor y pasaje por referencia . . . . . . . 34
5.2.4. Semántica de pasaje por valor-resultado . . . . . . . . . . . . . . . 35
5.2.5. Pasaje de parámetros no estricto (perezoso) . . . . . . . . . . . . . 36
5.2.6. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
5.3. Alcance estático vs. alcance dinámico . . . . . . . . . . . . . . . . . . . . . 42
5.3.1. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
5.4. Recursión a la cola . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
5.4.1. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
5.5. Alto orden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.5.1. Funciones de primera clase . . . . . . . . . . . . . . . . . . . . . . . 47
5.5.2. Pasar Funciones a otras Funciones . . . . . . . . . . . . . . . . . . . 48
5.6. Excepciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
5.6.1. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
5.7. Recolección de basura (garbage collection) . . . . . . . . . . . . . . . . . . 57
5.7.1. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
6. Orientación a objetos 61
6.1. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
7. Tipos de datos 91
7.1. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
8. Paradigma funcional 95
8.1. Expresiones imperativas vs. expresiones funcionales . . . . . . . . . . . . . 95
8.2. Propiedades valiosas de los lenguajes funcionales . . . . . . . . . . . . . . . 97
8.3. Problemas naturalmente no declarativos . . . . . . . . . . . . . . . . . . . 99
8.4. Concurrencia declarativa . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
8.5. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
9. Programación lógica 103

9.1. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
10.Programación concurrente 106

10.1. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
11.Paradigma de scripting 112

11.1. Tipos de lenguajes de scripting . . . . . . . . . . . . . . . . . . . . . . . . 113
11.2. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
12.Seguridad basada en lenguajes de programación 120

12.1. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
A. Exámenes de ediciones anteriores 121
3
Capı́tulo 1
Introducción y Motivación
1.1. Nuestro objeto de estudio

Esta materia se llama Paradigmas de la Programación, pero en otros lugares la pue-
den encontrar bajo el nombre Lenguajes de Programación, porque el objetivo es aprender
conceptos y propiedades de los lenguajes de programación.
1.2. Cuestiones fundamentales

¿Cuáles son las atribuciones de un lenguaje de programación?
¿Cómo funcionan los lenguajes de programación?
¿Cómo podemos hablar del “significado” de un programa?
¿Cómo podemos comparar diferentes lenguajes de programación?
1.3. Objetivos del curso “Paradigmas de la Progra-

mación”
Objetivizar e instrumentar los conceptos involucrados en la constitución de los len-
guajes de programación.
1.4. Para qué sirve esta materia

En la currı́cula de un profesional de la computación, esta materia nos capacita para
analizar, entender y tomar decisiones respecto a las fortalezas y desventajas de los diferentes
lenguajes de programación en diferentes contextos y para diferentes tareas.
Por ejemplo, para un proyecto en el que la eficiencia sea crı́tica (p.ej. dispositivos
móviles, grandes volúmenes de datos) podemos elegir un lenguaje que priorice la eficiencia
aunque requiera más experiencia de parte del programador, como C. En cambio, si el equipo
4
de desarrollo del software está compuesto de personas con poca experiencia, será mejor
elegir un lenguaje que ayude a prevenir los errores humanos, como por ejemplo Python.
1.5. Estructura de este apunte

Este apunte es un breve resumen en castellano de los contenidos de la materia. Está con-
cebido para acompañar a la lectura del libro Concepts in Programming Languages de John
Mitchell. Cada capı́tulo del apunte tiene un puntero a las secciones correspondientes del
libro, ası́ como a las filminas correspondientes de clase. Al final de cada capı́tulo se encuen-
tran los ejercicios prácticos correspondientes. También se encuentran varias preguntas de
tipo verdadero-falso sobre el contenido del capı́tulo.
Al final del apunte se encuentran exámenes parciales y finales de ediciones pasadas de
la materia.
El capı́tulo 2 trata sobre el alcance de los lenguajes de programación y sus componentes
fundamentales: la forma y el significado. En el capı́tulo 3 describimos cómo funcionan los
lenguajes de programación en una computadora.
Después, el capı́tulo 4 presenta la primera abstracción en lenguajes de programación, la
estructura de bloques, y a partir de esa abstracción nuestra unidad de significado básica:
el activation record. En este capı́tulo damos ejemplos de dos lenguajes con abstracción
de bloques: Algol en el paradigma imperativo y ML en el paradigma funcional. Estos dos
lenguajes están en la base de la mayor parte de lenguajes modernos.
En capı́tulo 5 mostramos diferentes construcciones de los lenguajes para manejar de
forma eficiente e intuitiva el flujo de ejecución de un programa. Vemos las implicaciones
en eficiencia y expresividad que tienen las diferentes construcciones.
En el capı́tulo 6 describimos las abstracciones propias del paradigma de orientación a
objetos, con ejemplos de C++ y Java.
En el capı́tulo 7 describimos mecanismos para organizar y manipular los datos, jerar-
quizándolos en estructuras de conjuntos y subconjuntos, y cómo estas estructuras otorgan
mayor seguridad a los lenguajes de programación.
En el capı́tulo 9 presentamos el paradigma de programación lógica, con su único expo-
nente, Prolog. En el capı́tulo 10 presentamos cómo se introduce en lenguajes de programa-
ción secuenciales la semántica de concurrencia, con ejemplos de concurrencia declarativa
con lenguajes como Scala.
Y finalmente en el capı́tulo 11 mostramos las decisiones de diseño y las concreciones
del paradigma de scripting, con ejemplos de glsjavascript y Perl.
Este apunte está en construcción y se agradecen comentarios y sugerencias a ale-
many@famaf.unc.edu.ar.
5
Capı́tulo 2
Qué es y qué puede hacer un

lenguaje de programación
Un lenguaje de programación es un lenguaje formal diseñado para realizar procesos

que pueden ser llevados a cabo por máquinas como las computadoras. Pueden usarse para
crear programas que controlen el comportamiento fı́sico y lógico de una máquina o para
expresar algoritmos con precisión (fuente: wikipedia).
2.1. Sintaxis y semántica

Los lenguajes son sistemas que se sirven de una forma para comunicar un significado.
Lo que tiene que ver con la forma recibe el nombre de sintaxis y lo que tiene que ver con
el significado recibe el nombre de semántica.
En los lenguajes naturales, como el castellano, el inglés o las lenguas de signos, las
palabras son la forma, y el contenido proposicional de las oraciones es el significado.
En los lenguajes de programación, que son lenguajes artificiales creados por hombres
(lenguajes formales), la forma son los programas y el significado es lo que los progra-
mas hacen, usualmente, en una computadora. En la definición de arriba, se ha descrito
lo que los programas como “controlar el comportamiento fı́sico y lógico de una máquina”.
Un lenguaje de programación se describe con su sintaxis (qué es lo que se puede escribir
legalmente en ese lenguaje) y su semántica (qué efectos tiene en la máquina lo que se escribe
en ese lenguaje).
2.2. Alcance de los lenguajes de programación

Mitchell 2.
Para “controlar el comportamiento fı́sico y lógico de una máquina” usamos algoritmos,
un conjunto de instrucciones bien definidas, ordenadas y finitas que permite realizar algo
de forma inambigua mediante pasos.
6
Las funciones computables son la formalización de la noción intuitiva de algoritmo, en
el sentido de que una función es computable si existe un algoritmo que puede hacer el
trabajo de la función, es decir, dada una entrada del dominio de la función puede devolver
la salida correspondiente.
El concepto de función computable es intuitivo, se usa para hablar de computabilidad
sin hacer referencia a ningún modelo concreto de computación. Cualquier definición, sin
embargo, debe hacer referencia a algún modelo especı́fico de computación, como por ejem-
plo máquina de Turings, las funciones µ recursivas, el lambda cálculo o las máquinas de
registro.
La tesis de Church-Turing1 dice que las funciones computables son exactamente las
funciones que se pueden calcular utilizando un dispositivo de cálculo mecánico dada una
cantidad ilimitada de tiempo y espacio de almacenamiento. De manera equivalente, esta
tesis establece que cualquier función que tiene un algoritmo es computable.
Algunas función no computable famosas son Halting problem o calcular la Complejidad
de Kolmogorov.
2.3. Sintaxis a través de gramáticas

Nuestro objetivo con respecto a la sintaxis de los lenguajes de programación es describir
de forma compacta e inambigua el conjunto de los programas válidos en ese lenguaje. El
instrumento formal básico para describir la sintaxis de los lenguajes de programación son
las gramáticas independientes de contexto. El estándar de facto para gramáticas indepen-
dientes de contexto de lenguajes de programación es EBNF.
Sin embargo, las gramáticas independientes de contexto no son suficientemente expre-
sivas para describir adecuadamente la mayor parte de lenguajes de programación. Por esa
razón, en la práctica el análisis de la forma de los programas suele incorporar diferentes
mecanismos, entre ellos, el análisis de un programa mediante una gramática independien-
te de contexto, que se complementa con otros mecanismos para alcanzar la expresividad
propia de una máquina de Turing. El proceso completo de análisis lo realiza el compilador
del lenguaje, como se describe en la sección 3.1.
No obstante, las gramáticas independientes de contexto describen el grueso de la forma
de los lenguajes de programación.
Una gramática de ejemplo clásica es la que genera los strings que representan expresio-
nes aritméticas con los cuatro operadores +, −, ∗, / y los números como operandos:
1 < expresion > --> numero
< expresion > --> ( < expresion > )
3 < expresion > --> < expresion > + < expresion >
< expresion > --> < expresion > - < expresion >
1
La historia de la colaboración entre Church y Turing es un ejemplo muy interesante de como dos
individuos geniales quieren y pueden trabajar juntos para potenciarse mútuamente y llegar a alcanzar
logros mucho mayores de los que habrı́an alcanzado cada uno por su lado. Fı́jense también en los estudiantes
a los que dirigió Church.
7
5 < expresion > --> < expresion > * < expresion >
< expresion > --> < expresion > / < expresion >
El único sı́mbolo no terminal en esta gramática es expresion, que también es el sı́mbolo
inicial. Los terminales son {+,-,*,/,(,),numero}, donde numero representa cualquier
número válido.
La primera regla (o producción) dice que una <expresion> se puede reescribir como
(o ser reemplazada por) un número. Por lo tanto, un número es una expresión válida. La
segunda regla dice que una expresión entre paréntesis es una expresión válida, usando una
definición recursiva de expresión. El resto de reglas dicen que la suma, resta, producto o
división de dos expresiones también son expresiones válidas.
Pueden encontrar algunos ejemplos simples de gramáticas independientes de contexto
en https://www.cs.rochester.edu/~nelson/courses/csc_173/grammars/cfg.html
Algunos fenómenos de los lenguajes de programación no se pueden expresar con na-
turalidad mediante gramáticas independientes de contexto. Por ejemplo es difı́cil expre-
sar la obligación de que una variable sea declarada antes de ser usada, o bien descri-
bir la asignación múltiple de variables, como podemos hacer por ejemplo en Python:
(foo, bar, baz) = 1, 2, 3.
Pregunta 1:
Piense cómo serı́a una gramática independiente de contexto para expresar la
obligación de que una variable sea declarada antes de ser usada, o la asigna-
ción múltiple de variables. ¿Cómo es la gramática resultante? ¿Resulta fácil de
pensar, fácil de entender?
Las gramáticas que describen los lenguajes de programación se usan para verificar la
correctitud de un programa escrito en ese lenguaje, mediante un compilador. En un compi-
lador, estas limitaciones se solucionan en parte porque hay módulos de procesamiento del
programa posteriores a la gramática que tratan algunos de los fenómenos que las gramáticas
no pueden capturar.
Sin embargo, también se usan las gramáticas para describir los lenguajes para consumo
humano. En ese uso, uno desea que la gramática pueda expresar de forma compacta todas
las propiedades relevantes del lenguaje. Para conseguirlo, se suelen usar mecanismos ad-
hoc para aumentar su poder expresivo, como por ejemplo predicados asociados a reglas.
Por ejemplo, si queremos establecer una restricción de tipos en una determinada regla,
podemos hacerlo de la siguiente forma:
< expresion > --> numero
2 < expresion > --> ( < expresion > )
< expresion > --> < expresion > + < expresion >
4 < expresion > --> < expresion > - < expresion >
< expresion > --> < expresion > * < expresion >
6 < expresion > --> < expresion > / < expresion > ^ < expresion >
es_de_tipo Float
8
< expresion > --> < expresion > div < expresion > ^ < expresion >
es_de_tipo Int
En la práctica, las restricciones de tipos las realiza el análisis semántico del compilador.
Para ejercitar este mecanismo de expresividad, resuelvan el ejercicio 2.11.
2.4. Semántica operacional vs. lambda cálculo o de-

notacional
Hay diferentes maneras de describir y manipular formalmente la semántica de un pro-
grama. Algunas de ellas son el lambda cálculo de Church (Mitchell 4.2), la semántica de-
notacional de Strachey & Scott (Mitchell 4.3) y diferentes tipos de semántica operacional.
En nuestro curso vamos a estar usando un tipo de semántica operacional.
La semántica operacional (de pequeños pasos) describe formalmente cómo se llevan a
cabo cada uno de los pasos de un cálculo en un sistema computacional. Para eso se suele
trabajar sobre un modelo simplificado de la máquina.
Cuando describimos la semántica de un programa mediante semántica operacional, des-
cribimos cómo un programa válido se interpreta como secuencias de pasos computacionales.
Estas secuencias son el significado del programa.
Tal vez la primera formalización de semántica operacional fue el uso del cálculo lambda
para definir la semántica de LISP que hizo [John McCarthy. ”Funciones recursivas de
expresiones simbólicas y su cómputo por máquina, Parte I”. Consultado el 2006-10-13.].
Pregunta 2:
¿Por qué puede haber más de un tipo de semántica operacional, mientras que
el lambda cálculo y la semántica denotacional son sólo uno?
2.5. Para saber más

[John McCarthy. ”Funciones recursivas de expresiones simbólicas y su cómputo por
máquina, Parte I”. Consultado el 2006-10-13.]
9
2.6. Ejercicios
Seleccione la(s) respuesta(s) correcta(s)
2.1. Una gramática describe...
a) lo que significan las sentencias de un lenguaje de programación.

b) las sentencias que forman parte de un lenguaje de programación.
c) cómo se pueden escribir sentencias en un lenguaje de programación.
d) el alfabeto de un lenguaje de programación.
2.2. Una gramática independiente de contexto (context-free grammar)...
a) tiene predicados.
b) es inambigua.
c) tiene reglas de reescritura.
d) describe la sintaxis de un lenguaje.
e) es más expresiva que una gramática dependiente del contexto.
f) es tan expresiva como una máquina de Turing.
2.3. ¿Se puede expresar con una gramática libre de contexto la obligación de declarar una
variable antes de que se use?
a) Verdadero.
b) Falso.
2.4. ¿Se puede expresar con una gramática libre de contexto la declaración de variables
con tipo?
a) Verdadero.
b) Falso.
2.5. ¿Se puede expresar con una gramática libre de contexto la asignación múltiple de
variables?
a) No.
b) Sı́, si se trata de de asignación en secuencia, y no en espejo.
c) Sı́, si se trata de un número finito de variables.
d) Todas las anteriores.
e) Ninguna de las anteriores.
10
2.6. Una gramática que puede ofrecer más de un árbol de derivación para una misma
expresión es una gramática...
a) Incorrecta.
b) Ambigua.
c) Dependiente de contexto.
d) Independiente de contexto.
2.7. ¿Dada una gramática EBNF, ¿cómo se puede probar si una secuencia de tokens es
válida?
a) Si existe una secuencia de reglas de la gramática que puedan aplicarse sucesiva-

mente desde el sı́mbolo terminal de forma que su resultado sea la secuencia de
tokens.
b) Si los tokens pertenecen al alfabeto de la gramática.
c) Si podemos dar un árbol de derivación de la secuencia.
d) Si la secuencia pertenece al lenguaje de la gramática.
2.8. La semántica de los lenguajes de programación debe reflejar formalmente...
a) la intención del programador.

b) los efectos de un programa en una computadora.
2.9. La semántica operacional...
a) describe el significado de un programa como una secuencia de transiciones de

estado a estado.
b) usa una máquina abstracta para representar el significado de un programa.
c) tiene un conjunto de operaciones para definir la semántica de un programa.
2.10. La semántica denotacional...
a) explica el significado de un programa paso a paso.

b) explica un programa como una función (parcial) de estados a estados.
c) son una traducción de un programa en cualquier lenguaje a cualquier otro len-
guaje.
2.11. En EBNF no podemos expresar lenguajes Turing completos, por esa razón necesita-
mos aumentar el poder expresivo de las gramáticas libres de contexto. Esto se hace
en la implementación con el paso posterior al análisis sintáctico, el análisis semántico.
Informalmente, podemos aumentar una gramática libre de contexto con predicados.
Escriba una EBNF aumentada con los predicados necesarios para poder expresar:
11
que una variable debe ser declarada antes de ser usada.
asignación múltiple de variables, con un número arbitrario de variables.
2.12. Considerando la asignación múltiple de variables en Python, ¿es Python un lenguaje

independiente de contexto? Justifique su respuesta.
2.13. Cuando se usa una gramática independiente de contexto para describir un lenguaje
puede suceder que la gramática resulte ambigua. ¿Cuándo decimos que una gramática
es ambigua? ¿Qué problemas presenta la ambigüedad, y cómo se pueden solucionar?
2.14. Dada la siguiente gramática:
<e> ::= <n> | <e>+<e> | <e>-<e>

<n> ::= <d> | <n><d>
<d> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
a) Enumere los conjuntos de no terminales y terminales.

b) Dé 3 ejemplos de expresiones válidas en el lenguaje definido por la gramática.
Grafique los árboles de derivación correspondientes.
c) Las siguientes secuencias de sı́mbolos: <e>,e-5, e + 6 - A ¿son expresiones váli-
das en el lenguaje? Justifique su respuesta.
d) ¿Es la gramática definida ambigua? Si lo es, de un ejemplo que pruebe su am-
bigüedad.
e) Si la gramática es ambigua, ¿qué condiciones agregarı́a para desambiguarla?
2.15. De la misma forma que obtuvimos la derivación de una expresión algebraica usando
la gramática de dı́gitos, use la siguiente gramática:
1 program = ’ PROGRAM ’ , espacio , identificador , espacio ,
’ BEGIN ’ , espacio ,
3 { asignacion , " ; " , espacio } ,
’ END . ’ ;
5 identificador = caracter_alfabetico , {
caracter_alfabetico | digito } ;
numero = [ " -" ] , digito , { digito } ;
7 string = ’" ’ , { todos_caracteres - ’" ’ } , ’" ’ ;
asignacion = identificador , " := " , ( numero |
identificador | string ) ;
9 caracter_alfabetico = " A " | " B " | " C " | " D " | " E " | " F " |
"G"
| "H" | "I" | "J" | "K" | "L" | "M"
| "N"
11 | "O" | "P" | "Q" | "R" | "S" | "T"
| "U"
12
| "V" | "W" | "X" | "Y" | "Z" ;
13 digito = " 0 " | " 1 " | " 2 " | " 3 " | " 4 " | " 5 " | " 6 " | " 7 " |
"8" | "9" ;
espacio = ? caracteres_espacio ? ;
15 all caracteres = ? todos_caracteres_visibles ? ;
Para obtener la derivación de la siguiente expresión:

1 PROGRAM DEMO1
BEGIN
3 A :=3;
TEXT := " Hello world ! " ;
5 END .
2.16. Muestre con un ejemplo que la siguiente gramática es ambigua, y modifı́quela para
que se convierta en una gramática inambigua. ¿Qué estrategias puede usar para
hacerlo?
1 < bloque > ::= { < sentencias > }
< sentencias > ::= < sentencias > < sentencia > | < sentencia >
3 < sentencia > ::= < asignacion > | < sentenciaIf > | < bloque >
< sentenciaIf > ::= if ( < expresion > ) < sentencia > |
5 if ( < expresion > ) < sentencia > else
< sentencia >
< asignacion > ::= < variable > := < expresion >
7 < expresion > ::= < variable > | < variable > < operador >
< variable >
< operador > ::= + | - | * | / | < | > | ’ and ’ | ’ or ’
9 < variable > ::= x | y | z
2.17. Dé 3 ejemplos distintos de secuencias de caracteres que satisfagan las siguientes
gramáticas. Justifique por qué.
a) ssh [-1246AaCfgKkMNnqsTtVvXxYy] [-b bind_address] [-c cipher_spec] [-D

[bind_address:]port] [-e escape_char] [-F configfile]
[-i identity_file] [-L [bind_address:]port:host:hostport]
[-l login_name] [-m mac_spec] [-O ctl_cmd] [-o option] [-p port] [-R
[bind_address:]port:host:hostport] [-S ctl_path]
[-w local_tun[:remote_tun]] [user@]hostname [command]
b) <postal-trate> ::= <nombre-parte> <calle-trate> <relampagar-parte>

<nombre-parte> ::= <personal-parte> <pasado-nombre> <OPT-jr-parte> <EOL>
| <personal-parte> <nombre-parte>
<personal-parte> ::= <primero-nombre> | <inicial> "."
<calle-trate> ::= <OPT-conveniente-numerico> <casa-numerico>
<calle-nombre> <EOL>
<relampagar-parte> ::= <ciudad-nombre> "," <estado-codigo>
<Relampagar-codigo> <EOL>
<OPT-jr-parte> ::= \Sr." | \Jr." | <romano-numero> | ""
13
c) <sintaxis> ::= <regla> | <regla> <sintaxis>
<regla> ::= <OPT-whitespace> \<\ <regla-nombre> \>\ <OPT-whitespace> "::="
<OPT-whitespace> <expresion> <linea-extremo>
<OPT-whitespace> ::= " " <OPT-whitespace> | "" 
<expresion> ::= <lista> | <lista> "|" <expresion>
<linea-extremo> ::= <OPT-whitespace> <EOL> | <linea-extremo> <linea-extremo>
<lista> ::= <termino> | <termino> <OPT-whitespace> <lista>
<termino> ::= <literal> | \<\ <regla-nombre> \>\
<literal> ::= ’"’ <texto> ’"’ | "’" <texto> "’" <¡! -- realmente, el
BNF original no utilizo cotizaciones -->
2.18. Algunos lenguajes de programación, como Python, usan la tabulación para definir el
alcance de las variables y los finales de bloque, como en el siguiente ejemplo:
1 a = " mi vieja mula ya no es lo que era "
b = 0
3 while b <= 3:
print a
5 b = b +1
¿Cómo serı́a el tokenizer para reconocer las expresiones de un lenguaje de programa-

ción ası́? Escriba una gramática EBNF para este lenguaje.
2.19. Un programa Lisp está compuesto por una sucesión de expresiones simbólicas deno-
minadas S-expressions o sexp. Éstas se definen formalmente como sigue:
1 < s_exp > ::= < atomic_symbol > | < natural > | " ( " < s_exp >
" . " < s_exp > " ) "
< atomic_symbol > ::= < letter > < atom_part > | " : " < atom_part >
3 < natural > ::= { < number >}+
< atom_part > ::= < empty > | < letter > < atom_part > | < number >
< atom_part >
5 < letter > ::= " a " | " b " | ... | " z "
< number > ::= " 1 " | " 2 " | ... | " 9 "
7 < empty > ::= " "
Determine cuáles de los siguientes son programas sintácticamente correctos. Derive,

para los que efectivamente sean programas Lisp, el árbol sintáctico correspondiente.
a) 2 .
b) a ( b )
c) (3 . 3)
d) (3 2 1)
2.20. En Lisp un dotted pair es un par escrito con un punto (.) separando ambas partes del
mismo, ej: (3 . 3). Por su parte, una lista de Lisp es una concatenación de dotted
14
pairs que además termina en el átomo nil. Por ejemplo (3 . (2 . (1 . nil))) es
una lista con los elementos 3, 2 y 1. Una “syntax sugar” para esta lista es (3 2 1).
Modifique la gramática de arriba para que admita esta forma sintáctica.
2.21. Un árbol es una estructura de datos que está formada por nodos, los cuales tienen
asociado un valor y pueden tener cero o más nodos hijos conectados. Es posible
implementar dicha estructura utilizando solamente listas, de la siguiente forma:
2 6
3 5 7 8
4
[1 [[2 [[3] [4] [5]]] [6 [[7] [8]]]]]
Escriba una EBNF que formalice la estructura de datos descripta.
2.22. Dé informalmente (explicando con lenguaje cotidiano, sin necesidad de notación ma-
temática) la semántica denotacional de estas dos funciones, es decir, explique infor-
malmente qué es lo que hacen. Son equivalentes?
1 function foo ( x ) is :
if predicate ( x ) then
3 return foo ( bar ( x ) )
else
5 return baz ( x )
1 function foo ( x ) is :
while predicate ( x ) do :
3 x <-- bar ( x )
return baz ( x )
15
Capı́tulo 3
Cómo funcionan los lenguajes de

programación
3.1. Estructura de un compilador

Mitchell 4.1.1.
3.2. Estructuras de datos de bajo nivel

3.2.1. Variables
Una de las estructuras de datos básicas de los lenguajes de programación son las va-
riables. Una variable está formada por una ubicación en la memoria y un identificador
asociado a esa ubicación. Esa ubicación contiene un valor, que es una cantidad o informa-
ción conocida o desconocida. El nombre de la variable es la forma usual de referirse al valor
almacenado: esta separación entre nombre y contenido permite que el nombre sea usado
independientemente de la información exacta que representa.
Los compiladores reemplazan los nombres simbólicos de las variables con la real ubica-
ción de los datos. Mientras que el nombre, tipo y ubicación de una variable permanecen
fijos, los datos almacenados en la ubicación pueden ser cambiados durante la ejecución del
programa.
El identificador en el código fuente puede estar ligado a un valor durante el tiempo
de ejecución y el valor de la variable puede por lo tanto cambiar durante el curso de la
ejecución del programa. De esta forma, es muy sencillo usar la variable en un proceso
repetitivo: puede asignársele un valor en un sitio, ser luego utilizada en otro, más adelante
reasignársele un nuevo valor para más tarde utilizarla de la misma manera, por ejemplo,
en procedimientos iterativos.
Diferentes identificadores del código pueden referirse a una misma ubicación en memo-
ria, lo cual se conoce como aliasing. En esta configuración, si asignamos un valor a una
variable utilizando uno de los identificadores también cambiará el valor al que se puede
16
acceder a través de los otros identificadores.
Veamos un ejemplo:
x : int ;
2 y : int ;
x : = y + 3;
En la asignación, el valor almacenado en la variable y se añade a 3 y el resultado se
almacena en la ubicación para x. Notemos que las dos variables se utilizan de manera
diferente: usamos el valor almacenado en y, independientemente de su ubicación, pero en
cambio usamos la ubicación de x, independientemente del valor almacenado en x antes de
que ocurra la asignación.
La ubicación de una variable se llama su L-valor y el valor almacenado en esta ubicación
se llama el R-valor de la variable.
En ML, los L-valores y los R-valores tienen diferentes tipos. En otras palabras, una
región de la memoria asignable tiene un tipo diferente de un valor que no se puede cambiar.
En ML, un L-valor o región asignable de la memoria se llama celda de referencia. El tipo
de una celda de referencia indica que es una celda de referencia y especifica el tipo de valor
que contiene. Por ejemplo, una celda de referencia que contiene un número entero tiene
tipo int ref.
Cuando se crea una celda de referencia, se debe inicializar a un valor del tipo correcto.
ML no tiene variables no inicializadas o punteros colgantes. Cuando una asignación cambia
el valor almacenado en una celda de referencia, la asignación debe ser coherente con el tipo
de la celda de referencia: una celda de referencia de tipo entero siempre contendrá un
entero, una celda de referencia de tipo lista contendrá siempre (o hará referencia a) una
lista, y ası́.
ML tiene operaciones para crear celdas de referencia, para acceder a su contenido y
para cambiar su contenido: ref, ! y :=, que se comportan como sigue:
ref v – crea una celda de referencia que contiene el valor v

! r – devuelve el valor contenido en la celda r
r: = v – ubica el valor v en la celda de referencia r
3.3. Ejercicios
3.1. Las variables están compuestas de... (elija la opción más precisa)
a) un nombre y un valor.
b) un l-valor y un r-valor.
c) un identificador y un valor.
d) un identificador que está ligado a un valor que está ligado a una dirección en
memoria.
17
e) un identificador que está ligado a una dirección en memoria que contiene un
valor.
f) una dirección de memoria, un valor y un identificador en el texto del programa.
3.2. El identificador de una variable es...
a) la dirección de memoria donde se encuentra un valor que se usa en un programa.

b) el string que se usa en el texto de un programa para referirse a una variable.
c) el tipo del valor de la variable.
3.3. Los “huecos” (regiones del programa en los que una variable no se puede acceder) en
el alcance de una variable (identificador de variable) se dan porque...
a) el identificador de la variable se usa para ligarse a otra variable.

b) el lifetime de la variable no llega hasta ahı́.
c) tenemos un programa no estructurado.
18
Capı́tulo 4
Estructura en bloques
4.1. Código estructurado vs. código spaghetti

Mitchell 8.1
En lenguajes como ensamblador o Fortran es muy fácil escribir programas que resulten
incomprensibles porque al que lee le cuesta entender la estructura de control del programa.
A este tipo de código se le llama código spaghetti, y aquı́ mostramos unos ejemplos:
1 10 IF ( X . GT . 0.000001) GO TO 20
X = -X
3 11 Y = X * X - SIN ( Y ) /( X +1)
IF ( X . LT . 0.000001) GO TO 50
5 20 IF ( X * Y . LT . 0.00001) GO TO 30
X = X -Y - Y
7 30 X = X + Y
...
9 50 CONTINUE
X=A
11 Y = B-A + C*C
GO TO 11
13 ...
En este ejemplo de Fortran de Mitchell (8:204) se ven algunos efectos del código spag-
hetti.
1 10 i = 0
20 i = i + 1
3 30 PRINT i ; " squared = " ; i * i
40 IF i >= 10 THEN GOTO 60
5 50 GOTO 20
60 PRINT " Program Completed . "
7 70 END
19
Este fragmento de código spaghetti podrı́a traducirse a un lenguaje con bloques de la
siguiente forma:
1 10 FOR i = 1 TO 10
20 PRINT i ; " squared = " ; i * i
3 30 NEXT i
40 PRINT " Program Completed . "
5 50 END
Para evitar este problema, la mayorı́a de los lenguajes de programación modernos pro-
porcionan alguna forma de bloque. Un bloque es una región del texto del programa con
inicio y fin explı́citos e inambiguos. Esta región del texto permite organizar de forma
explı́cita la lógica del programa. Pero además, posibilita sucesivas abstracciones sobre el
flujo de ejecución.
En primer lugar, los bloques nos permiten hacer declaraciones de variables locales. Por
ejemplo:
1 { int x = 2;
{ int y = 3;
3 x = y +2;
}
5 }
En esta sección del código hay dos bloques. Cada bloque comienza con una llave izquier-
da, {, y termina con una llave derecha, }1 . El bloque exterior comienza con la primera llave
izquierda y termina con la última llave derecha. El bloque interno se anida en el interior
del bloque exterior, comienza con la segunda llave izquierda y termina con la primera llave
derecha.
La variable x se declara en el bloque exterior y la variable y se declara en el bloque
interior. Una variable declarada dentro de un bloque se dice que es una variable local para
ese bloque. Las variables que no están declaradas en un bloque, sino en algún otro bloque
que lo contiene, se dice que es una variable global para el bloque más interno. En este
ejemplo, x es local en el bloque exterior, y es local para el bloque interior, y x es global
para el bloque interior.
Gracias a la estructura de bloques se pueden implementar mecanismos de gestión de la
memoria que permiten, por ejemplo, el llamado a funciones de forma recursiva.
Las versiones de Fortran de los años 1960 y 1970 no eran estructuradas por bloques.
En Fortran histórico, todas las variables, incluyendo todos los parámetros de cada proce-
dimiento (llamado subrutina en Fortran) tenı́an una ubicación fija en memoria. Esto hacı́a
imposible llamar a un procedimiento de forma recursiva, ya fuera directa o indirectamente.
1
Los bloques se pueden delimitar con cualquier sı́mbolo arbitrario, de hecho, los lenguajes de progra-
mación modernos ya no usan llaves sino espacios en blanco, que resultan más naturales para el humano.
Un buen ejercicio es pensar la gramática que describirı́a la sintaxis de delimitadores de bloque de Python,
como se pide en el ejercicio 2.18.
20
Si el procedimiento Fortran P llama Q, Q llama R, R y luego intenta llamar a P, la segunda
llamada a P no se puede realizar. Si P se llama por segunda vez en esta cadena de llamadas,
la segunda llamada escribirı́a sobre los parámetros y la dirección de la primera llamada,
por lo tanto, no se podrı́a volver correctamente a la primera llamada.
4.2. Estructura de bloque

Mitchell 7.1
Los lenguajes con estructrua de bloque se caracterizan por las siguientes propiedades:
Las nuevas variables se pueden declarar en varios puntos de un programa.
Cada declaración es visible dentro de una determinada región de texto del programa,
llamada bloque. Los bloques pueden ser anidados, pero no pueden superponerse par-
cialmente. En otras palabras, si dos bloques contienen expresiones o declaraciones en
común, entonces un bloque debe estar enteramente contenida dentro del otro.
Pregunta 1:
Den un ejemplo de bloques superpuestos parcialmente, y argumenten qué pro-
blemas podemos encontrar si permitimos este tipo de estructuras en nues-
tros programas.
Cuando un programa inicia la ejecución de las instrucciones contenidas en un bloque

en tiempo de ejecución, se asigna memoria a las variables declaradas en ese bloque.
Cuando un programa sale de un bloque, parte o toda la memoria asignada a las

variables declaradas en ese bloque se libera.
Un identificador de variable que no está declarado en el bloque actual se considera

global a ese bloque, y su referencia es a la entidad con el mismo identificador nombre
que se encuentra en el bloque más cercano que contiene al bloque actual.
Aunque la mayorı́a de los lenguajes de programación de propósito general modernos son

estructurados por bloques, muchos lenguajes importantes no explotan todas las capacidades
que permite la estructura por bloques. Por ejemplo, C y C ++ no permiten declaraciones
de función locales dentro de los bloques anidados, y por lo tanto no se ocupan de las
cuestiones de aplicación asociados con el retorno de las funciones de los bloques anidados.
En este capı́tulo, nos fijamos en cómo se manejan en memoria tres clases de variables:
variables locales que se almacenan en la pila de ejecución, en el activation record aso-

ciado al bloque.
parámetros de función que también se almacenan en el activation record asociada con

el bloque.
21
Figura 4.1: Modelo simplificado de la computadora que usamos para describir la semántica
operacional.
variables globales que se declaran en algún bloque que contiene al bloque actual y por
lo tanto hay que acceder a ellos desde un activation record que se colocó en la pila
de ejecución antes del bloque actual.
La mayorı́a de complicaciones y diferencias entre lenguajes están relacionadas con el

acceso a las variables globales, a consecuencia de la estructura de la pila: para dejar más a
mano las variables locales, una variable global puede quedar enterrado en la pila bajo un
número arbitrario de activation records.
4.3. Activation records

Para describir la semántica de los lenguajes de programación usamos una semántica
operacional, es decir, describimos los efectos de las diferentes expresiones del lenguaje
sobre una máquina. Para eso usamos un modelo simplificado de la computadora, el que se
ve en la figura 4.1.
Vamos a usar esta simplificación para describir cómo funcionan en memoria los lenguajes
estructurados por bloques.
Vemos que este modelo de máquina separa la memoria en la que se guarda el código de la
memoria en la que se guardan los datos. Usamos dos variables para saber a qué parte de la
memoria necesitamos acceder en cada momento de la ejecución del programa: el contador
de programa y el puntero de entorno. El contador de programa es una dirección en
la parte de la memoria donde se guarda el código, en concreto, la dirección donde se
22
encuentra la instrucción de programa que se está ejecuntando actualmente. Normalmente
se incrementa después de ejecutar cada instrucción.
El puntero de entorno nos sirve para saber cuáles son los valores que se asignan a las
variables que se están usando en una parte determinada del código. En los lenguajes no
estructurados por bloques, la memoria de datos es no estructurada, todo el espacio es heap,
y por lo tanto los valores que se asignan a las variables son visibles desde cualquier parte
del código. En cambio, en los lenguajes estructurados por bloques, se guardan en el heap
algunos datos para los que necesitamos persistencia (por ejemplo, variables globales), en
los registros guardamos algunos datos para los que queremos rápido acceso, y en la pila de
ejecución o stack se guardan los datos estructurados en forma de pila, lo cual hace posible
que se instancien variables locales y argumentos distintos para cada llamada de función.
Esto posibilita que las funciones puedan ser más abstractas y que se puedan hacer llamadas
recursivas.
Pregunta 2:
¿Por qué no se pueden hacer llamadas recursivas sin bloques ni activation re-
cords? Explique usando Fortran como ejemplo.
El stack o pila de ejecución funciona de la siguiente forma: cuando el programa entra en
un nuevo bloque, se agrega a la pila una estructura de datos que se llama activation record
o marco de pila (stack frame), que contiene el espacio para las variables locales declaradas
en el bloque, normalmente, por la parte de arriba de la pila. Entonces, el puntero de
entorno apunta al nuevo activation record. Cuando el programa sale del bloque, se retira
el activation record de la pila y el puntero de entorno se restablece a su ubicación anterior,
es decir, al puntero de entorno correspondiente a la función que llamaba a la función que
ha sido desapilada. El activation record que se apila más recientemente es el primero en
ser desapilado, a esto se le llama disciplina de pila.
En la figura 4.2 podemos ver la información que hay en un activation record de arqui-
tectura x86. Vemos que en esta arquitectura hay, además de espacio para variables locales,
también espacio para los argumentos que puede recibir una función, que funcionan como
variables locales con respecto a la función pero que son escritos por la función que la llama.
También encontramos espacio para guardar resultados intermedios, en el caso de que sea
necesario. Podemos observar que hay dos direcciones de memoria donde se guardan datos
importantes: una, el control link, contiene el que será el puntero de entorno cuando se
desapile el activation record actual, es decir, el puntero de entorno del activation record
correspondiente a la función que llamaba a la función del activation record actual. La otra
dirección de memoria distinguida es la llamada dirección de retorno, que es donde se va a
guardar el resultado de la ejecución de la función, si es que lo hay.
Los activation records pueden tener tamaños variables, por lo tanto, las operaciones que
ponen y sacan activation records de la pila guardan también en cada activation record una
variable con la dirección de memoria que corresponde a la parte superior del registro de
activación anterior. Esta variable o puntero (porque apunta a una dirección de memoria)
se llama control link, porque es el enlace que se sigue cuando se devuelve el control a la
instrucción en el bloque precedente.
23
Figura 4.2: Esquema de los contenidos de un activation record tı́pico de la arquitectura
x86.
Pregunta 3:
Aunque la mayorı́a de lenguajes estructurados por bloques se ejecutan con una
pila, las funciones de alto orden pueden hacer que falle la disciplina de pila.
¿Por qué?
Pregunta 4:
Se pueden hacer algunas optimizaciones sobre el funcionamiento de los activa-
tion records, cuáles se le ocurren?
Pregunta 5:
Los programas estructurados por bloques y su traslado a activation records en
una parte de la memoria permiten las llamadas recursivas. Pero hacer muchas
llamadas recursivas puede crear un problema en la memoria. ¿Cómo se llama
este problema y cómo lo solucionan los compiladores de algunos lenguajes?
Pregunta 6:
¿Por qué pueden tener tamaños variables los activation records?
El lenguaje de programación C está diseñado para ser fácil de compilar y ejecutar,

evitando varias de las propiedades de alcance y de manejo de memoria en general que
se describen en este capı́tulo. Sin embargo, algunas implementaciones comerciales de C y
C++ permiten tomar funciones como parámetros de otras funciones y devolver funciones
como resultado de otras funciones, preservando el alcance estático con clausuras.
24
En la siguiente sección vamos a ver cómo funcionan los activation records en ejemplos
de ejecución. Para una explicación alternativa, pueden consultar la sección correspondiente
de la wikipedia sobre la estructura de pila de llamadas.
4.3.1. Detalle de ejecución de un activation record

Mitchell 7.2
Describiremos el comportamiento de los bloques in line primero, ya que estos son más
simples que los bloques asociados a las llamadas de función. Un bloque in line es un bloque
que no es el cuerpo de una función o procedimiento.
Cuando un programa en ejecución entra en un bloque in line, se asigna espacio en
memoria para las variables que se declaran en el bloque, un conjunto de posiciones de
memoria en la pila, el activation record.
Veamos cómo funciona paso a paso, con el siguiente ejemplo de código.
1 { int x =0;
int y = x +1;
3 { int z =( x + y ) * (x - y ) ;
};
5 }
Si este código es parte de un programa más grande, la pila puede contener espacio para
otras variables antes de ejecutar este bloque.
Este código estará escrito en código máquina, traducido por el compilador, y guardado
en la parte de la memoria en la que se guarda el programa. El contador de programa
recorrerá cada una de sus instrucciones, y realizará las acciones que indiquen en memoria,
tal como sigue.
Cuando se introduce el bloque exterior, se pone en la parte superior de la pila un
activation record que contiene espacio para las variables x e y. A continuación se ejecutan
las declaraciones que establecen valores de x e y, y los valores de x e y se almacenan en las
direcciones de memoria del activation record.
Cuando se introduce el bloque interior, se apila un nuevo activation record que con
direcciones en memoria para z. Después de establecer el valor de z, el activation record
que contiene este valor se retira de la pila y el puntero de entorno deja de referirse a este
activation record y pasa a referirse al activation record que está ahora en la cabeza de la
pila. Por último, cuando se sale del bloque exterior, el activation record que con x e y se
retira de la pila y el puntero de entorno se refiere al activation record que esté en la cabeza
de la pila o a ninguno si no hay más activation records en la pila.
Podemos visualizar esta ejecución usando una secuencia de gráficos que describen la
secuencia de estados por los que pasa la pila, como se ve en la figura 4.3.
El número de direcciones en memoria que va a necesitar un activation record en tiempo
de ejecución depende del número de variables declaradas en el bloque y sus tipos. Debido a
que estas cantidades se conocen en tiempo de compilación, el compilador puede determinar
25
Figura 4.3:
Figura 4.4:
26
el formato de cada activation record y almacenar esta información como parte del código
compilado.
En general, un activation record también puede contener espacio para resultados inter-
medios, como hemos visto en la figura 4.2. Estos son valores que no reciben un identificador
de variable explı́cito en el código, pero que se guardan temporalmente para facilitar algún
cálculo.
Por ejemplo, el registro de activación para este bloque,
1 { int z = ( x + y ) * (x - y ) ; }
puede tener espacio para asignar valor a la variable z pero también para los valores x+y
y x-y, porque los valores de estas subexpresiones pueden tener que ser evaluados y alma-
cenados en algún lugar antes de multiplicarse. Si hacemos zoom en el tercer estado de la
pila de la figura 4.3, veremos lo que se muestra en la figura 4.4, con espacio para valores
temporales.
En las computadoras modernas, hay suficientes registros en memoria para guardar
estos resultados intermedios en los registros y no en la pila. No hablamos de ubicación de
registros porque es un tema que compete a los compiladores y no al diseño de lenguajes de
programación.
4.4. Ejercicios
4.1. Los activation records representan...
a) unidades en la pila de ejecución

b) stack frames
c) bloques del texto del programa
d) todos los anteriores
e) ninguno de los anteriores
4.2. Todo activation record necesariamente tiene...
a) control link
b) access link
c) variables locales
d) todas las anteriores
e) ninguna de las anteriores
4.3. Los activation records...
27
a) muestran el estado de una máquina abstracta en un momento de la ejecución.
b) se corresponden con los bloques en el texto del programa.
c) se apilan en la pila de ejecución.
d) todos los anteriores.
e) ninguno de los anteriores.
4.4. El siguiente código es código espagueti porque...

1 10 IF ( X . GT . 1) GO TO 30
20 X = -X
3 IF ( X . LT . 1) GO TO 60
30 IF ( X * Y . LT . 1) GO TO 40
5 X = X -Y - Y
40 X = X + Y
7 60 CONTINUE
X = A
9 Y = B-A
GO TO 20
a) tiene bloques.
b) las lı́neas están numeradas.
c) no podemos armar un árbol sintáctico del programa.
d) usa expresiones GOTO.
4.5. En el siguiente programa, la segunda ocurrencia de P es libre o ligada?

declare P in
2 proc { P X }
if X > 0 then { P X -1 } end
4 end
a) libre
b) ligada
Ejercicios prácticos
4.1. El siguiente es un ejemplo de “spaghetti code”. Reescrı́balo de forma que NO use
saltos (GOTO), y en cambio use programación estructurada.
28
10 i = 0
2 20 i = i + 1
30 PRINT i ; " squared = " ; i * i
4 40 IF i >= 10 THEN GOTO 60
50 GOTO 20
6 60 PRINT " Program Completed . "
70 END
4.2. Diagrame los estados de la pila de ejecución en los diferentes momentos de la ejecución
del siguiente programa, mostrando cómo se apilan y desapilan los diferentes activation
records a medida que se va ejecutando el programa. Puede representar los activation
records con la información de variables locales y control links.
1 { int x =2 { int y =3; x = y +2;}}
4.3. Diagrame como en el ejercicio anterior.

1 int sum ( int n ) {
if ( n ==0)
3 return n ;
else
5 return n + sum (n -1) ;
}
7 sum (4) ;
29
Capı́tulo 5
Control de la ejecución
5.1. Funciones y procedimientos

Mitchell 7.3
5.2. Pasaje de parámetros

Mitchell 7.3.2
https://en.wikipedia.org/wiki/Evaluation_strategy
Los nombres de los parámetros que se usan cuando se declara una función se llaman
parámetros formales. Cuando se llama a una función, se usan los llamados parámetros
reales, que son los valores efectivos de los parámetros formales en una llamada concreta a
la función. Ilustraremos la distinción entre los parámetros formales y los reales se ilustra
en el siguiente código:
1 proc p ( int x , int y ) {
if ( x > y ) then . . . else . . . ;
3 ...
x := y * 2 + 3;
5 ...
}
7 p (z , 4 * z +1) ;
Los identificadores x e y son parámetros formales del procedimiento p. Los parámetros
reales en la llamada a p son z y 4 ∗ z + 1.
La forma en que los parámetros reales se evalúan y se pasan a la función depende del
lenguaje de programación y el tipo de mecanismo de pasaje de parámetros que utiliza. Los
distintos mecanismos de pasaje de parámetros se diferencian por el momento en el que
se evalúa el parámetro real (evaluación estricta, en el momento de pasar el parámetro, o
perezosa, cuando se necesita) y por la ubicación de memoria donde se almacena el valor
30
del parámetro (la misma ubicación del bloque que hace la llamada a función o una nueva
ubicación especı́fica de la función).
La mayorı́a de los lenguajes de programación actuales evalúan los parámetros reales de
forma estricta, no perezosa, pero hay algunas excepciones. (Una de las razones para que un
lenguaje o optimización de programa podrı́a querer retrasar la evaluación de un parámetro
real es que la evaluación podrı́a ser costosa y el parámetro real podrı́a no ser utilizado en
algunas llamadas.) Entre los mecanismos que evalúan el parámetro real antes de ejecutar
el cuerpo de la función, los más comunes son el pasaje por referencia y el pasaje por
valor. Estos dos mecanismos se diferencian entre ellos por la ubicación de memoria donde
se almacena el valor del parámetro. El pasaje por referencia pasa el L-valor, es decir, la
ubicación en memoria, del parámetro real, mientras que el pasaje por valor pasa el R-valor,
es decir, el valor que hay en la ubicación de memoria.
La diferencia entre el pasaje por valor y el pasaje por referencia es importante para el
programador por varias razones:
Efectos secundarios Las asignaciones de valor en el interior del cuerpo de la función

pueden tener diferentes efectos.
Aliasing el aliasing ocurre cuando dos identificadores de variable se refieren al mismo

objeto o ubicación. Esto puede ocurrir cuando dos parámetros se pasan por referencia
o un parámetro pasado por referencia tiene la misma ubicación que la variable global
del procedimiento.
Eficiencia Pasar por valor puede ser ineficaz para grandes estructuras de datos, si hay que
copiar ese valor. Pasar por referencia puede ser menos eficiente que pasar por valor
pequeñas estructuras que se adapten bien en la pila, porque cuando los parámetros
se pasan por referencia, debemos resolver la referencia de un puntero para obtener
su valor.
Hay dos formas de describir la semántica del pasaje de parámetros: con diagramas de
la memoria y la pila que muestren si la pila contiene una copia del parámetro real o una
referencia. Otra forma es traducir el código a un lenguaje que distinga entre R-valores y
L-valores, que es lo que vamos a hacer aquı́.
5.2.1. Semántica de pasaje por valor (call-by-value)

El pasaje por valor es la estrategia de evaluación más común en los lenguajes de pro-
gramación. Es una forma estricta de pasaje de parámetros, es decir, que el argumento se
evalúa, y el valor que se obtiene (su R-valor) se liga a una variable local de la función, en
general copiando el valor a una nueva ubicación de memoria en el activation record de la
llamada a función. El valor que se encuentra en el activation record que llama a la función
no es modificado en ningún momento.
Por ejemplo, veamos esta definición de función y su llamada:
31
1 f ( x ) = { x : = x + 1; volver x };
... . f ( y ) ... ;
Si el parámetro se pasa por valor e y es una variable entera, entonces este código tiene
el mismo significado que el siguiente código ML:
fun f ( z : int ) = let x = ref z in x :=! x +1;! x end ;
2 ... f (! y ) ... ;
Como se puede ver en el tipo, el valor pasado a la función f es un número entero. El
entero es el R-valor del parámetro real y, como lo indica la expresión !y en la llamada. En
el cuerpo de f , se asigna y se inicializa una nueva ubicación para el R-valor de y.
Si el valor de y es 0 antes de la llamada, entonces el valor de f (!y) es 1 porque la
función f incrementa el parámetro y devuelve su valor. Sin embargo, el valor de y después
de la llamada es aún 0, porque la asignación dentro del cuerpo de f solamente cambia el
contenido de una ubicación temporal.
5.2.2. Semántica de pasaje por referencia call-by-reference

En pasaje por referencia se liga el L-valor del parámetro real al parámetro formal. En
este caso se tiene un único valor referenciado (o apuntado) desde dos puntos diferentes,
el programa principal y la función a la que se le pasa el argumento, por lo que cualquier
acción sobre el parámetro se realiza sobre la misma posición de memoria (aliasing).
Esto significa que la función que es llamada puede modificar la variable con efecto
en el bloque que llama a la función. De esta manera, el pasaje por referencia se puede
usar como un canal de comunicación entre la función que llama y la que es llamada, pero
a la vez resulta más difı́cil seguir el rastro de los efectos de una llamada a función, y se
pueden introducir errores sutiles. Por esta razón, aunque hay muchos lenguajes que ofrecen
pasaje por referencia, pocos lo usan como pasaje por defecto, por ejemplo, Perl. Algunos
lenguajes, como C++, PHP, Visual Basic .NET o C# tienen pasaje por valor por defecto
pero ofrecen una sintaxis especı́fica para pasar parámetros por referencia.
Veamos el detalle de la semántica de pasaje por referencia.
Considere la misma definición de la función y de llamadas utilizada en la explicación
de pasaje por valor:
f ( x ) = { x : = x + 1; volver x };
2 ... . f ( y ) ... ;
Si el parámetro se pasa por referencia e y es una variable entera, entonces este código
tiene el mismo significado que el siguiente código de ML:
fun f ( x : int ref ) = ( x := ! x +1; ! x ) ;
2 ... f ( y )
32
Como se puede ver en el tipo, el valor pasado a la función f es una referencia, un
L-valor. Si el valor de y es 0 antes de la llamada, entonces el valor de f (!y) es 1 porque
la función f incrementa el parámetro y devuelve su valor. Sin embargo, a diferencia de la
situación para el pasaje por valor, el valor de y es 1 también después de la llamada, debido
a que la asignación dentro del cuerpo de f también cambia el valor del parámetro real.
Veamos un ejemplo, escrito en una notación asimilable a Algol, que combina pasaje por
referencia y pasaje por valor:
fun f ( pass - by - ref x : int , pass - by - value y : int )
2 begin
x := 2;
4 y := 1;
if x = 1 then return 1 else return 2;
6 end ;
var z : int ;
8 z := 0;
print f (z , z ) ;
Si traducimos este ejemplo en pseudo-Algol a ML nos da:
1 fun f ( x : int ref , y : int ) =
let val yy = ref y in
3 x := 2;
yy := 1;
5 if (! x = 1) then 1 else 2
end ;
7 val z = ref 0;
f (z ,! z ) ;
Este código, que trata a los R-valores y L-valores explı́citamente, muestra que para el
pasaje por referencia se pasa un L-valor, la referencia z. Para pasaje por valor, se pasa un
R-valor, el contenido !z de z, y se le asigna una nueva ubicación temporal.
Si se pasa y por valor tal como se ve, a z se le asigna el valor 2. En cambio, si y se
hubiera pasado por referencia, entonces x e y habrı́an sido alias de la misma variable y a
z se le habrı́a asignado el valor 1.
En este otro ejemplo tenemos una función que comprueba si sus dos parámetros son
alias:
function (y , z ) {
2 y := 0;
z :=0;
4 y := 1;
if z =1 then y :=0; return 1 else y :=0; return 0
6 }
33
Si y y z son alias, entonces asignar 1 a y asignará 1 a z también, y la función devolverá 1.
De lo contrario, la función devolverá 0. Por lo tanto, una llamada f (x, x) tendrá diferentes
resultados si los parámetros se pasan por valor o por referencia.
5.2.3. Sutilezas entre pasaje por valor y pasaje por referencia

En lenguajes puramente funcionales tı́picamente no hay diferencia semántica entre pa-
saje por valor y pasaje por referencia, porque sus estructuras de datos son inmutables,
por lo que es imposible que una función pueda modificar sus argumentos. Por esta razón
normalmente se describen como de pasaje por valor, a pesar de que las implementaciones
utilizan normalmente pasaje por referencia internamente porque es más eficiente.
En algunos casos de pasaje por valor el valor que se pasa no es el habitual de la variable,
sino una referencia a una ubicación de memoria. El efecto es que lo que sintácticamente
parece llamada por valor puede terminar teniendo los efectos de un pasaje por referencia.
Lenguajes como C y ML utilizan esta técnica. No es una estrategia de evaluación indepen-
diente, ya que el lenguaje sigue teniendo pasaje por valor pero a veces se llama pasaje por
dirección de memoria. En un lenguaje con poca seguridad como C puede causar errores de
seguridad de la memoria como desreferencia de puntero nulo, y también puede ser confuso.
En cambio, en ML las referencias tienen seguridad de tipo y de memoria.
Aquı́ vemos un ejemplo de pasaje por dirección que simula pasaje por referencia en C:
void Modify ( int p , int * q , int * o )
2 {
p = 27; // pasado por valor - solo se modifica el
parametro local
4 * q = 27; // pasado por valor o referencia , verificar en
punto de llamada para comprobar cual
* o = 27; // pasado por valor o referencia , verificar en
punto de llamada para comprobar cual
6 }
int main ()
8 {
int a = 1;
10 int b = 1;
int x = 1;
12 int * c = & x ;
Modify (a , &b , c ) ; // a se pasa por valor , b se pasa por
referencia creando un puntero ,
14 // c es un puntero pasado por valor
// b y x han sido cambiados
16 return (0) ;
}
34
Hay varias razones por las que se puede pasar una referencia. Una razón puede ser
que el lenguaje no permita el pasaje por valor de estructuras de datos complejas, y se
pase una referencia para preservar esa estructura. También se usa de forma sistemática en
lenguajes con orientación a objetos, lo que se suele llamar call-by-sharing, call-by-object o
call-by-object-sharing.
En call-by-sharing, el pasaje de parámetros es por valor, pero se pasa una referencia a
un objeto. Por lo tanto, se hace una copia local del argumento que se pasa, pero esa copia
es una referencia a un objeto que es visible tanto desde la función llamada como desde la
función que llama.
La semántica de call-by-sharing difiere del pasaje por referencia en que las asignaciones
a los argumentos dentro de la función no son visibles a la función que llama, por lo que, por
ejemplo, si se pasa una variable, no es posible simular una asignación en esa variable en el
alcance de la función que llama. Por lo tanto, no se pueden hacer cambios a la referencia
que se ha pasado por valor.
Sin embargo, a través de esa referencia de la que la función llamada ha hecho una
copia, ambas funciones, la llamada y la que llama, tienen acceso al mismo objeto, no se
hace ninguna copia. Si ese objeto es mutable, los cambios que se hagan al objeto dentro de
la función llamada son visibles para la función que llama, a diferencia del pasaje por valor.
Este es el comportamiento de Java, Python, Ruby, JavaScript o OCaml. Sin embargo,
el término call-by-sharing no se usa mucho, se usan diferentes términos en los diferentes
lenguajes y documentaciones. Por ejemplo, en la comunidad Java dicen que Java tiene
pasaje por valor, mientras que en la comunidad Ruby dicen que Ruby tiene pasaje por
referencia, a pesar de que los dos lenguajes tienen la misma semántica. El call-by-sharing
implica que los valores que se pasan por parámetro se basan en objetos en lugar de tipos
primitivos, es decir que todos los valores están empaquetados.
Resuelva el ejercicio 5.11 para profundizar sobre este tipo de pasaje de parámetros.
5.2.4. Semántica de pasaje por valor-resultado

Es un tipo de pasaje de parámetros con evaluación estricta (no perezosa) poco usado
en los lenguajes de programación actuales. Se basa en que dentro de la función se trabaja
como si los argumentos hubieran sido pasados por valor, pero al acabar la función los
valores que tengan los argumentos serán copiados a la ubicación de memoria en la que se
ubicaba el valor copiado inicialmente.
Este tipo de pasaje de parámetros puede ser simulado en cualquier lenguaje que permita
el paso de valores por referencia de la siguiente forma:
1 void EjemploValorRes ( int a1 , int a2 , int a3 ) {
int aux1 = a1 , aux2 = a2 , aux3 = a3 ;
3 // codigo trabajando con aux1 , aux2 y aux3
a1 = aux1 ; a2 = aux2 ; a3 = aux3 ; // Dependiendo del
compilador la copia se realiza en un sentido o en el otro
5 }
35
Tal y como indica el ejemplo de simulación de valor-resultado, el orden de copia depende
del compilador, lo que implica que la misma función pueda dar resultados diferentes según
el compilador usado.
Pregunta 1:
Qué ventajas y qué desventajas tiene pasaje por valor-resultado?
Pregunta 2:
Haga un programa como en la sección anterior, que tenga diferentes resultados
si los parámetros se pasan por valor, por referencia o por valor-resultado.
5.2.5. Pasaje de parámetros no estricto (perezoso)

En la evaluación perezosa, los argumentos de una función no se evalúan a menos que
se utilicen efectivamente en la evaluación del cuerpo de la función.
Pregunta 3:
¿La evaluación de las alternativas de expresiones condicionales debe conside-
rarse estricta o perezosa?
Pregunta 4:
¿Se le ocurre alguna forma de optimización de la evaluación de expresiones
complejas, usando evaluación perezosa y las propiedades del absorbente de un
operador?
Pasaje por nombre call-by-name

En el pasaje call-by-name, los argumentos de una función no se evalúan antes de la
llamada a la función, sino que se sustituyen sus nombres directamente en el cuerpo de la
función y luego se dejan para ser evaluados cada vez que aparecen en la función. Si un
argumento no se utiliza en el cuerpo de la función, el argumento no se evalúa; si se utiliza
varias veces, se re-evalúa cada vez que aparece.
En algunas ocasiones, call-by-name tiene ventajas sobre pasaje por valor, por ejemplo,
si el argumento no siempre se usa, porque nos ahorramos la evaluación del argumento. Si el
argumento es un cálculo no termina, la ventaja es enorme. Sin embargo, cuando se utiliza
el argumento en la función, el pasaje por nombre es a menudo más lento.
Este tipo de pasaje se usó en ALGOL 60. Scala tiene por defecto pasaje por valor, pero
también pueden hacer pasaje por nombre. Eiffel provee agentes, operaciones que serán
evaluadas cuando sea necesario.
36
Pasaje por necesidad call-by-need
El pasaje por necesidad call-by-need es una versión memoizada de pasaje por nombre
donde, si se evalúa el argumento de la función, ese valor se almacena para usos posteriores.
En un entorno de ”puro”(sin efectos secundarios), esto produce los mismos resultados que
el pasaje por nombre; cuando el argumento de la función se utiliza dos o más veces, el
pasaje por necesidad es casi siempre más rápido.
Haskell es el lenguaje más conocido que utiliza call-by-need. R también utiliza una
forma de pasaje por necesidad. Variantes de .NET pueden simular llamada por necesidad
utilizando el tipo Lazy¡T¿.
Pregunta 5:
Haga un programa como en la sección anterior, que tenga diferentes resultados
si los parámetros se pasan por nombre, por necesidad o por algún otro método.
5.2.6. Ejercicios
5.1. Si el Browse del siguiente programa muestra 4, qué tipo de pasaje de parámetros
tiene?
1 declare A =2 B =4 C =1
proc { P X Y Z}
3 C =5
X=Z
5 C =4
Y=Z+A
7 end
in { P A B A+C}
9 { Browse B}
a) por valor
b) por referencia
c) por valor-resultado
d) por nombre
e) por por necesidad
5.2. Si el Browse del siguiente programa muestra 5, qué tipo de pasaje de parámetros
tiene?
1 declare A =2 B =4 C =1
proc { P X Y Z }
3 C =5
X=Z
37
5 C =4
Y=Z+A
7 end
in { P A B A + C }
9 { Browse B }
a) por valor
b) por referencia
c) por valor-resultado
d) por nombre
e) por por necesidad
5.3. La ventaja del pasaje de parámetros por referencia es que...
a) reduce aliasing.
b) ocupa menos lugar en la memoria.
c) no tiene efectos fuera de la función llamada.
d) permite actuar en la función que llama, si el programador lo necesita.
5.4. La ventaja del pasaje de parámetros por valor es que...
a) reduce aliasing.
5.5. La ventaja del pasaje de parámetros por valor-resultado es que...
a) reduce aliasing.
5.6. Los métodos de pasaje por parámetros que siguen la filosofı́a de evaluación perezosa
(lazy evaluation) son...
a) pasaje por referencia.

b) pasaje por valor.
c) pasaje por valor-resultado.
d) pasaje por nombre.
38
e) pasaje por necesidad.
5.7. En el siguiente programa,
begin
integer n;
procedure p(k: integer);
begin
k := k+2;
print(n);
n := n+(2*k);
end;
n := 4;
p(n);
print(n);
end;
Qué dos valores se imprimen si k se pasa...
a) por valor?
b) por valor-resultado?
c) por referencia?
5.8. [10 pt.] En el siguiente programa:
begin
integer a, b, c;
procedure p(x: integer, y: integer, z: integer);
begin
c := 5;
x := z;
c := 4;
y := z+a
end;
a := 2;
b := 4;
c := 1;
p(a, b, a+c);
print(b);
end;
a) por valor?
39
c) por referencia?
5.9. En los siguientes fragmentos de programa, introduzcan los elementos necesarios para
determinar si C y Perl funcionan por call-by-value o call-by-reference:
Fragmento en C:
1 int main ( void ) {
int x =50 , y =70;
3 ...
printf ( " x= %d y= %d " , x , y ) ;
5 return 0;
}
7
void interchange ( int x1 , int y1 ) {

9 int z1 ;
...
11 ...
...
13 printf ( " x1= %d y1= %d " , x1 , y1 ) ;
}
Fragmento en Perl:
$x =50;
2 $y =70;
& interchange ( $x , $y ) ;
4 print " x : $x y : $y \ n " ;
6 sub interchange {
( $x1 , $y1 ) = @_ ;
8 ...
...
10 ...
print " x1 : $x1 y1 : $y \ n " ;
12 }
5.10. ¿Qué diferencia hay en Scala entre pasar una variable por valor, pero lazy, a pasar
a una variable por nombre? Cree un programa que muestre estas diferencias.
5.11. Describa qué sucede en el siguiente programa en Java, teniendo en cuenta el meca-
nismo de pasaje de parámetros que utiliza el lenguaje.
public class Point {
2 public int x ;
40
public int y ;
4
public Point ( int x , int y ) {

6 this . x = x ;
this . y = y ;
8 }
10 public static void tricky1 ( Point arg1 , Point arg2 )

{
12 arg1 . x = 100;
arg1 . y = 100;
14 Point temp = arg1 ;
arg1 = arg2 ;
16 arg2 = temp ;
}
18
public static void tricky2 ( Point arg1 , Point arg2 )

20 {
arg1 = null ;
22 arg2 = null ;
}
24
public static void main ( String [] args )

26 {
Point pnt1 = new Point (0 ,0) ;
28 Point pnt2 = new Point (0 ,0) ;
System . out . println ( " pnt1 X : " + pnt1 . x + " pnt1 Y : "
+ pnt1 . y ) ;
30 System . out . println ( " pnt2 X : " + pnt2 . x + " pnt2 Y : "
+ pnt2 . y ) ;
System . out . println ( " triki1 \ n " ) ;
32 tricky1 ( pnt1 , pnt2 ) ;
System . out . println ( " pnt1 X : " + pnt1 . x + " pnt1 Y : " +
pnt1 . y ) ;
+ pnt2 . y ) ;
System . out . println ( " \ ntriki2 " ) ;
36 tricky2 ( pnt1 , pnt2 ) ;
System . out . println ( " pnt1 X : " + pnt1 . x + " pnt1 Y : " +
pnt1 . y ) ;
+ pnt2 . y ) ;
}
41
40 }
5.3. Alcance estático vs. alcance dinámico

Mitchell 7.3.3
Si un identificador x aparece en el cuerpo de una función, pero x no se declara dentro
de la función, entonces el valor de x depende de alguna declaración fuera de la función.
En esta situación, la ubicación de x está fuera del registro de activación para la función y
es una variable global a esa función. Debido a que x ha sido declarada en otro bloque, el
acceso a una x libre o global consiste en encontrar el registro de activación pertinente en
la pila.
Hay dos polı́ticas principales para buscar la declaración adecuada de un identificador
global:
alcance estático Un identificador global se refiere al identificador con ese nombre que se
declara en el bloque contenedor más cercano del texto del programa.
alcance dinámico Un identificador global se refiere al identificador asociado con el regis-

tro de activación más reciente.
Estas definiciones pueden ser difı́ciles de entender, ası́ que asegúrese de entender con
precisión los ejemplos. Una diferencia importante entre el alcance estático y el dinámico es
que la búsqueda de una declaración usando la polı́tica de alcance estático utiliza la relación
estática e inmutable entre bloques en el texto del programa. Por el contrario, el alcance
dinámico utiliza la secuencia efectiva de las llamadas que se ejecutan en la ejecución del
programa, que es dinámica y puede cambiar.
Aunque la mayorı́a de los lenguajes actuales de programación de propósito general uti-
lizan alcance estático para las declaraciones de variables y funciones, el alcance dinámico
es un concepto importante que se utiliza en lenguajes de propósito especı́fico y en cons-
trucciones especializadas como las excepciones. Algunos lenguajes con alcance dinámico
son los dialectos antiguos de Lisp, los lenguajes de marcado Tex/LaTex, las excepciones y
las macros.
Pregunta 6:
¿En qué contextos le parece que serı́a útil tener alcance dinámico?
5.3.1. Ejercicios
5.1. La clausura de una función es necesaria para...
a) definir funciones en un alcance global

b) mantener la referencia a las variables locales de la función si tenemos alcance
dinámico
42
c) mantener la referencia a las variables locales de la función si tenemos alcance
estático
d) mantener la referencia a las variables libres de la función si tenemos alcance
dinámico
e) mantener la referencia a las variables libres de la función si tenemos alcance
estático
5.2. Si el resultado del siguiente programa es 19, qué tipo de alcance tiene el lenguaje de
programación en el que está escrito?
val x = 4;
2 fun f ( y ) = x * y ;
fun g ( x ) = let
4 f (3) + x ;
g (7) ;
a) estático
b) dinámico
records a medida que se va ejecutando el programa. Puede representar los activation
records con la información de variables locales y control links. Añada en el activation
record la información necesaria para poder recuperar la información de la función,
con alcance estático.
1 int sum ( int n ) {
if ( n ==0)
3 return n ;
else
5 return n + sum (n -1) ;
}
7 sum (4) ;

1 bool isPalindrome ( char * s , int len )
{
3 if ( len < 2)
return TRUE ;
5 else
return s [0] == s [ len -1] && isPalindrome (& s [1] , len -2) ;
7 }
isPalindrome ( ‘ ‘ ada ’ ’)
43
fact ( n ) = if n <=1 then 1 else n * fact (n -1) ; fact (4) ;
5.6. Diagrame como en el ejercicio anterior, pero ahora con alcance dinámico.
1 var x =1;
function g ( z ) { return x + z ;}
3 function f ( y ) {
var x = y +1;
5 return g ( y * x ) ;
}
7 f (3)
5.7. Explique el funcionamiento del siguiente programa en pseudocódigo con alcance

estático y con alcance dinámico. Ayúdese de diagramas de active records si le re-
sulta útil.
1 local D R Div in
D =5
3 fun Div ( X )
X div D
5 end
R = Div (10)
7 Print ( R )
local D =0 R2 in
9 R2 = Div (10)
Print ( R2 )
11 end
end
5.8. Diagrame la pila de ejecución del siguiente programa en Bash, incluyendo la estruc-
tura de control links y access links, asumiendo que el lenguaje de programación tiene
alcance estático.
x =1
2 function g () { echo $x ; x =2 ; }
function f () { local x =3 ; g ; }
4 f # does this print 1 , or 3?
echo $x
En realidad este programa está escrito en Bash, que tiene alcance dinámico. Justifique
por qué puede ser que Bash se haya diseñado con lenguaje dinámico.
Qué imprimirá este programa, ahora que sabemos que tiene alcance dinámico?
44
5.9. Reescriba el siguiente programa para que sea un programa en C estándar (sin usar
gcc con -fnested-functions) con la misma semántica.
1 void f ( void )
{
3 // Define a function called g
void g ( void )
5 {
}
7 // Call g
g () ;
9 }
5.10. Reescriba el siguiente programa en Python para que sea válido en Perl en modo
estricto, poniendo atención al lugar de declaración de la variable, para que su alcance
sea exactamente el mismo en ambos programas.
1 if c :
a = ’ foo ’
3 else :
a = ’’
5.11. Determine si los siguientes lenguajes tienen alcance estático o alcance dinámico:
Python, Haskell, Java, Scala, C, Javascript y Ruby. Para cada uno de estos len-
guajes, cree un programa (simple) que lo demuestre.
5.4. Recursión a la cola

Mitchell 7.3.4
En este apartado nos fijamos en una optimización del compilador que se llama elimi-
nación de la recursión a la cola. Para las funciones recursivas a la cola, que describimos
a continuación, se puede reutilizar un activation record para una llamada recursiva a la
función. Esto reduce la cantidad de espacio de la pila que usa una función recursiva, y
evita llegar a problemas por lı́mites de hardware como el llamado stack overflow, en el que
la ejecución de un programa requiere más espacio del que hay disponible en la pila.
El principal concepto de lenguajes de programación que necesitamos entender es el
concepto de la llamada a la cola. Supongamos que la función f llama a la función g. f y g
podrı́an ser diferentes funciones o la misma, haciendo una llamada recursiva. Una llamada
a f en el cuerpo de g es una llamada de la cola si g devuelve el resultado de la llamada f
sin ningún cálculo adicional. Por ejemplo, en la función
fun g ( x ) = if x =0 then f ( x ) else f ( x ) * 2
45
Figura 5.1: Estado de la pila después de tres llamadas a factcola sin optimización del
compilador.
la primera llamada a f en el cuerpo de g es una llamada de la cola, ya que el valor de

retorno de g es exactamente el valor de retorno de la llamada a f. La segunda llamada a
f en el cuerpo de g no es una llamada de la cola porque g realiza un cálculo que involucra
el valor de retorno de f antes de que g retorne.
Una función f es recursiva de cola si todas las llamadas recursivas en el cuerpo de f
son llamadas a la cola a f.
Veamos como ejemplo la función recursiva a la cola que calcula el factorial:
1 fun factcola (n , a ) = if n <= 1 then a else factcola (n -1 , n *
a);
Para cualquier entero positivo n, factcola (n, a) devuelve n!. Podemos ver que
factcola es una función recursiva de cola porque la única llamada recursiva en el cuerpo
de factcola es una llamada a la cola.
La ventaja de la recursión de cola es que podemos utilizar el mismo activation record
para todas las llamadas recursivas. Considere la llamada factcola(3,1). La figura 5.1
muestra las partes de cada activation record en el cómputo que son relevantes para la
discusión.
5.4.1. Ejercicios
46
records a medida que se va ejecutando el programa. Diagrame en dos versiones: una
con un compilador que NO optimice las llamadas a la cola y otra con un compilador
que sı́ las optimice, sin una optimización especı́fica para llamadas recursivas a la
cola, es decir, sin overlay, pero sı́ consiguiendo que el tamaño de la pila se mantenga
constante.
1 def fact (n , acc ) :
if n ==0:
3 return acc
return fact (n -1 , acc * n )
5 fact (4 ,1)
5.5. Alto orden

Mitchell 7.4
5.5.1. Funciones de primera clase

Un lenguaje tiene funciones de primera clase si las funciones pueden ser
declaradas dentro de cualquier alcance,
pasadas como argumentos a otras funciones y,
devueltas como resultado de funciones.
En un lenguaje con funciones de primera clase y con alcance estático, un valor de

función se representa generalmente por una clausura, un par formado por un puntero al
código del cuerpo de una función y otro puntero a un activation record.
Veamos un ejemplo de función en ML que requiere a otra función como argumento:
1 fun map (f , nil ) = nil
| map (f , x :: xs ) = f ( x ) :: map (f , xs )
La función map toma una función f y una lista m como argumentos y aplica f a cada
elemento de m en orden. El resultado de map(f, m) es la lista de resultados f(x) para
elementos x de la lista m. Esta función es útil en muchos programas en los que se usan
listas. Por ejemplo, si tenemos una lista de tiempos de vencimiento para una secuencia de
eventos y queremos incrementar cada tiempo de vencimiento, podemos hacerlo pasando
una función de incremento a map.
Veremos por qué se necesitan las clausuras teniendo en cuenta las interacciones entre
el alcance estático y las funciones como argumentos y como valores de retorno. C y C ++
no admiten clausuras porque tratan de mantener el costo computacional del compilador
al mı́nimo, y las clausuras involucran un overhead no despreciable. Sin embargo, la imple-
mentación de objetos en C ++ y otros lenguajes se relaciona con la aplicación de valores
47
de función tal como se explican en este capı́tulo. La razón es que un clausura y un objeto
ambos combinan los datos y el código de la función.
5.5.2. Pasar Funciones a otras Funciones

Vamos a ver que cuando una función f se pasa a una función g, es posible que tengamos
que pasar también la clausura de f, que contiene un puntero a su activation record. Cuando
f se llama dentro del cuerpo de g, el puntero de entorno de la clausura se utiliza para
determinar cuál es el access link que tiene que guardarse en el activation record de la
llamada a f. La necesidad de clausuras en este contexto se conoce como el problema de
downward funarg, porque sucede cuando se pasan funciones como argumentos hacia abajo
en alcances anidados.
Vamos a ilustrar los principales aspectos de este problema con un programa de ejemplo
con dos declaraciones de una variable x y una función f que se pasa a otra función g:
val x = 4;
2 fun f ( y ) = x * y ;
fun g ( h ) = let val x =7 in h (3) + x ;
4 g(f);
En este programa, el cuerpo de f contiene una variable global x que se declara fuera
del cuerpo de f. Cuando f se llama dentro g, el valor de x se tiene que recuperar desde
el activation record asociado al bloque exterior. De lo contrario el cuerpo de f se evalúa
con la variable x local declarada dentro de g, lo cual es inconsistente con la semántica de
alcance estático.
Podemos ver el problema de la búsqueda de variables en la pila de ejecución después
de la llamada a f desde la invocación de g.
Esta ilustración simplificada muestra sólo los datos contenidos en cada activation record.
En esta ilustración, la expresión x * y del cuerpo de f se muestra en la parte inferior, el
activation record asociado a la invocación de f (a través del parámetro formal h de g).
48
Como muestra la ilustración, la variable y es local para la función y por lo tanto se puede
encontrar en el activation record actual. Sin embargo, la variable x es global, y se encuentra
varios registros de activación por encima del actual. Para encontrar las variables globales
tenemos que seguir los access links, por lo tanto el access link del activation record inferior
debe permitirnos alcanzar el activation record de la parte superior de la ilustración.
Cuando las funciones se pasan a otras funciones, hay que guardar el access link para el
registro de la activación de cada función para que podamos encontrar las variables globales
de esa función según la semántica del alcance estático. Y para poder cubrir este requisito
necesitamos extender alguna estructura de datos de tiempo de ejecución. Esa estructura
de datos serán las clausuras.
La solución estándar para mantener el alcance estático cuando las funciones se pasan
como argumentos a otras funciones o se devuelven como resultados es utilizar una estruc-
tura de datos llamada clausura. La clausura es un par formado por un puntero a la parte de
la memoria donde se guarda el código de la función y otro puntero a un activation record.
Debido a que cada activation record contiene un access link señalando al activation record
del bloque del texto del programa más cercano que lo contiene, un puntero al alcance en
el que se declara una función también proporciona enlaces al activation record del bloque
que la contiene.
Cuando se pasa como parámetro una función a otra función, el valor real que se pasa es
un puntero a una clausura. A partir de una clausura, una función se llama de la siguiente
forma:
5.1. Asignar un activation record para la función que se llama, como es habitual.
5.2. Establecer el access link en el activation record utilizando el puntero del activation
record de la clausura.
Podemos ver cómo esto resuelve el problema de acceso a variables para funciones que
se pasan a otras funciones como argumentos. Para ello vamos a diagramar el estado de la
pila, con los diferentes activation records, cuando se ejecuta el programa anterior, tal como
se muestra en la figura 5.2.
Podemos entender la figura 5.2 atravesando la secuencia de pasos de ejecución que
conducen a la configuración que se muestra en la figura:
5.1. Declaración de x: se apila un activation record para el bloque en el que se declara x.

El activation record contiene un valor para x y un control link que no se muestra.
5.2. Declaración de f: se apila un activation record para el bloque en ue se declara f. Este

activation record contiene un puntero a la representación en tiempo de ejecución de
f, que es una clausura con dos punteros. El primer puntero apunta al activation
record para el alcance estático de f, que es el activation record para la declaración de
f. El segundo puntero apunta al código de verb—f—, que fue producido durante la
compilación y se coloca en alguna ubicación de memoria que conoce el compilador.
49
Figura 5.2: Cómo se establecen los access links desde la clausura.
5.3. Declaración de g: Al igual que con la declaración de f, se apila un activation record

para el bloque en el que se declaró g. Este activation record contiene un puntero a la
representación en tiempo de ejecución de g, que es una clausura.
5.4. Llamada a g(f): La llamada hace que se apile un activation record para la función g.
El tamaño y estructura de este record los determina el código para g. El access link se
establece hacia el activation record para el alcance donde se declara g; el access link
apunta al mismo activation record que el activation record que hay en la clausura de
g. El activation record tiene espacio para el parámetro h y la variable local x. Debido
a que el parámetro real es la clausura de f, el valor del parámetro h es un puntero a
la clausura de f. La variable local x tiene un valor de 7, que viene dado por el código
fuente.
5.5. Llamada a h(3): El mecanismo para la ejecución de esta llamada es el punto principal
de este ejemplo. Debido a que h es un parámetro formal de g, el código de g se
compila sin saber dónde se declara la función h. Como resultado, el compilador no
puede establecer el access link para el activation record para la llamada h(3). Sin
embargo, la clausura provee esa información: el access link para este activation record
se establece mediante el puntero de activation record de la clausura de h. Debido a
que el parámetro real es f, el acces link apunta al activation record para el alcance
en el que se declaró f. Cuando se ejecuta el código de f, el access link se utiliza para
encontrar x. En concreto, el código seguirá el access link hasta el segundo activation
record de la ilustración, seguirá un access link adicional porque el compilador sabı́a,
cuando generó el código para f, que la declaración de x se encuentra un alcance por
encima de la declaración de f, y encontrará el valor 4 para la variable global x en el
cuerpo de f.
50
Como se describe en el paso 5, la clausura de f hace posible que el código que se ejecuta
encuentre el activation record que contiene la declaración global de x.
Cuando podemos pasar funciones como argumentos, los access links dentro de la pila
forman un árbol. La estructura no es lineal, porque el activation record correspondiente a
la llamada a la función h(3) tiene que saltar el activation record para g(f) para encontrar
el x adecuado. Sin embargo, todos los access links apuntan hacia arriba. Por lo tanto, sigue
siendo posible asignar y desasignar activation records mediante el uso de la disciplina de
pila (último apilado, primero desapilado).
5.6. Excepciones
Mitchell 8.2
Las excepciones proporcionan una forma estructurada de salto que se puede utilizar
para salir de una construcción tal como un bloque o llamada a función. El nombre de
excepción sugiere que las excepciones deben ser utilizados en circunstancias excepcionales.
Sin embargo, es muy habitual usarlas de formas muy poco excepcionales, como por ejemplo:
salir de un bloque o llamada de función
pasar datos como parte de un salto
volver a un punto del programa fijado para continuar la computación
Además de saltar de un punto a otro del programa, también se asocia con las excepciones
parte del manejo de memoria. Más en concreto, se pueden desapilar activation records que
ya resulten innecesarios como resultado del salto.
Todo mecanismo de excepción incluye dos construcciones lingüı́sticas:
levantar, rise o throw, una construcción para ejecutar una excepción, que corta parte
del cómputo actual y provoca un salto (transferencia de control),
un controlador, handle o catch, un mecanismo de control, que permite ciertas decla-

raciones, expresiones o llamadas a función provistos de código para responder a las
excepciones que se lanzan durante la ejecución.
Hay varias razones por las que las excepciones se han convertido en construcciones muy
aceptadas en la mayor parte de lenguajes. Muchos lenguajes no tienen ningún otro mecanis-
mo limpio para saltar fuera de una llamada de función, por ejemplo, abortando la llamada.
En lugar de utilizar instrucciones del tipo go to, que permiten crear código totalmente
desestructurado (código spaghetti), muchos programadores prefieren usar excepciones, que
se pueden utilizar para saltar sólo hacia la parte del programa que ya se ha cargado en la
pila, no hacia alguna parte del programa que no se ha ejecutado todavı́a.
Las excepciones también permiten a un programador pasar datos como parte del salto,
lo cual resulta muy útil si el programa trata de recuperarse de algún tipo de condición
51
de error. Las excepciones proporcionan un método dinámico y útil de determinar hasta
donde llega un salto. Si se declara más de un mecanismo de control, se establece cuál es el
controlador adecuado en cada caso siguiendo una semántica de alcance dinámico, lo cual
no serı́a fácil de lograr con otras formas de saltos de control.
La utilidad del alcance dinámico para estos casos se ilustra en el siguiente ejemplo, el
cálculo de la inversa de una matriz de números reales. Calculamos la multiplicación de
matrices, que se utiliza en el álgebra lineal, multiplicando las entradas de dos matrices.
Si A es una matriz e I es la matriz identidad (con unos a lo largo de la diagonal y ceros
en todas las otras posiciones), entonces la inversa A−1 de A es una matriz tal que el
producto AA−1 = I. Una matriz cuadrada tiene una inversa si y sólo si algo que se llama
el determinante de A no es igual a cero. Encontrar el determinante de una matriz requiere
aproximadamente el mismo coste computacional que invertir una matriz.
Supongamos que escribimos una función para invertir matrices que tienen entradas de
números reales. Como sólo se pueden invertir matrices con determinantes distintos de cero,
no podemos calcular correctamente la inversa de una matriz si el determinante resulta ser
cero. Una forma de manejar esta dificultad podrı́a ser la de comprobar el determinante
antes de llamar a la función de inversión. Pero esto no es una buena idea, porque calcular
el determinante de una matriz es aproximadamente tanto trabajo como invertirla. Como
podemos comprobar fácilmente el determinante cuando estamos tratando de convertir a la
inversa, tiene más sentido tratar de invertir la matriz y lanzar una excepción en el caso de
que detectemos un determinante cero. Esto lleva a un código estructurado de la siguiente
manera:
exception Determinante ; ( * Declarar excepcion Determinante * )
2 fun invertir ( aMatriz ) =
...
4 if ...
then raise Determinante ( * si el determinante de la matriz
es cero * )
6 else ...
end ;
8 invertir ( miMatriz ) handle Determinante ... ;
En este ejemplo, la función invertir genera una excepción si el determinante de
aMatrix resulta ser cero. Si la función levanta esta excepción como resultado de la llamada
invertir(myMatrix), entonces, debido a la declaración de handle asociada, la llamada
a invertir se aborta y se transfiere el control al código que sigue inmediatamente al
handle Determinante.
En este ejemplo, el mecanismo de excepción se utiliza para manejar una condición que
hace que sea imposible continuar el cálculo. En concreto, si el determinante es cero, la
matriz no tiene inversa, y es imposible para la función de inversión devolver la inversa de
la matriz.
Pregunta 7:
Si lo piensas bien, este ejemplo ilustra la necesidad de algún tipo de mecanismo
52
de alcance dinámico. Más especı́ficamente, supongamos que hay varias llamadas
para invertir en un programa que hace cálculos matriciales. Cada una de estas
llamadas podrı́an levantar la excepción Determinante. Cuando una llamada
levanta esta excepción, donde nos gustarı́a manejar la excepción?
La motivación principal para una semántica de alcance dinámico de los handles de ex-
cepción es que el código en el que se llama a la función invertir es el mejor lugar para
decidir qué hacer si el determinante es cero. Si las excepciones tuvieran alcance estático,
entonces al lanzar una excepción se saltarı́a al controlador de excepción que se declaró léxi-
camente (en el texto del programa) antes de la definición de la función invert. Si invert
está en una librerı́a de programas, entonces el controlador tendrı́a que estar también en la
librerı́a. Sin embargo, la persona que escribió la librerı́a no tiene idea de qué hacer en los
casos en que se produce la excepción. Por este motivo, las excepciones están en el alcance
de forma dinámica: cuando se produce una excepción, el control salta al controlador que
se estableció por última vez en la historia dinámica de llamadas del programa. Vamos a
ver cómo funciona esto con más detalle en algunos mecanismos de excepción especı́ficos.
5.6.1. Ejercicios
5.1. La parte de las excepciones que tiene alcance dinámico es...
a) el declare.
b) el raise.
c) el handle.
5.2. Se usa alcance dinámico en las excepciones...
a) para no colisionar con el alcance de las variables.

b) porque se busca encontrar un patrón recorriendo la pila de ejecución.
c) porque el programador tiene más claro qué quiere que quien programó las li-
brerı́as.
5.3. Las excepciones se pueden usar para optimizar código...
a) porque tienen alcance dinámico.

b) porque son saltos explı́citos entre partes del programa.
c) porque son imperativas.
d) porque son funcionales.
5.4. En las siguientes funciones en ML:
53
exception Excpt of int ;
2 fun twice (f , x ) = f ( f ( x ) ) handle Excpt ( x ) = > x ;
fun pred ( x ) = if x = 0 then raise Excpt ( x ) else x -1;
4 fun dumb ( x ) = raise Excpt ( x ) ;
fun smart ( x ) = 1 + pred ( x ) handle Excpt ( x ) = > 1;
Cuál es el resultado de evaluar cada una de las siguientes expresiones?
a) twice(pred,1)
b) twice(dumb,1)
c) twice(smart,1)
Explique qué excepción se levanta en cada caso y dónde se levanta.
5.5. En el siguiente código java, inserte en el main los mecanismos de manejo de excep-
ciones necesarios para capturar la excepción de forma adecuada.
1 public class RepartirComensales
{
3 public static void main ( String [] args )
{
5 Mesa mesa = new Mesa (1) ;
System . out . println ( " vamos a llenar la mesa 1 ... " ) ;
7 mesa . aniadirComensal ( " Ana " ) ;
mesa . aniadirComensal ( " Juan " ) ;
9 mesa . aniadirComensal ( " Maria " ) ;
mesa . aniadirComensal ( " Pedro " ) ;
11 mesa . aniadirComensal ( " Juana " ) ;
mesa . aniadirComensal ( " Esteban " ) ;
13 mesa . aniadirComensal ( " Lola " ) ;
}
15 }
17 public class Mesa

{
19 private int numeroDeComensales ;
private int numeroDeMesa ;
21 public Mesa ( int numeroDeMesa )
{
23 this . numeroDeMesa = numeroDeMesa ;
}
25 public void aniadirComensal ( string comensal ) throws
ExcepcionMesaLlena
54
{
27 if ( numeroDeComensales > 5)
{
29 throw new ExcepcionMesaLlena ( numeroDeComensales )
}
31 else
{
33 numeroDeComensales += 1;
}
35 }
}
5.6. Escriba el siguiente programa con excepciones en lugar de tratar manejo de errores
mediante estructuras de control.
Nota: no es necesario que el programa compile, puede usar pseudocódigo siempre que su
semántica sea inambigua.
codigoErrorType readFile {
2 initialize codigoError = 0;
4 // abrir el archivo ;
if ( elArchivoEstaAbierto ) {
6 // determinar la longitud del archivo ;
if ( obtenemosLongitudArchivo ) {
8 // alojar esa cantidad de memoria ;
if ( tenemosSuficienteMemoria ) {
10 // leemos el archivo a memoria ;
if ( falloLectura ) {
12 codigoError = -1;
}
14 } else {
codigoError = -2;
16 }
} else {
}
20 // cerrar el archivo ;
if ( elArchivoNoSeCerro && codigoError == 0) {
} else {
24 codigoError = codigoError and -4;
}
26 } else {
55
codigoError = -5;
28 }
return codigoError ;
30 }
5.7. En el siguiente código java, inserte en el main los mecanismos de manejo de excep-
ciones necesarios para capturar la excepción de forma adecuada.
public class BankDemo
2 {
public static void main ( String [] args )
4 {
CuentaBancaria c = new CuentaBancaria (101) ;
6 System . out . println ( " Depositando $500 ... " ) ;
c . depositar (500.00) ;
8 System . out . println ( " \ nRetirando $100 ... " ) ;
c . retirar (100.00) ;
10 System . out . println ( " \ nRetirando $600 ... " ) ;
c . retirar (600.00) ;
12 }
}
1 public class CuentaBancaria

{
3 private double balance ;
private int numero ;
5 public CuentaBancaria ( int numero )
{
7 this . numero = numero ;
}
9 public void depositar ( double cantidad )
{
11 balance += cantidad ;
}
13 public void retirar ( double cantidad ) throws
ExcepcionFondosInsuficientes
{
15 if ( cantidad <= balance )
{
17 balance -= cantidad ;
}
19 else
{
21 double necesita = cantidad - balance ;
56
throw new ExcepcionFondosInsuficientes ( necesita ) ;
23 }
}
25 public double getBalance ()
{
27 return balance ;
}
29 public int getNumber ()
{
31 return numero ;
}
33 }
5.7. Recolección de basura (garbage collection)

5.7.1. Ejercicios
5.1. Para los puntos en el código marcados con (A), (B) y (D) reporte qué variables
pueden ser recolectadas por el recolector de basura.
1 local X Y Z B R
fun { M X }
3 proc { R Y } Y = X end
end
5 P ={ M X }
Q ={ M Y } % (A)
7 R=P
in
9 X =2
local A B C R = Q Z = foo ( A f1 : B C ) in
11 {R Z} % (B)
{ Browse Z } % (C)
13 end
{R Z} % (D)
15 Y =3
{ Browse Z } % (E)
17 end
5.2. En los puntos indicandos con <----, indique cuáles son las variables que pueden ser
recolectadas si el recolector de basura (garbage collector) se ejecuta.
1 fun { Mergesort Xs }
case Xs
57
3 of nil then nil
[] [ X ] then [ X ]
5 else Ys Zs in
{ Split Xs Ys Zs }
7 <----
{ Merge { Mergesort Ys }
9 { Mergesort Zs }}
end
11 end
13 Z = [1 2 3 4 5]
XS = { Mergesort 1 | 2 | 3 | Z }
15 { Browse Z }
<----
17 { Browse XS }
<----
5.3. Escriba en pseudocódigo un ejemplo de programa donde hay variables que se pueden
recoletar semánicamente pero no sintácticamente.
5.4. Escriba en pseudocódigo un ejemplo de programa donde hay variables que, aunque
por la estructura de bloques se podrı́an recolectar, no se pueden recolectar porque
tienen una referencia de otra variable. Luego, modifique el programa anterior inser-
tando una sentencia “dereference” que elimine todas las referencias a una variable.
Ahora, la variable quedará disponible para recolección de basura? Qué problema pue-
de acarrear el uso de una sentencia como dereference? Compare ese problema con
el problema de los memory leaks, y opine sobre la gravedad de cada uno de ellos.
5.5. En el siguiente código en Ruby, cuándo se puede recolectar la memoria asociada a

obj?
module Base
2 def click ( element_hash )
begin
4 obj =
@browser . element ( element_hash . keys [0] , element_hash . values [0])
obj . when_present . click
6 report_pass ( " Element successfully clicked " )
rescue = > exception
8 report_fail ( " Failed to click on object . #{ exception })
end
10 end
58
5.6. En el siguiente programa en Java, qué variables pueden ser recolectadas por el re-
colector de basura, y cuándo? En su explicación, use el concepto de alcanzabilidad.
NOTA: En Java, obj = null elimina exactamente una referencia a un objeto.
class A { int i = 5; }
2 class B { A a = new A () ; }
class C {
4 B b;
public static void main ( String args []) {
6 C c = new C () ;
c.b = new B () ;
8 c.b = null ;
}
5.7. Compare el overhead que se da en Garbage Collection con el que se da en Orientación

a Objetos. En un caso, el overhead se encuentra en el acceso a estructuras de datos
en memoria, en otro caso el overhead se dá por cambios de contexto y procesos de
sistema. Cuál cree que proporciona un mayor beneficio en eficacia del programador,
cuál cree que contribuye a la naturalidad para expresar soluciones informáticas, cuál
cree que evita errores de programación, y por qué?
5.8. El método finalize() en Java contiene código que se ejecuta cuando el recolector
de basura reclama a un objeto. La acción obj = null; elimina una referencia a un
objeto. Cuál de estas dos acciones contribuye de forma más efectiva a la liberación
de memoria del programa?
5.9. Comente el siguiente texto, explicando primero cuál es la función del garbage co-
llector en un lenguaje de programación, y describiendo los problemas que se pueden
encontrar con el uso de finalize().
Many GC systems have a notion of ”finalization..An object may be regis-

tered with the GC system so that when it is about to reclaim the object, it
runs a function on the object that can perform necessary cleanups. Finali-
zation is tricky. Some of the issues are:
When can an object actually be finalized? This is trickier than it first ap-
pears in the presence of some normally-desirable optimizing transforma-
tions.
In what thread, resource, or security context does a finalization function
run?
What happens when registered objects reference each other?
What happens if a finalization function makes an object not be garbage any
more?
59
5.10. El método finalize() en Java se ejecuta cuando el recolector de basura reclama
un objeto. En el siguiente pedazo de código tenemos el uso del método cleanup.
Imaginemos que tanto cleanup() como finalize() se usan para liberar los recursos
asociados a myObj, por ejemplo, file handlers. Entonces, en cuál de los dos casos
sabemos con exactitud en qué momento se liberan los recursos asociados a myObj?
1 MyClass myObj ;
3 myObj = new MyClass () ;

// ...
5 myObj . finalize () ;
1 MyClass myObj ;
3 try {
myObj = new MyClass () ;
5
// ...
7 } finally {
9 if ( null != myObj ) { // no hay ninguna referencia a

myObj
myObj . cleanup () ;
11 }
}
60
Capı́tulo 6
Orientación a objetos
Mitchell 10., 11., 12.1, 12.2, 12.3, 13.1, 13.2
6.1. Ejercicios
6.1. La diferencia entre interfaces de Java y clases abstractas de C++ es que...
a) las clases abstractas de C++ permiten herencia múltiple.

b) las interfaces de Java no pueden heredar de ninguna clase.
c) las interfaces de Java permiten herencia múltiple.
d) las clases abstractas de C++ no pueden ser instanciadas.
6.2. En programación orientada a objetos, la interfaz es la parte de un objeto...
a) que se ve en la pantalla.
b) que se comunica con el resto del programa.
c) que puede ser heredada por más de una clase.
6.3. Tenemos un name clash cuando...
a) una clase hereda dos miembros con el mismo nombre de dos de sus madres.
b) las signaturas de dos clases cualquiera tienen un miembro en común.
6.4. Se dice que en Java no hay funciones porque...
a) no es un lenguaje funcional.
b) no se pueden encontrar funciones fuera de los objetos.
c) se llaman métodos.
61
6.5. La diferencia entre extends e implements en Java consiste en que...
a) extends crea relaciones de herencia, mientras que implements crea relaciones

de implementación.
b) extends se aplica para heredar de clases, mientras que implements se aplica
para heredar de interfaces.
c) extends sólo permite herencia simple, mientras que implements permite heren-
cia múltiple.
6.6. Los objetos se pueden considerar como...
a) instancias de clases.
b) ejecuciones de una función que es la clase.
c) activation records de una clase.
6.7. Muchos lenguajes proveen sintaxis amigable para referirse a algunas clases dentro de
la jerarquı́a de clases, que son:
a) las clases hermanas de la clase desde las que se las refiere.

b) la clase madre de la clase desde que se la refiere.
c) las clases ancestro de la clase desde la que se está trabajando.
d) la propia clase desde la que se está trabajando.
e) las clases descendientes de la clase desde la que se está trabajando.
6.8. En las siguientes declaraciones de clase, indique qué partes son implementación y
qué partes son interfaz, marcando la interfaz.
public class URLExpSimple {
2
public static void main ( String [] args ) {

4 try {
URL mySite = new
URL ( " http :// www . cs . utexas . edu /~ scottm " ) ;
6 URLConnection yc = mySite . openConnection () ;
Scanner in = new Scanner ( new
InputStreamReader ( yc . getInputStream () ) ) ;
8 int count = 0;
while ( in . hasNext () ) {
10 System . out . println ( in . next () ) ;
count ++;
12 }
System . out . println ( " Number of tokens : " +
count ) ;
62
14 in . close () ;
} catch ( Exception e ) {
16 e . printStackTrace () ;
}
18 }
}
1 public class Stopwatch

{
3 private long startTime ;
private long stopTime ;
5
public static final double NANOS_PER_SEC =

1000000000.0;
7
public void start ()

9 { startTime = System . nanoTime () ; }
11 public void stop ()

{ stopTime = System . nanoTime () ; }
13
public double time ()

15 { return ( stopTime - startTime ) / NANOS_PER_SEC ; }
17 public String toString () {

return " elapsed time : " + time () + " seconds . " ;
19 }
21 public long timeInNanoseconds ()

{ return ( stopTime - startTime ) ; }
23 }
1 public class MineSweeper

{ private int [][] myTruth ;
3 private boolean [][] myShow ;
5 public void cellPicked ( int row , int col )

{ if ( inBounds ( row , col ) && ! myShow [ row ][ col ] )
7 { myShow [ row ][ col ] = true ;
9 if ( myTruth [ row ][ col ] == 0)

{ for ( int r = -1; r <= 1; r ++)
11 for ( int c = -1; c <= 1; c ++)
63
cellPicked ( row + r , col + c ) ;
13 }
}
15 }
17 public boolean inBounds ( int row , int col )

{ return 0 <= row && row < myTruth . length && 0 <= col
&& col < myTruth [0]. length ;
19 }
}
public class PrimeEx {

2
public static void main ( String [] args ) {

4 printTest (10 , 4) ;
printTest (2 , 2) ;
6 printTest (54161329 , 4) ;
printTest (1882341361 , 2) ;
8 printTest (36 , 9) ;
10 System . out . println ( isPrime (54161329) + " expect false " ) ;

System . out . println ( isPrime (1882341361) + " expect
true " ) ;
12 System . out . println ( isPrime (2) + " expect true " ) ;
int numPrimes = 0;
14 Stopwatch s = new Stopwatch () ;
s . start () ;
16 for ( int i = 2; i < 10000000; i ++) {
if ( isPrime ( i ) ) {
18 numPrimes ++;
}
20 }
s . stop () ;
22 System . out . println ( numPrimes + " " + s ) ;
s . start () ;
24 boolean [] primes = getPrimes (10000000) ;
int np = 0;
26 for ( boolean b : primes )
if ( b )
28 np ++;
s . stop () ;
30 System . out . println ( np + " " + s ) ;
64
32 System . out . println ( new BigInteger (1024 , 10 , new
Random () ) ) ;
}
34
public static boolean [] getPrimes ( int max ) {

36 boolean [] result = new boolean [ max + 1];
for ( int i = 2; i < result . length ; i ++)
38 result [ i ] = true ;
final double LIMIT = Math . sqrt ( max ) ;
40 for ( int i = 2; i <= LIMIT ; i ++) {
if ( result [ i ]) {
42 // cross out all multiples ;
int index = 2 * i ;
44 while ( index < result . length ) {
result [ index ] = false ;
46 index += i ;
}
48 }
}
50 return result ;
}
52
54 public static void printTest ( int num , int

expectedFactors ) {
Stopwatch st = new Stopwatch () ;
56 st . start () ;
int actualFactors = numFactors ( num ) ;
58 st . stop () ;
System . out . println ( " Testing " + num + " expect " +
expectedFactors + " , " +
60 " actual " + actualFactors ) ;
if ( actualFactors == expectedFactors )
62 System . out . println ( " PASSED " ) ;
else
64 System . out . println ( " FAILED " ) ;
System . out . println ( st . time () ) ;
66 }
68 // pre : num >= 2

public static boolean isPrime ( int num ) {
70 assert num >= 2 : " failed precondition . num must be >=
2. num : " + num ;
65
final double LIMIT = Math . sqrt ( num ) ;
72 boolean isPrime = ( num == 2) ? true : num % 2 != 0;
int div = 3;
74 while ( div <= LIMIT && isPrime ) {
isPrime = num % div != 0;
76 div += 2;
}
78 return isPrime ;
}
80
// pre : num >= 2

82 public static int numFactors ( int num ) {
assert num >= 2 : " failed precondition . num must be >=
2. num : " + num ;
84 int result = 0;
final double SQRT = Math . sqrt ( num ) ;
86 for ( int i = 1; i < SQRT ; i ++) {
if ( num % i == 0) {
88 result += 2;
}
90 }
if ( num % SQRT == 0)
92 result ++;
return result ;
94 }
6.9. En los siguientes programas escritos en C++, indique qué parte del programa se
encontrarı́a en el archivo .h
El archivo .h o archivo de cabeceras contiene declaraciones de clases cuya implementación
se encuentra en otros archivos, con extensión .cpp. Su finalidad es ser incluı́dos en otros
archivos que usan las funciones que se declaran en el archivo de cabeceras. Por ejemplo, en
el archivo .h tendrı́amos:
class A2DD
2 {
private :
4 int gx ;
int gy ;
6
public :
8 A2DD ( int x , int y ) ; // se dejan aca las declaraciones
int getSum () ;
10 };
66
Y en el archivo a2dd.cpp escribimos la implementación:
A2DD :: A2DD ( int x , int y ) // las definiciones se prefijan con
el nombre de la clase
2 {
gx = x ;
4 gy = y ;
}
6
int A2DD :: getSum ()

8 {
return gx + gy ;
10 }
// include header file with the class declaration

2 # include " frac . hpp "
4 // include standard header files

# include < iostream >
6 # include < cstdlib >
8 / * constructor por defecto , inicializando en 0 * /

Fraction :: Fraction ()
10 : numer (0) , denom (1)
{
12 }
14 / * constructor para un numero entero , inicializando en n

*/
Fraction :: Fraction ( int n )
16 : numer ( n ) , denom (1)
{
18 }
20 / * constructor para numerador y denominador ,

inicializados segun parametro * /
Fraction :: Fraction ( int n , int d )
22 : numer ( n ) , denom ( d )
{
24 // no permitimos 0 como denominador
if ( d == 0) {
26 // salir del programa con un mensaje de error
std :: cerr << " error : el denominador es 0" <<
std :: endl ;
67
28 std :: exit ( EXIT_FAILURE ) ;
}
30 }
32 / * print * /
void Fraction :: print ()
34 {
std :: cout << numer << ’/ ’ << denom << std :: endl ;
36 }
# include " Circle . h " // cabecera definida por usuario en

el mismo directorio
2
// Constructor
4 // los valores por defecto solo se especifican en la
declaracion ,
// no se repiten en la definicion
6 Circle :: Circle ( double r , string c ) {
radius = r ;
8 color = c ;
}
10
// getter publico para el miembro de datos privado

‘‘ radius ’’
12 double Circle :: getRadius () const {
return radius ;
14 }
16 // setter publico para el miembro de datos privado

‘‘ radius ’’
void Circle :: setRadius ( double r ) {
18 radius = r ;
}
20
// getter publico para el miembro de datos privado

‘‘ color ’’
22 string Circle :: getColor () const {
return color ;
24 }
26 // setter publico para el miembro de datos privado

‘‘ color ’’
void Circle :: setColor ( string c ) {
68
28 color = c ;
}
30
// una funcion miembro publica

32 double Circle :: getArea () const {
return radius * radius * 3.14159265;
34 }
# include < iostream >

2 # include < iomanip >
# include " Time . h " // incluye la cabecera de la clase
Time
4
// Constructor con valores por defecto , sin validacion de

input
6 Time :: Time ( int h , int m , int s ) {
hour = h ;
8 minute = m ;
second = s ;
10 }
12 // getter publico para el miembro de datos privado

‘‘ hour ’’
int Time :: getHour () const {
14 return hour ;
}
16
// setter publico para el miembro de datos privado

‘‘ hour ’’, sin validacion de input
18 void Time :: setHour ( int h ) {
hour = h ;
20 }

‘‘ minute ’’
int Time :: getMinute () const {
24 return minute ;
}
26

‘‘ minute ’’, sin validacion de input
28 void Time :: setMinute ( int m ) {
minute = m ;
69
30 }

‘‘ second ’’
int Time :: getSecond () const {
34 return second ;
}
36

‘‘ second ’’, sin validacion de input
38 void Time :: setSecond ( int s ) {
second = s ;
40 }
42 // Fijar hora , minuto y segundo , sin validacion de input .

void Time :: setTime ( int h , int m , int s ) {
44 hour = h ;
minute = m ;
46 second = s ;
}
48
// Imprimir esta instancia de Time en el formato de

" hh : mm : ss "
50 void Time :: print () const {
cout << setfill ( ’0 ’) ; // zero - filled , need
< iomanip > , sticky
52 cout << setw (2) << hour // set width to 2 spaces ,
need < iomanip > , non - sticky
<< " : " << setw (2) << minute
54 << " : " << setw (2) << second << endl ;
}
56
// Aumentar esta instancia por un segundo

58 void Time :: nextSecond () {
++ second ;
60 if ( second >= 60) {
second = 0;
62 ++ minute ;
}
64 if ( minute >= 60) {
minute = 0;
66 ++ hour ;
}
70
68 if ( hour >= 24) {
hour = 0;
70 }
}
6.10. Dibuje la jerarquı́a de clases en que se basa el siguiente código.

1 class storable
{
3 public :
storable ( const char * ) ;
5 virtual void read () =0; // this becomes pure
virtual making storable an abstract
virtual void write () ; // class
7 virtual ~ storable () ;
private :
9 ... .
}
11
class transmitter : public virtual storable

13 {
public :
15 void write ()
{
17 read () ;
... .
19 }
}
21
class receiver : public virtual storable

23 {
public :
25 void read () ;
}
27
class radio : public transmitter , public receiver

29 {
public :
31 ...
}
33
int main ()
35 {
71
radio * rad = new radio () ;
37 receiver * r1 = rad ;
transmitter * r2 = rad ;
39
rad - > write () ;

41 r1 - > write () ;
r2 - > write () ;
43 return 1;
}
SpinSpots spots ;
2 SpinArm arm ;
4 void setup () {
size (640 , 360) ;
6 arm = new SpinArm ( width /2 , height /2 , 0.01) ;
spots = new SpinSpots ( width /2 , height /2 , -0.02 , 90.0) ;
8 }
10 void draw () {
background (204) ;
12 arm . update () ;
arm . display () ;
14 spots . update () ;
spots . display () ;
16 }
18 class Spin {
float x , y , speed ;
20 float angle = 0.0;
Spin ( float xpos , float ypos , float s ) {
22 x = xpos ;
y = ypos ;
24 speed = s ;
}
26 void update () {
angle += speed ;
28 }
}
30
class SpinArm extends Spin {

32 SpinArm ( float x , float y , float s ) {
super (x , y , s ) ;
72
34 }
void display () {
36 strokeWeight (1) ;
stroke (0) ;
38 pushMatrix () ;
translate (x , y ) ;
40 angle += speed ;
rotate ( angle ) ;
42 line (0 , 0 , 165 , 0) ;
popMatrix () ;
44 }
}
46
class SpinSpots extends Spin {

48 float dim ;
SpinSpots ( float x , float y , float s , float d ) {
50 super (x , y , s ) ;
dim = d ;
52 }
void display () {
54 noStroke () ;
pushMatrix () ;
56 translate (x , y ) ;
angle += speed ;
58 rotate ( angle ) ;
ellipse ( - dim /2 , 0 , dim , dim ) ;
60 ellipse ( dim /2 , 0 , dim , dim ) ;
popMatrix () ;
62 }
}
1 #!/ usr / bin / ruby
3 class Being
5 @@count = 0
7 def initialize
@@count += 1
9 puts " Being class created "
end
11
def show_count
73
13 " There are #{ @@count } beings "
end
15
end
17
class Human < Being

19
def initialize
21 super
puts " Human is created "
23 end
end
25
class Animal < Being

27
def initialize
29 super
puts " Animal is created "
31 end
end
33
class Dog < Animal

35
def initialize
37 super
puts " Dog is created "
39 end
end
41
Human . new
43 d = Dog . new
puts d . show_count
Option Strict On
2
4 Module Example
6 Class Being
Sub New ()
8 Console . WriteLine ( " Being is created " )
End Sub
10 End Class
74
12 Class Human
Inherits Being
14
Sub New ()
16 Console . WriteLine ( " Human is created " )
End Sub
18
End Class
20
Sub Main ()
22
Dim h As New Human

24
End Sub
26
End Module
1 class Opt {
public :
3 // / Returns true if a barrier has been hit
virtual bool barrier ( double S ) =0;
5 // / Returns payoff at maturity for underlying price S
virtual double pay ( double S ) =0;
7 };
9 class Vanilla :
public Opt
11 {
// / Strike
13 double K ;
public :
15 bool barrier ( double S )
{
17 return false ;
}
19 double pay ( double S )
{
21 return (S - K ) >0 ? S - K : 0;
}
23 };
25 class NoBarrier :
75
public Opt
27 {
public :
29 bool barrier ( double S )
{
31 return false ;
}
33 };
35 class Vanilla2 :
public NoBarrier
37 {
// / Strike
39 double K ;
public :
{
43 return (S - K ) >0 ? S - K : 0;
}
45 };
47 class PlainPay :
public Opt
49 {
// / Strike
51 double K ;
public :
{
55 return (S - K ) >0 ? S - K : 0;
}
57 };
59 class Vanilla3 :
public NoBarrier ,
61 public PlainPay
{
63
};
6.11. Dibuje la jerarquı́a de clases en que se basa el siguiente código.

1 class Vehicle {
76
public :
3 explicit
Vehicle ( int topSpeed )
5 : m_topSpeed ( topSpeed )
{}
7 int TopSpeed () const {
return m_topSpeed ;
9 }
11 virtual void Save ( std :: ostream & ) const = 0;
13 private :
int m_topSpeed ;
15 };
17 class WheeledLandVehicle : public Vehicle {

public :
19 WheeledLandVehicle ( int topSpeed , int numberOfWheels
)
: Vehicle ( topSpeed ) , m_numberOfWheels (
numberOfWheels )
21 {}
int NumberOfWheels () const {
23 return m_numberOfWheels ;
}
25
void Save ( std :: ostream & ) const ; // is implicitly

virtual
27
private :
29 int m_numberOfWheels ;
};
31
class TrackedLandVehicle : public Vehicle {

33 public :
TrackedLandVehicle ( int topSpeed , int numberOfTracks
)
35 : Vehicle ( topSpeed ) , m_numberOfTracks (
numberOfTracks )
{}
37 int NumberOfTracks () const {
return m_numberOfTracks ;
39 }
77
void Save ( std :: ostream & ) const ; // is implicitly
virtual
41
private :
43 int m_numberOfTracks ;
};
class DrawableObject
2 {
public :
4 virtual void Draw ( GraphicalDrawingBoard &) const = 0;
// draw to GraphicalDrawingBoard
};
6
class Triangle : public DrawableObject

8 {
public :
10 void Draw ( GraphicalDrawingBoard &) const ; // draw a
triangle
};
12
class Rectangle : public DrawableObject

14 {
public :
rectangle
};
18
class Circle : public DrawableObject

20 {
public :
circle
};
24
typedef std :: list < DrawableObject * > DrawableList ;

26
DrawableList drawableList ;
28 GraphicalDrawingBoard drawingBoard ;
30 drawableList . pushback ( new Triangle () ) ;

drawableList . pushback ( new Rectangle () ) ;
32 drawableList . pushback ( new Circle () ) ;
78
34 for ( DrawableList :: const_iterator iter =
drawableList . begin () ,
endIter = drawableList . end () ;
36 iter != endIter ;
++ iter )
38 {
DrawableObject * object = * iter ;
40 object - > Draw ( drawingBoard ) ;
}
6.12. De estos dos programas, en cuál están los objetos más acoplados?
1 public class CartEntry
{
3 public float Price ;
public int Quantity ;
5 }
7 public class CartContents

{
9 public CartEntry [] items ;
}
11
public class Order

13 {
private CartContents cart ;
15 private float salesTax ;
17 public Order ( CartContents cart , float salesTax )

{
19 this . cart = cart ;
this . salesTax = salesTax ;
21 }
23 public float OrderTotal ()

{
25 float cartTotal = 0;
for ( int i = 0; i < cart . items . Length ; i ++)
27 {
cartTotal += cart . items [ i ]. Price *
cart . items [ i ]. Quantity ;
29 }
79
cartTotal += cartTotal * salesTax ;
31 return cartTotal ;
}
33 }
1 public class CartEntry

{
3 public float Price ;
public int Quantity ;
5
public float GetLineItemTotal ()

7 {
return Price * Quantity ;
9 }
}
11
public class CartContents

13 {
public CartEntry [] items ;
15
public float GetCartItemsTotal ()

17 {
float cartTotal = 0;
19 foreach ( CartEntry item in items )
{
21 cartTotal += item . GetLineItemTotal () ;
}
23 return cartTotal ;
}
25 }
27 public class Order

{
29 private CartContents cart ;
private float salesTax ;
31
public Order ( CartContents cart , float salesTax )

33 {
this . cart = cart ;
35 this . salesTax = salesTax ;
}
37
public float OrderTotal ()
80
39 {
return cart . GetCartItemsTotal () * (1.0 f +
salesTax ) ;
41 }
}
6.13. Identifique en el siguiente código en C++ un problema con la herencia del miembro
meow.
class Felino {
2 public :
void meow () = 0;
4 };
6 class Gato : public Felino {

public :
8 void meow () { std :: cout << " miau \ n " ; }
};
10
class Tigre : public Felino {

12 public :
void meow () { std :: cout << " ROARRRRRR \ n " ; }
14 };
16 class Ocelote : public Felino {

public :
18 void meow () { std :: cout << " roarrrrr \ n " ; }
};
6.14. A partir del siguiente código Ruby hemos tratado de escribir un código Java con
la misma semántica, pero los resultados no son iguales. Cuál es la diferencia y por
qué? Cómo deberı́amos modificar el programa en Java para que haga lo mismo que
el programa en Ruby?
1 #!/ usr / bin / ruby
3 class Being
5 @@count = 0
7 def initialize
@@count += 1
9 puts " creamos un ser "
end
81
11
def show_count
13 " Hay #{ @@count } seres "
end
15
end
17
class Human < Being

19
def initialize
21 super
puts " creamos un humano "
23 end
end
25
class Animal < Being

27
def initialize
29 super
puts " creamos un animal "
31 end
end
33
class Dog < Animal

35
def initialize
37 super
puts " creamos un perro "
39 end
end
41
Human . new
43 d = Dog . new
puts d . show_count
class Being {
2
private int count = 0;

4
public Being () {
6 count ++;
System . out . println ( " creamos un ser " ) ;
8 }
82
10 public void getCount () {
System . out . format ( " hay %d seres %n " , count ) ;
12 }
}
14 class Human extends Being {
16 public Human () {
System . out . println ( " creamos un humano " ) ;
18 }
}
20 class Animal extends Being {
22 public Animal () {
System . out . println ( " creamos un animal " ) ;
24 }
}
26 class Dog extends Animal {
28 public Dog () {
System . out . println ( " creamos un perro " ) ;
30 }
}
32
public class Inheritance2 {

34
@SuppressWarnings ( " ResultOfObjectAllocationIgnored " )

36 public static void main ( String [] args ) {
new Human () ;
38 Dog dog = new Dog () ;
dog . getCount () ;
40 }
}
6.15. A partir de la siguiente template en C++, escriba una clase de C++ con la misma
semántica pero especı́fica para int.
1 template < class A_Type > class calc
{
3 public :
A_Type multiply ( A_Type x , A_Type y ) ;
5 A_Type add ( A_Type x , A_Type y ) ;
};
83
7 template < class A_Type > A_Type
calc < A_Type >:: multiply ( A_Type x , A_Type y )
{
9 return x * y ;
}
11 template < class A_Type > A_Type calc < A_Type >:: add ( A_Type
x , A_Type y )
{
13 return x + y ;
}
6.16. Los mixins son una construcción de Ruby que permite incorporar algunas de las
funcionalidades de la herencia múltiple, ya que Ruby es un lenguaje con herencia
simple. Con un mixin se pueden incluir en una clase miembros de otra clase, con
la palabra clave include. Los name clashes, si los hay, se resuelven por el orden
de los include, de forma que la última clase añadida prevalece, y sus definiciones
son las que se imponen en el caso de conflicto. Teniendo esto en cuenta, describa el
comportamiento del siguiente pedazo de código.
module EmailReporter
2 def send_report
# Send an email
4 end
end
6
module PDFReporter
8 def send_report
# Write a PDF file
10 end
end
12
class Person
14 end
16 class Employee < Person

include EmailReporter
18 include PDFReporter
end
20
class Vehicle
22 end
24 class Car < Vehicle
84
include PDFReporter
26 include EmailReporter
end
6.17. Reescriba el siguiente código en Java en Haskell, de forma que su semántica denota-
cional sea idéntica.
1 import core . List ;
import static core . List . * ;
3
import java . util . NoSuchElementException ;

5
class P01 {
7
<T > T f1 ( List <T > list ) {

9 if ( list . isEmpty () ) throw new
NoSuchElementException ( " List is empty " ) ;
List <T > elements = list . tail () ;
11 List <T > result = list ;
while ( elements . nonEmpty () ) {
13 result = elements ;
elements = elements . tail () ;
15 }
return result . head () ;
17 }
6.18. El siguiente ejemplo en C++ causa un error de compilación. Por qué? cómo puede
solucionarse?
1 class trabajador
{
3 public :
void hora_de_levantarse ( )
5 { ... . ... ... . }
};
7 class estudiante
{
9 void hora_de_levantarse ( )
{ ... . ... ... . }
11 };
class ayudante_alumno : public trabajador , public
estudiante
13 {
85
15 };
17 int main ()
{
19 ayudante_alumno obj ;
21 obj . hora_de_levantarse ( )
}
6.19. Explique qué tests realizarı́a para saber cuál es la visibilidad de un método protected
en Ruby.
6.20. Explique por qué Smalltalk es menos eficiente que C++ utilizando el concepto de
overhead. Puede ayudarse de los siguientes gráficos, en los que se muestra el proceso
de lookup de información asociada a los objetos en uno y otro lenguaje.
6.21. En el siguiente código el compilador está creando una instancia de una subclase anóni-
ma de la clase abstracta, y luego se está invocando al método de la clase abstracta.
Explique por qué es necesario que el compilador haga este proceso.
abstract class my {
2 public void mymethod () {
System . out . print ( " Abstract " ) ;
4 }
}
6
86
class poly {
8 public static void main ( String a []) {
my m = new my () {};
10 m . mymethod () ;
}
12 }
6.22. En el siguiente programa en C++ indique si hay name clashes. Si los hay, iden-
tifı́quelos y mencione alguna polı́tica para solucionarlos. Si no los hay, introdúzcalos
y añada los mecanismos para solucionarlos (no es necesario que sea el mecanismo que
efectivamente implementa C++, puede ser otra polı́tica). ¿En qué contexto se dan
los name clashes?
class Persona
2 {
private :
4 std :: string m_strNombre ;
int m_nEdad ;
6 bool m_bEsVaron ;
8 public :
Persona ( std :: string strNombre , int nEdad , bool
bEsVaron )
10 : m_strNombre ( strNombre ) , m_nEdad ( nEdad ) ,
m_bEsVaron ( bEsVaron )
{
12 }
14 std :: string GetNombre () { return m_strNombre ; }

int GetEdad () { return m_nEdad ; }
16 bool EsVaron () { return m_bEsVaron ; }
};
18
class Empleado
20 {
private :
22 std :: string m_strEmpleador ;
double m_dSalario ;
24
public :
26 Empleado ( std :: string strEmpleador , double dSalario )
: m_strEmpleador ( strEmpleador ) ,
m_dSalario ( dSalario )
87
28 {
}
30
std :: string GetEmpleador () { return m_strEmpleador ; }

32 double GetSalario () { return m_dSalario ; }
};
34
class Profesor : public Persona , public Empleado

36 {
private :
38 int m_nDictaGrado ;
40 public :
Profesor ( std :: string strNombre , int nEdad , bool
bEsVaron ,
42 std :: string strEmpleador , double dSalario , int
nDictaGrado )
: Persona ( strNombre , nEdad , bEsVaron ) ,
44 Empleado ( strEmpleador , dSalario ) ,
m_nDictaGrado ( nDictaGrado )
46 {
}
48 };
6.23. Indique si el siguiente programa en C++ se podrı́a escribir en Java con una semántica
equivalente. Si no se puede, indique por qué. Si se puede, indique con qué recursos
del lenguaje se puede.
class Persona
2 {
private :
4 std :: string m_strNombre ;
int m_nEdad ;
6 bool m_bEsVaron ;
8 public :
Persona ( std :: string strNombre , int nEdad , bool
bEsVaron )
10 : m_strNombre ( strNombre ) , m_nEdad ( nEdad ) ,
m_bEsVaron ( bEsVaron )
{
12 }
88
14 std :: string GetNombre () { return m_strNombre ; }
int GetEdad () { return m_nEdad ; }
16 bool EsVaron () { return m_bEsVaron ; }
};
18
class Empleado
20 {
private :
22 std :: string m_strEmpleador ;
double m_dSalario ;
24
public :
26 Empleado ( std :: string strEmpleador , double dSalario )
: m_strEmpleador ( strEmpleador ) ,
m_dSalario ( dSalario )
28 {
}
30
std :: string GetEmpleador () { return m_strEmpleador ; }

32 double GetSalario () { return m_dSalario ; }
};
34
class Profesor : public Persona , public Empleado

36 {
private :
38 int m_nDictaGrado ;
40 public :
Profesor ( std :: string strNombre , int nEdad , bool
bEsVaron ,
42 std :: string strEmpleador , double dSalario , int
nDictaGrado )
44 Empleado ( strEmpleador , dSalario ) ,
m_nDictaGrado ( nDictaGrado )
46 {
}
48 };
6.24. En Java existen dos formas de crear un nuevo thread explı́citamente: creando una
subclase de la clase Thread o bien implementando la interfaz Runnable. En ambos
casos el nuevo thread debe implementar el método run, que contendrá el código
ejecutado por el thread. Cuál de estas dos opciones crea un objeto más versátil y por
89
qué?
6.25. Estos dos programas, en dos lenguajes distintos, tienen la misma semántica. ¿Cuáles
son las diferencias entre estos dos lenguajes? Refiérase a los elementos de los progra-
mas que ejemplifican las diferencias entre estos dos lenguajes. Cuando sea relevante,
argumente las ventajas y desventajas de la forma de expresión de cada lenguaje.
interface Iterable <T >
2 def each (& block : T - >)
end
4
interface Addable <T >

6 def +( other : T )
end
8
def sum ( values : Iterable <T >) where T : Addable <T >
10 count = 0
values . each do | value |
12 count += value
end
14 count
end
1 def sum ( values )

count = 0
3 values . each do | value |
count += value
5 end
count
7 end
90
Capı́tulo 7
Tipos de datos
Mitchell 6.1., 6.2., 6.3., 6.4., 13.3
7.1. Ejercicios
7.1. Los tipos son...
a) reglas sobre cómo usar las variables.

b) analizados por el compilador posteriormente al análisis sintáctico.
c) conjuntos de valores.
7.2. el tipado estático difiere del tipado dinámico en que...
a) en tipado estático no puede haber coerción (casteo) de tipos.

b) en tipado dinámico tiene que haber coerción (casteo) de tipos.
c) el tipado estático se hace en tiempo de compilación, y el dinámico en tiempo de
ejecución.
d) un lenguaje con tipado estático no puede tener tipado dinámico.
e) en tipado estático los tipos se tienen que declarar explı́citamente, mientras que
en tipado dinámico no hay que declararlos.
7.3. La inferencia de tipos se realiza...
a) en tiempo de compilación.
b) en tiempo de ejecución.
c) parte en tiempo de compilación, parte en tiempo de ejecución.
d) con tipos explı́citos.
91
7.4. Un lenguaje es seguro en tipado (type safe) si...
a) no se permite ningún tipo de error atribuible a tipos.

b) se detectan como errores las discrepancias entre los tipos de variables y métodos
o funciones.
7.5. Los tipos built-in son...
a) los que provee el lenguaje propiamente.

b) el opuesto de los tipos user-defined.
c) todos los anteriores.
d) ninguno de los anteriores.
7.6. La diferencia entre polimorfismo y sobrecarga es...
a) que sobrecarga se aplica sólo a algunos tipos, mientras que polimorfismo es más
general.
b) que la sobrecarga se comprueba en tiempo de ejecución y el polimorfismo en
tiempo de compilación.
c) que en la sobrecarga tenemos diferentes implementaciones para un mismo sı́mbo-
lo y en el polimorfismo tenemos una sola implementación con tipos generales.
d) que la sobrecarga usa tipos concretos mientras que el polimorfismo usa variables
de tipo.
e) que la sobrecarga la analiza el compilador y el polimorfismo no.
Ejercicios prácticos
7.1. En base al siguiente árbol de parseo, calcule el tipo de datos de la función implemen-
tada en ML.
fun f(g,h) = g(h) + 2;
92
158 Type Systems and Type Inference
158 Type Systems and Type Inference
λ
λ
& !
&& !!
&& !!
&& !!
!!
&& !!
& & !
@
& & @
& & " !
& & "" !!
"" !!
&& !!
&& "" !!
@ "
&& @ !
2
& # 2
% ##
%%
%% ##
+% #
@
+ @#
int → int → int
int → int → int $ ##
$$ ##
$$ #
$ h
g h
g
6.6 Parse Graph

7.2.6.6EnParse Graph
Usebase al siguiente
the following árbol
parse graph de parseo,
to follow the steps calcule
of the MLel tipo de datos
type-inference algo- de la función implemen-
rithmthe
Use
tada en following
ML.
on the parse
function graph to follow the steps of the ML type-inference algo-
declaration
rithm on the function declaration
fun f(g) = g(g) + 2;
fun f(g) = g(g) + 2;
fun
Whatf(g) = g(g)
is the output of the +
type2;
checker?
What is the output of the type checker?
λ
λ
& !
&& !!
&& !!
&& !!
& !!
& !!
& & !
@
& & @
&& " !
&& "" !!
"" !!
&& !!
&& "" !!
&& @" !
& @ 2
% # 2
%% # #
%% ##
+% #
@
+ @#
int → int → int
int → int → int $ ##
$$ ##
$ $ #
$ g
g g
g
7.3. Calcule el tipo de datos de la siguientes funciones implementadas en ML:
a) fun a(x,y) = x+2*y;

b) fun b(x,y) = x+y/2.0;
93
c) fun d(f,x) = f(f(x)));
7.4. Calcule el tipo de datos de las siguientes funciones en ML. Provea el árbol sintáctico
de la función y aplique de forma explı́cita el algoritmo de inferencia de tipos, ya sea
sobre el árbol mismo o como sistema de ecuaciones.
fun a(x,y) = (x > 2) orelse (y < 10);
fun a(f,x,y) = f(x*2+3) andalso y;
fun d(f,x) = f(x*2) andalso true
fun aplicar(f,x) = f(x)
7.5. En el siguiente texto, explique si el diseño de Crystal con duck typing mantiene
los principios de seguridad del tipado estático, qué errores se podrı́an producir y
qué errores no.
The language allows you to program using duck-typing, in a way. For exam-
ple if you have a variable ”duck.and you assign a Duck to it and invoke
”quack.on it, given a Duck quacks, it will work. Now if later you assign a
Horse to it, and the horse doesn’t quack, you will get a compile error. So,
the compiler catches the error at compile time. Now, if you assign another
type, say, a Goose, and it quacks, then the code continue to compile fine
(provided that it returns the correct type, which again is determined by its
methods, and so on). The new type will be Duck | Goose. In short: there’s
no “undefined method” errors at runtime in Crystal.
94
Capı́tulo 8
Paradigma funcional
Mitchell 4.4.
Van Roy y Haridi. 2004. Concepts, Techniques, and Models of Computer Programming.
MIT Press. Capı́tulo 3: introducción
8.1. Expresiones imperativas vs. expresiones funcio-

nales
En muchos lenguajes de programación, las construcciones básicas son imperativas, del
mismo modo que lo serı́a una oración imperativa en lenguaje natural, como por ejemplo
“Traeme esa manzana.”. Por ejemplo, esta instrucción de asignación:
1 x: = 5
es una orden que el programador le da a la computadora para guardar el valor 5 en un
lugar determinado.
Los lenguajes de programación también contienen construcciones declarativas, como la
declaración de la función
1 function f ( int x ) { return x +1; }
que describe un hecho, de la misma forma que en lenguaje natural podrı́amos decir “La
tierra es redonda.”. En este ejemplo, lo que describimos es que “f es una función cuyo valor
de retorno es 1 mayor que su argumento.”.
La distinción entre construcciones imperativas y declarativas se basa en que las impe-
rativas cambian un valor y las declarativas declaran un nuevo valor. Por ejemplo, en el
siguiente fragmento de programa:
1 { int x = 1;
x = x +1;
3 { int y = x +1;
{ int x = y +1;
5 }}}
95
sólo la segunda lı́nea es una operación imperativa, las otras lı́neas contienen declaraciones
de nuevas variables.
Un punto sutil es que la última lı́nea en el código anterior declara una nueva variable con
el mismo nombre que el de una variable declarada anteriormente. La forma más sencilla de
entender la diferencia entre declarar una nueva variable y cambiar el valor de una variable
ya existente es cambiando el nombre de la variable. Las variables ligadas, que no son libres
en una expresión (que están definidas dentro del alcance de la expresión) pueden cambiar
de nombre sin cambiar el significado de la expresión. En particular, podemos cambiar
el nombre de las variables ligadas en el fragmento de programa anterior de la siguiente
manera:
1 { int x = 1;
x = x +1;
3 { int y = x +1;
{ int z = y +1;
5 }}}
(Si hubiera más ocurrencias de x dentro del bloque interior, también les cambiarı́amos el
nombre a z.) Después de volver a escribir el programa a esta forma equivalente, podemos
ver fácilmente que la declaración de una nueva variable z no cambia el valor de cualquier
variable ya existente.
La asignación imperativa puede introducir efectos secundarios porque puede destruir
el valor anterior de una variable, sustituyéndolo por uno nuevo, de forma que éste no
esté disponible más adelante. En programación funcional la asignación imperativa se conoce
como asignación o actualización destructiva.
Decimos que una operación computacional es declarativa si, cada vez que se invoca con
los mismos argumentos, devuelve los mismos resultados independientemente de cualquier
otro estado de computación. Una operación declarativa es:
independiente no depende de ningún estado de la ejecución por fuera de sı́ misma,
sin estado no tiene estados de ejecución internos que sean recordados entre invocaciones,
y
determinı́stica siempre produce los mismos resultados para los mismos argumentos y,
por extensión, ejecutar la operación no tendrá efectos secundarios.
Una consecuencia muy valiosa de estas propiedades es la conocida como transparencia
referencial. Una expresión es transparente referencialmente si se puede sustituir por su valor
sin cambiar la semántica del programa. Esto hace que todas las componentes declarativas,
incluso las más complejas, se puedan usar como valores en un programa, por ejemplo, como
argumentos de función, como resultados de función o como partes de estructuras de datos.
Esto aporta una gran flexibilidad a los lenguajes funcionales, ya que se pueden tratar de
forma homogénea expresiones de estructura muy variable, como por ejemplo en el siguiente
programa:
96
1 HayAlgunExceso xs n = foldr ( filter ( > n ) ( map
convertirSistemaMetrico xs ) ) False xs
Veamos un ejemplo de dos funciones, una referencialmente transparente y otra referen-
cialmente opaca:
1 globalValue = 0;
3 integer function rq ( integer x )

begin
5 globalValue = globalValue + 1;
return x + globalValue ;
7 end
9 integer function rt ( integer x )

begin
11 return x + 1;
end
La función rt es referencialmente transparente, lo cual significa que rt(x) = rt(y) si x
= y. Sin embargo, no podemos decir lo mismo de rq porque usa y modifica una variable
global. Por ejemplo, si queremos razonar sobre la siguiente aserción:
integer p = rq ( x ) + rq ( y ) * ( rq ( x ) - rq ( x ) ) ;
Podrı́amos querer simplificarla de la siguiente forma:
1 integer p = rq ( x ) + rq ( y ) * (0) ;
integer p = rq ( x ) + 0;
3 integer p = rq ( x ) ;
Pero esto no es válido para rq() porque cada ocurrencia de rq(x) se evalúa a un valor
distinto. Recordemos que el valor de retorno de rq está basado en una variable global que
no se pasa como parámetro de la función y que se modifica en cada llamada a rq. Esto
implica que no podemos asegurar la veracidad de aserciones como x − x = 0.
Por lo tanto, la transparencia referencial nos permite razonar sobre nuestro código de
forma que podemos construir programas más robustos, podemos encontrar errores que no
podrı́amos haber encontrado mediante testing y podemos encontrar posibles optimizaciones
que podemos trasladar al compilador.
8.2. Propiedades valiosas de los lenguajes funcionales

Los lenguajes funcionales, como Lisp o ML, realizan la mayor parte del cómputo me-
diante expresiones con declaraciones de funciones. Todos los lenguajes funcionales tienen
también construcciones imperativas, pero en esos lenguajes se pueden escribir programas
muy completos sin usarlas.
97
En algunos casos se usa el término “lenguaje funcional” para referirse a lenguajes
que no tienen expresiones con efectos secundarios o cualquier otra forma de construcción
imperativa. Para evitar ambigüedades entre estos y lenguajes como Lisp o ML, llamaremos
a estos últimos “lenguajes funcionales puros”. Los lenguajes funcionales puros pueden pasar
el siguiente test:
Dentro del alcance de las declaraciones x1 , ..., xn , todas las ocurrencias de una
expresión e que contenga sólo las variables x1 , ..., xn tendrán el mismo valor.
Como consecuencia de esta propiedad, los lenguajes funcionales puros tienen una propiedad
muy útil: si la expresión e ocurre en varios lugares dentro de un alcance especı́fico, entonces
la expresión sólo necesita evaluarse una vez. Esto permite que el compilador pueda hacer
optimizaciones de cálculo y de espacio en memoria (aunque no necesariamente todos los
compiladores de todos los lenguajes funcionales lo van a hacer).
Otra propiedad interesante de los programas declarativos es que son composicionales.
Un programa declarativo consiste de componentes que pueden ser escritos, comprobados,
y probados correctos independientemente de otros componentes y de su propia historia
pasada (invocaciones previas).
Otra propiedad interesante es que razonar sobre programas declarativos es sencillo. Es
más fácil razonar sobre programas escritos en el modelo declarativo que sobre programas
escritos en modelos más expresivos. Como los programas declarativos sólo pueden calcular
valores, se pueden usar técnicas sencillas de razonamiento algebraico y lógico.
En un programa declarativo, la interacción entre componentes se determina únicamente
por las entradas y salidas de cada componente. Considere un programa con un componente
declarativo. Este componente puede ser mirado en sı́ mismo, sin tener que entender el resto
del programa. El esfuerzo que se necesita para entender el programa completo es la suma
de los esfuerzos que se necesitan para entender el componente declarativo y para entender
el resto.
Si existiera una interacción más estrecha entre el componente y el resto del programa
no se podrı́an entender independientemente. Tendrı́an que entenderse juntos, y el esfuerzo
requerido serı́a mucho más grande. Por ejemplo, podrı́a ser (aproximadamente) proporcio-
nal al producto de los esfuerzos requeridos para entender cada parte. En un programa con
muchos componentes que interactuán estrechamente, esto explota muy rápido, difcultan-
do o haciendo imposible entenderlo. Un ejemplo de interacción estrecha es un programa
concurrente con estado compartido.
Pero para algunos problemas, es necesario trabajar con interacciones estrechas. Sin
embargo, podemos adoptar por principio la directiva de tratar de hacer código lo más
modular posible, con interacciones estrechas sólo cuando sea necesario y no en cualquier
caso. Para soportar este principio, el total de componentes declarativos deberı́a ser el mayor
número posible.
Estas dos propiedades son importantes tanto para programar en grande como en pe-
queño. Serı́a muy agradable si todos los programas pudieran escribirse en el modelo de-
clarativo. Desafortunadamente, este no es el caso. El modelo declarativo encaja bien con
ciertas clases de programas y mal con otras.
98
8.3. Problemas naturalmente no declarativos
La forma más elegante y natural (compacta e intuitiva) de representar algunos proble-
mas es mediante estado explı́cito. Es el caso, por ejemplo, de las aplicaciones cliente-servidor
y de las aplicaciones que muestran video. En general, todo programa que realice algún tipo
de Input-Output lo hará de forma más natural mediante estado explı́cito. También es el
caso en el que estamos tratando de modelar algún tipo de comportamiento (por ejemplo,
agentes inteligentes, juegos) en el que representamos a una componente de software como
una entidad que tiene memoria, porque inherentemente la memoria cambia a lo largo del
tiempo.
Pregunta 1:
Piense algunos ejemplos de problemas en los que el estado deberı́a estar repre-
sentado en la solución de software de forma explı́cita.
También hay tipos de problemas que se pueden programar de forma mucho más eficiente
si se hace de forma imperativa. En esos casos podemos llegar a convertir un problema
que es intratable con programación declarativa en un problema tratable. Este es el
caso de un programa que realiza modificaciones incrementales de estructuras de datos
grandes, e.g., una simulación que modifica grafos grandes, que en general no puede ser
compilado eficientemente. Sin embargo, si el estado está guardado en un acumulador y el
programa nunca requiere acceder a un estado ya pasado, entonces el acumulador se puede
implementar con asignación destructiva (ver Van Roy y Haridi 6.8.4.).
Por esta razón muchos lenguajes funcionales proveen algún tipo de construcción lingüı́sti-
ca para poder expresar instrucciones imperativas. Incluso en lenguajes funcionales puros
existen estas construcciones, que en general se conocen como mónadas. Las mónadas son
una construcción de un lenguaje que permite crear un alcance aislado del resto del pro-
grama. Dentro de ese alcance, se permiten ciertas operaciones con efectos secundarios, por
ejemplo, el uso de variables globales (globales al alcance) o asignación destructiva. Está ga-
rantizado que estos efectos secundarios no van a afectar a la parte del programa que queda
fuera del alcance de la mónada. Las mónadas han sido descritas como un “punto y coma
programable”, que transportan datos entre unidades funcionales que los van transformando
un paso a la vez.
Sabiendo todo esto, ¿podemos considerar que la programación declarativa es eficien-
te? Existe una distancia muy grande entre el modelo declarativo y la arquitectura de una
computadora. La computadora está optimizada para modificar datos en su lugar, mientras
que el modelo declarativo nunca modifica los datos sino que siempre crea datos nuevos.
Pero sin embargo esto no es un problema tan grave como podrı́a parecer, porque el com-
pilador puede convertir partes importantes de los programas funcionales en instrucciones
imperativas.
Pregunta 2:
Piense dos ejemplos de operación declarativa y dos ejemplos de operación no
declarativa
99
Pregunta 3:
Piense por lo menos una operación que no se pueda llevar a cabo sin estado
8.4. Concurrencia declarativa

Una consecuencia muy valiosa de los programas escritos de forma funcional pura, sin
expresiones con efectos secundarios, es que se pueden ejecutar de forma concurrente con
otros programas con la garantı́a de que su semántica permanecerá inalterada. De esta forma,
paralelizar programas funcionales puros es trivial. En cambio, para paralelizar programas
imperativos, es necesario detectar primero las posibles regiones del programa donde puede
haber condiciones de carrera, y, si es necesario, establecer condiciones de exclusión mútua.
Backus acuñó el término “el cuello de botella von Neumann” (von Neumann bottleneck)
para referirse al hecho de que cuando ejecutamos un programa imperativo, la computación
funciona de a un paso por vez. Como es posible que cada paso en un programa dependa
del previo, tenemos que pasar el estado de la memoria (asignación de valores a variables)
de la memoria a la CPU cada vez que ejecutamos un paso de la computación. Este canal
secuencial entre la CPU y la memoria es el cuello de botella von Neumann.
Sin embargo, aunque paralelizar programas funcionales sea trivial, es difı́cil aprovechar
este potencial en la práctica. Efectivamente, en algunos puntos de un programa tiene sentido
introducir paralelismo y en otros no. El paralelismo tiene un pequeño coste (overhead) en
la creación de nuevos procesos, incluso si son ligeros, y también en el posible cambio de
contexto si hay un solo procesador. Por otro lado, si la ejecución de un proceso depende del
resultado de otro, no se obtiene ningún beneficio al paralelizarlos. Es necesario entonces
hacer algún tipo de análisis previo para que la paralelización de los programas declarativos
sea realmente efectiva.
8.5. Ejercicios
8.1. Cuál de estas dos funciones, rq o rt, es transparente referencialmente?
1 globalValue = 0;
3 integer function rq ( integer x )

begin
5 globalValue = globalValue + 1;
return x + globalValue ;
7 end
9 integer function rt ( integer x )

begin
11 return x + 1;
end
100
8.2. El siguiente pedazo de código es declarativo? Por qué?
{ int x = 1;
2 x = x +1;
{ int y = x +1;
4 { int x = y + z ;
}}}
8.3. En los siguientes programas imperativos, identifique porciones de código que no sean
declarativas.
1 int A ;
int B ;
3
int Add ()
5 {
return A + B ;
7 }
9 int main ()
{
11 int answer ; // Local variable
A = 5;
13 B = 7;
answer = Add () ;
15 printf ( " %d \ n " , answer ) ;
return 0;
17 }
1 int glob = 0;
3 int square ( int x )

{
5 glob = 1;
return x * x ;
7 }
9 int main ()
{
11 int res ;
glob = 0;
13
101
res = square (5) ;
15 res += glob ;
17 return res ;
}
8.4. Reescriba el siguiente código en Java en un lenguaje declarativo, por ejemplo Haskell
o pseudocódigo declarativo, de forma que su semántica denotacional sea idéntica.
class P01 {
2
<T > T f1 ( List <T > list ) {

4 if ( list . isEmpty () ) throw new
NoHayElemento ( " lista vacia " ) ;
List <T > elements = list . tail () ;
6 List <T > result = list ;
while ( elements . nonEmpty () ) {
8 result = elements ;
elements = elements . tail () ;
10 }
return result . head () ;
12 }
8.5. En un programa imperativo cualquiera, identifique porciones de código que no sean

declarativas.
8.6. En un programa imperativo cualquiera, identifique posibles canales por los que even-
tualmente propagarse efectos secundarios.
102
Capı́tulo 9
Programación lógica
Mitchell 15.
9.1. Ejercicios
9.1. Por qué el cut (!) no pertenece al paradigma declarativo?
a) porque no es un objetivo en prolog

b) porque tiene efectos secundarios
9.2. Cuáles de los siguientes pares de términos unifican? En el caso de que unifiquen,
indique cómo se instancian las variables.
a) pan = pan
b) ’Pan’ = pan
c) ’pan’ = pan
d) Pan = pan
e) pan = salchicha
f) comida(pan) = pan
g) comida(pan) = X
h) comida(X) = comida(pan)
i) comida(pan,X) = comida(Y,salchicha)
j) comida(pan,X,cerveza) = comida(Y,salchicha,X)
k) comida(pan,X,cerveza) = comida(Y,hamburguesa)
l) comida(X) = X
m) meal(comida(pan),bebida(cerveza)) = meal(X,Y)
n) meal(comida(pan),X) = meal(X,bebida(cerveza))
103
9.3. A partir de la siguiente base de datos:
elfo_domestico(dobby).
bruja(hermione).
bruja(’McGonagall’).
bruja(rita_skeeter).
puede_hacer_magia(X):- elfo_domestico(X).
puede_hacer_magia(X):- hechicero(X).
puede_hacer_magia(X):- bruja(X).
Cuáles de las siguientes consultas se satisfacen? Con qué instanciaciones de variables?
?- puede_hacer_magia(elfo_domestico).
?- hechicero(harry).
?- puede_hacer_magia(hechicero).
?- puede_hacer_magia(’McGonagall’).
?- puede_hacer_magia(Hermione).
Dibuje el árbol de búsqueda para la consulta puede_hacer_magia(Hermione).

9.4. La búsqueda en Prolog es exhaustiva, mientras que en otros lenguajes se ejecuta la
sentencia controlada por el primer patrón que hace pattern matching. Sin embargo,
existe una forma en prolog para cortar una búsqueda exhaustiva, usando el operador
cut, como se ve en el siguiente ejemplo:
max(X,Y,Y) :- X =< Y,!.

max(X,Y,X) :- X>Y.
Escriba un pseudocódigo en imperativo (usando if ... then ... else ...) o fun-
cional (usando guardas) con la misma semántica.
9.5. Defina en Prolog el problema de recomendar “amigos” en una red social, especificado
como sigue: para un usuario P con un conjunto de amigos CA = [A1 , A2 , ...An ],
los cuales a su vez tienen cada uno asociado un conjunto de amigos C1 , C2 ... Cn
le recomendaremos a P todos los miembros de la unión de todos los conjuntos de
amigos de sus propios amigos CCA = C1 ∪ C2 ... ∪ Cn que NO están en la lista de sus
propios amigos.
Pueden usar la siguiente base de conocimiento.
amigo(pedro,marı́a). amigo(pedro,juan).
amigo(marı́a,pedro). amigo(marı́a,clara).
amigo(marı́a,romina). amigo(juan,pedro).
amigo(juan,clara). amigo(clara,marı́a).
amigo(clara,juan). amigo(romina,marı́a).
104
9.6. Defina en Prolog un sistema de ayuda a una central de turnos. Este sistema dirá si
se le puede asignar un turno a un paciente con un determinado médico para un
determinado dı́a, siguiendo las siguientes premisas:
el paciente no tiene ningún turno asignado para el mismo dı́a a la misma hora.
el paciente no tiene ningún turno asignado con ningún especialista de la misma
especialidad para la que pide turno.
el médico para el que pide turno no tiene turno asignado con ningún otro paciente
para el mismo dı́a a la misma hora.
Se puede definir con una sola regla!

La base de conocimiento puede ser como sigue:
turno(celia,rivas,(6,30,8)).
turno(celia,zilvetti,(7,14,11)).
turno(tomás,rivas,(7,11,10)).
turno(tomás,pérez,(8,11,10)).
turno(tomás,schuster,(9,11,10)).
turno(lidia,zilvetti,(7,14,10)).
turno(lidia,schuster,(9,11,11)).
turno(esteban,rivas,(7,1,9)).
especialidad(rivas,oftalmologia).
especialidad(smith,oftalmologia).
especialidad(zilvetti,ginecologı́a).
especialidad(román,ginecologı́a).
especialidad(pérez,endocrinologı́a).
especialidad(schuster,clı́nico).
105
Capı́tulo 10
Programación concurrente
Mitchell 14.
10.1. Ejercicios
10.1. En el siguiente ejemplo se está usando la variable común lock como lock. Describa
una ejecución del código que lleve a un estado inconsistente, describiendo en orden
las asignaciones y evaluaciones que ocurren al ejecutar el código. Explique cómo se
podrı́a evitar este funcionamiento no deseado con implementaciones atómicas de wait
y signal.
lock := 0;
2 cobegin
begin
4 while lock =1 do end ;
lock :=1;
6 sign up ( fred ) ;
lock :=0;
8 end ;
begin
10 while lock =1 do end ; // loop que no hace nada hasta
que el lock sea 0
lock :=1; // setear el lock para entrar
a la seccion critica
12 sign up ( bill ) ; // seccion critica
lock := 0; // soltar el lock
14 end ;
end ;
10.2. En java existen dos formas de crear un nuevo thread explı́citamente: creando una
subclase de la clase Thread o bien implementando la interfaz Runnable. En ambos
106
casos el nuevo thread debe implementar el método run, que contendrá el código
ejecutado por el thread. Cuál de estas dos opciones crea un objeto más versátil y por
qué?
10.3. El siguiente es un programa concurrente en Erlang. Escriba su versión secuencial.

1 f1 (0) ->
0;
3 f1 (1) ->
1;
5 f1 ( N ) ->
Self = self () ,
7 spawn ( fun () ->
Self ! f0 (N -1)
9 end ) ,
spawn ( fun () ->
11 Self ! f0 (N -2)
end ) ,
13 receive
F1 ->
15 receive
F2 ->
17 F1 + F2
end
19 end .
}
21 }
10.4. Explique por qué el esquema productor - consumidor no tiene condiciones de carrera.
10.5. En lenguajes con evaluación perezosa la concurrencia sin condiciones de ca rrera

puede implementarse mediante estructuras de datos. Explique cómo, a partir del
siguiente ejemplo:
1 lista_dobles = map (\ x -> 2 * x ) lista_todos_los_naturales
10.6. Hay ocho combinaciones posibles en el pasaje de mensajes entre procesos concu-
rrentes, combinando sincronicidad / asincronicidad, ordenado / no ordenado y con
buffer / sin buffer. Explique cuáles tienen ventajas y cuáles no tienen sentido o tienen
desventajas.
10.7. Los actores se comunican mediante mensajes desordenados. Explique qué información
y métodos deberı́a añadir a un modelo basado en actores para poder procesar los
mensajes recibidos en el orden en el que fueron enviados.
107
10.8. Escriba en pseudocódigo dos versiones secuenciales (no concurrentes) del siguiente
programa, una en paradigma funcional y otra en paradigma imperativo. Argumente
las ventajas y desventajas de las tres versiones del programa usando los conceptos de
velocidad, overhead y determinismo.
1 class Ejemplo extends RecursiveTask < Integer > {
final int n ;
3 Ejemplo ( int n ) { this . n = n ; }
Integer compute () {
5 if ( n <= 1)
return n ;
7 Ejemplo f1 = new Ejemplo ( n - 1) ;
f1 . fork () ;
9 Ejemplo f2 = new Ejemplo ( n - 2) ;
return f2 . compute () + f1 . join () ;
11 }
}
10.9. En el código del ejercicio anterior, identifique las expresiones que expresan semántica
exclusiva de un programa concurrente y describa su semántica informalmente.
10.10. En las siguientes interfaces y clases de Java, subraye las partes de la descripción que
describen semántica concurrente.
A Queue that additionally supports
operations that wait for the queue to
become non-empty when retrieving an
BlockingQueue<E>
element, and wait for space to become
available in the queue when storing an
element.
A Future represents the result of an
Future<E>
asynchronous computation.
An unbounded blocking queue that uses
the same ordering rules as class
PriorityBlockingQueue<E>
PriorityQueue and supplies blocking
retrieval operations.
A synchronization aid that allows a set
CyclicBarrier of threads to all wait for each other to
reach a common barrier point.
A blocking queue in which each insert
operation must wait for a corresponding
SynchronousQueue<E>
remove operation by another thread, and
vice versa.
10.11. En el siguiente código Java, subraye las partes del programa que hacen referencia a
semántica concurrente.
108
protected class ReadLock {
2 WriteLock lock ;
4 public ReadLock ( WriteLock lock ) {

super () ;
6 this . lock = lock ;
}
8
public void lock () throws InterruptedException { // If

write () then wait
10 synchronized ( lock ) {
System . out . println ( " Waiting to read :
" + Thread . currentThread () ) ;
12 Thread callingThread = Thread . currentThread () ;
while ( lock . isLocked && lock . lockedBy !=
callingThread ) {
14 lock . wait () ;
}
16 lock . readers ++; // Increment writelocks readers
System . out . println ( " Reading :
" + Thread . currentThread () ) ;
18 }
}
20
public void unlock () {

22 synchronized ( lock ) {
lock . readers - -; // Subtract from writelocks
readers
24 lock . notify () ;
}
26 }
28 }
10.12. En Java se puede escribir sincronización de métodos, pero esta funcionalidad es una
forma más cómoda de escribir (el llamado azúcar sintáctico), porque en realidad el al-
cance de una sincronización es siempre el objeto entero. Sabiendo esto, en el siguiente
código, ¿pueden dos threads acceder los métodos addA() y addB() simultáneamente?
¿Por qué? ¿Podemos decir que las variables a y b son regiones crı́ticas o canales de
comunicación entre dos threads?
class X {
2
109
private int a ;
4 private int b ;
6 public synchronized void addA () {

a ++;
8 }
10 public synchronized void addB () {

b ++;
12 }
14 }
10.13. En Quake-C se usa un modelo de pasaje de mensajes. Acá mostramos algunos ti-
pos de mensaje, su especificación y algunos ejemplos. Para los mensajes de tipo
MSG BROADCAST, MSG ONE, MSG ALL, diga cuáles de las tres caracterı́sticas
del pasaje de mensajes del modelo de actores tiene sentido usar: sincronización, buf-
fer, orden.
MSG_BROADCAST = 0; unreliable message , sent to all
2 MSG_ONE = 1; reliable message , sent to msg_entity
MSG_ALL = 2; reliable message , sent to all
4 MSG_INIT = 3; write to the init string
// Use unreliable ( but fast ) messages , when it ’s of no
importance that a client misses the message .
6 // examples : sound , explosions , monster deaths , taunts ... .
// Use reliable messages when it ’s very important that
every client sees the message , or a game incoherency
might happen .
8 // examples : shots , player deaths , door moves , game ends
... and CD track changes !.
10 Message : Killed Monster
12 WriteByte ( MSG_ALL , SVC_KILLEDMONSTER ) ;

Increase by one the count of killed monsters , as
available to the client . Can be displayed with
showscores .
14
Message : Set View Angles

16
msg_entity = player
18 WriteByte ( MSG_ONE , SVC_SETVIEWANGLES ) ;
110
WriteAngle ( MSG_ONE , camera . angles_x ) ;
20 WriteAngle ( MSG_ONE , camera . angles_y ) ;
WriteAngle ( MSG_ONE , camera . angles_z ) ;
22
Message : Final Message

24
WriteByte ( MSG_ALL , SVC_FINALE ) ;

26 WriteString ( MSG_ALL , " any text you like \ n " ) ;
111
Capı́tulo 11
Paradigma de scripting
capı́tulo 13. Michael Scott. Programming Language Pragmatics (2nd ed.). Morgan
Kaufmann. 2016.
Los lenguajes de programación tradicionales están diseñados principalmente para crear
aplicaciones autónomas: programas que aceptan algún tipo de entrada, la manipulan de al-
guna manera que se entiende bien, y generan la salida esperada. Pero la mayorı́a de los usos
reales de las computadoras requieren la coordinación de múltiples programas. Un sistema
de nóminas institucional, por ejemplo, debe procesar los datos de informes de los lectores
de tarjetas, formularios en papel escaneados, y la entrada manual (teclado); ejecutar miles
de consultas de bases de datos; cumplir cientos de normas jurı́dicas e institucionales; crear
un extenso rastro de papel”para el mantenimiento de registros, auditorı́a, y los propósitos
de preparación de impuestos; cheques de impresión; y comunicarse con los servidores de
todo el mundo para el depósito directo on-line, la retención de impuestos, la acumulación
de jubilación, seguro médico, y ası́ sucesivamente. Estas tareas suelen involucrar docenas
o cientos de programas ejecutables por separado. La coordinación entre estos programas
requiere pruebas y condicionales, bucles, variables y tipos, subrutinas y abstracciones: el
mismo tipo de herramientas lógicas que un lenguaje convencional proporciona dentro de
una aplicación.
En principio, cualquier lenguaje puede ser utilizado como un lenguaje de scripting,
siempre que cuente con las librerı́as o bindings para un entorno especı́fico. Sin embargo,
los lenguajes especı́ficamente de scripting están pensados para ser muy rápidos de apren-
der y escribir, ya sea como archivos ejecutables o de forma interactiva en un bucle de
lectura–evaluación–impresión (REPL). En general, esto implica una sintaxis y semánti-
ca relativamente simples; tı́picamente un ”script”se ejecuta de principio a fin, como un
”guión”, sin un punto de entrada explı́cito.
Por ejemplo, no es común utilizar Java como lenguaje de scripting debido a su sintaxis
verbosa y reglas sobre las clases que se encuentran en diferentes archivos, y directamente
es imposible ejecutar Java de forma interactiva, ya que los archivos fuente sólo pueden
tener las definiciones que deben ser invocados externamente por una aplicación lanzador
de aplicaciones. Por el contrario, en Python se pueden definir algunas funciones en un
solo archivo, evitar por completo las funciones y escribir en un estilo de programación
112
imperativo, o incluso utilizarlo de forma interactiva.
Un lenguaje de scripting suele ser interpretado a partir del código fuente o el bytecode.
Los lenguajes de scripting pueden estar diseñados para ser usados por usuarios finales
de una aplicación o sólo para uso interno de los desarrolladores. Los lenguajes de scripting
suelen utilizar abstracción para hacer transparente a los usuarios los detalles de los tipos
internos variables, almacenamiento de datos y la gestión de memoria.
Los scripts son a menudo creados o modificados por la persona que los ejecuta, pero a
menudo también se distribuyen, por ejemplo, buena parte de los juegos están escritos en
un lenguaje de scripting.
11.1. Tipos de lenguajes de scripting

Podemos distinguir dos grandes familias de lenguajes de scripting: los de propósito
general y los especı́ficos de dominio o de extensión.
Los lenguajes de scripting de propósito general, como Perl y Python, se suelen llamar
lenguajes pegamento (glue languages), porque fueron diseñados originalmente para ”pe-
gar”las salidas y entradas de otros programas, para construir sistemas más grandes. Con
el crecimiento de la World Wide Web, los lenguajes de scripting han adquirido una nueva
importancia en la generación de contenido dinámico.
Los lenguajes especı́ficos de dominio están pensados para extender las capacidades de
una aplicación o entorno, ya que permiten al usuario personalizar o extender las funciona-
lidades mediante la automatización de secuencias de comandos.
Lenguajes como TCL o Lua se han diseñado especı́ficamente como lenguajes de scripting
de propósito general, para ser incorporados en cualquier aplicación. Otros lenguajes como
Visual Basic para Aplicaciones (VBA) está pensado para facilitar la integración en un
sistema operativo especı́fico.
Implementar las secuencias de comandos en estos lenguajes independientes de dominio
en lugar de desarrollar un nuevo lenguaje para cada aplicación hace que los desarrolladores
no tengan que aprender nuevos lenguajes o traducir de un lenguaje a otro.
Si comparamos el paradigma de scripting con el resto, podemos pensarlo como compa-
rar secuencias de comandos con programación del sistema. Los scripts son código bisagra,
su función es conectar componentes de software. Los lenguajes “pegamento” (glue langua-
ges) son los que se especializan para conectar componentes de software. Algunos ejemplos
clásicos son los pipes y las secuencias de comandos del shell. También en el desarrollo web
se requiere esa funcionalidad, por ejemplo, para conectar un servidor web con diferentes
servicios web, como una base de datos.
Perl fue desarrollado para funcionar principalmente como lenguaje pegamento. Sin em-
bargo, pronto empezaron a expresarse partes más grandes de la lógica de los programas en
los scripts en perl, por lo que dejaron de cumplir su función de pegamento para pasar a
cumplir función de componentes de software en sı́, programas.
Los lenguajes pegamento son especialmente útiles para escribir y mantener:
comandos personalizados para una consola de comandos;
113
programas más pequeños que los que están mejor implementados en un lenguaje
compilado;
programas de çontenedor”para archivos ejecutables, como manipular archivos y hacer

otras cosas con el sistema operativo antes o después de ejecutar una aplicación como
un procesador de textos, hoja de cálculo, base de datos, ensamblador, compilador,
etc .;
secuencias de comandos que pueden cambiar;
prototipos rápidos de una solución.
Los lenguajes de macros que manipulan componentes de un sistema o aplicación es-

pecı́ficos pueden funcionar también como lenguajes de pegamento. Otras herramientas
como AWK también pueden ser considerados lenguajes pegamento, al igual que cualquier
lenguaje implementado por un motor de Windows Script Host (VBScript, JScript y VBA
por defecto en Windows y motores de otros fabricantes, incluyendo implementaciones de
Rexx, Perl, Tcl, Python, XSLT, Ruby, Delphi, etc.). La mayorı́a de las aplicaciones pueden
acceder y utilizar los componentes del sistema operativo a través de los modelos de objetos
o de sus propias funciones.
Otros dispositivos, como las calculadoras programables, también pueden tener lenguajes
pegamento. Por ejemplo, la Texas Instruments TI-92, se puede programar de fábrica con
un lenguaje de secuencias de comandos. En la serie TI-Nspire de calculadoras se incluyeron,
además de las secuencias de comandos, el lenguaje Lua. Los lenguajes de alto nivel de la
mayorı́a de las calculadoras gráficas (frecuentemente variantes de Basic, a veces derivados
de Lisp, y, menos frecuentemente, derivados C), en muchos casos pueden pegar funciones,
tales como gráficos de la calculadora, listas, matrices, etc. Para algunas de las máquinas de
TI y HP se usan conversores de C y Perl, REXX AWK, ası́ como secuencias de comandos
shell a Perl, VBScript hacia y desde Perl. De esta forma se puede escribir un programa en
un lenguaje de pegamento para la eventual aplicación (como un programa compilado) en
la calculadora.
Una clase importante de lenguajes de scripting ha crecido a partir de la automatización
del control de tareas, principalmente la puesta en marcha y control del comportamiento de
los programas del sistema. (En este sentido, se podrı́a pensar que las shells son descendientes
del JCL de IBM, o Job Control Language, que se utilizaba para este propósito.) Muchos
de los intérpretes de lenguajes doblan como intérpretes de lı́nea de comandos, como el shell
de Unix o el MS-DOS COMMAND.COM.
Con el advenimiento de interfaces gráficas de usuario, surgió un tipo especializado de
lenguaje de scripting. Estos lenguajes interactúan con los gráficos de ventanas, menús,
botones, etc., al mismo nivel de abstracción que resulta natural para un usuario humano.
Esto se hace facilitando que se puedan reproducir las acciones de un usuario, ya que estos
lenguajes se usan normalmente para automatizar las acciones del usuario. A estos lenguajes
también se les llama ”macros”si el control es a través de la simulación de las acciones de
presionar teclas o clics del ratón, ası́ como tocar o pulsar en una pantalla táctil activada.
114
Estos lenguajes podrı́an, en principio, utilizarse para controlar cualquier aplicación de
interfaz gráfica de usuario; pero, en la práctica, su uso es limitado porque están muy ligados
a una aplicación especı́fica o un sistema operativo particular. Hay algunas excepciones a
esta limitación. Algunos lenguajes de scripting de GUI se basan en el reconocimiento de
objetos gráficos a través de sus pı́xeles de la pantalla de visualización. Estos lenguajes de
scripting de GUI no dependen del apoyo del sistema operativo o aplicación.
Muchos programas de aplicación grandes incluyen un pequeño lenguaje de programa-
ción adaptado a las necesidades del usuario de la aplicación. Del mismo modo, muchos
juegos de computadora utilizan un lenguaje de programación especı́fico para expresar las
acciones de personajes no jugadores y del entorno del juego. Los lenguajes de este tipo están
diseñados para una sola aplicación; y, si bien pueden parecerse superficialmente un lenguaje
especı́fico de propósito general (por ejemplo QuakeC se parece a C), tienen caracterı́sticas
especı́ficas que los distinguen, principalmente abstracciones que acortan la expresión de
los conceptos propios del juego. El Emacs Lisp, aunque un dialecto totalmente formada
y capaz de Lisp, contiene muchas caracterı́sticas especiales que hacen que sea más útil
para ampliar las funciones de edición de Emacs. Un lenguaje de programación especı́fico
de la aplicación puede ser visto como un lenguaje de programación especı́fico del dominio
especializado para una sola aplicación.
Varios lenguajes han sido diseñados para reemplazar lenguajes de scripting especı́ficos
una aplicación, como estándares para tareas de scripting. De esta forma, los programadores
de aplicaciones (que trabajan en C o en otro lenguaje de programación no de scripting)
incluye ”ganchosçon los que el lenguaje de scripting puede controlar la aplicación. Estos
lenguajes pueden ser técnicamente equivalentes a un lenguaje de extensión especı́fico de
la aplicación, pero cuando una aplicación incorpora un lenguaje çomún”, el usuario puede
programar con el mismo lenguaje para diferentes aplicaciones. Una alternativa más genéri-
ca es simplemente proporcionar una librerı́a que un lenguaje de propósito general puede
utilizar para controlar la aplicación, sin modificar el lenguaje para el dominio especı́fico.
JavaScript comenzó como un lenguaje de secuencias de comandos en el interior de los
navegadores web, y ésa sigue siendo su función principal. Sin embargo, la estandarización
del lenguaje como ECMAScript lo ha popularizado como lenguaje integrable de propósi-
to general. En particular, la aplicación SpiderMonkey Mozilla está incrustada en varios
ambientes.
TCL fue creado como un lenguaje de extensión, pero ahora se usa principalmente como
un lenguaje de propósito general, parecido a Python, Perl o Ruby. Por otro lado, Rexx
fue creado originalmente como un lenguaje de control de trabajos, pero se usa como un
lenguaje de extensión, ası́ como un lenguaje de propósito general. Perl es un lenguaje de
propósito general, pero tenı́a en 1990 el dialecto Oraperl que consiste en un binario de Perl
4 con Oracle Call Interface compilado. Sin embargo, desde entonces se ha sustituido por
una biblioteca (Perl Module), DBD :: Oracle.
Otras aplicaciones complejas y orientadas a tareas pueden incorporar y un lenguaje de
programación para permitir a sus usuarios un mayor control y más funcionalidades. Por
ejemplo, las herramientas de autorı́a Autodesk Maya 3D incrustan el lenguaje de script
MEL, o Blender, que utiliza Python para desempeñar este papel.
115
11.2. Ejercicios
11.1. Si quiero un control fuerte de la seguridad de una aplicación, debo renunciar a usar
un lenguaje de scripting como por ejemplo JavaScript? Dé por lo menos un argumen-
to que muestre las vulnerabilidades de un lenguaje de scripting y por lo menos dos
argumentos o estrategias con las que podrı́a tratar de reducir los riesgos de un len-
guaje de scripting. Argumente qué ventajas aportan las caracterı́sticas del lenguaje
que implican vulnerabilidades.
11.2. En el siguiente código en Quake-C, identifique por lo menos 3 caracterı́sticas que

lo identifican como un lenguaje de scripting, y argumente por qué, si es posible,
comparándolo con C, lenguaje en el que está basado Quake-C.
// Example of an alternate fiend jumping AI
2
// Here ’s a jumping algorithm I came up with for the

fiends in Quake .
4 // It ’s a pretty good monster cheat that has them jumping
for you and
// making it half the time no matter where you are . Even
from underwater .
6
// You can also change

8 // setsize ( self , VEC_HULL2_MIN , VEC_HULL2_MAX ) ;
// to
10 // setsize ( self , VEC_HULL_MIN , VEC_HULL_MAX ) ;
// in void () monster_demon1
12
// Quake only has three clipping hulls for moving

entities , point - size ,
14 // man - size , and shambler - size . Making the hull
man - sized gives the
// fiend a BIG edge in tracking you down , ( it ’s a
definite hack :)
16
DEMON . QC
18 ( Change demon1_run6 and demon1_jump4 )
20 void () demon1_jump1 ;
void () demon1_run6 =[ $run6 , demon1_run1 ]
22 {
ai_run (36) ;
24 // if underwater , give a chance to switch to jump AI
anyway
116
if ( self . waterlevel == 1)
26 {
if ( random () > 0.8 )
28 self . think = demon1_jump1 ;
}
30
};
32
void () demon1_jump4 =[ $leap4 , demon1_jump5 ]

34 {
local vector dir ;
36 local float dist ;
38 ai_face () ;
40 self . touch = Demon_JumpTouch ;

makevectors ( self . angles ) ;
42 self . origin_z = self . origin_z + 1;
if ( self . enemy . origin_z > self . origin_z + 40)
44 {
if ( infront ( self . enemy ) || self . waterlevel == 1 )
46 {
dir = normalize ( self . enemy . origin - self . origin ) ;
48 dist = vlen ( self . enemy . origin - self . origin ) ;
self . velocity = dir * dist ;
50 }
else
52 self . velocity = v_forward * 150;
54 dist = self . enemy . origin_z - self . origin_z ;
56 // a vertical velocity to jump just above player ’s

head
// for any given distance between z origins .
58 // ( hack numbers that work for Quake )
dist = dist - 237;
60 self . velocity_z = 714 + dist ;
}
62 else
{
64 // slow forward to fall off ledge if player down
// else normal horizontal velocity
66 if ( self . enemy . origin_z < self . origin_z - 40)
117
self . velocity = v_forward * 150;
68 else
self . velocity = v_forward * 600;
70
// check for wall in front

72 traceline ( self . origin - ’0 0 16 ’ ,
( self . origin - ’0 0 16 ’) +
v_forward * 150 , TRUE , self ) ;
74
// attempt to jump wall or normal vel .

76 if ( trace_fraction < 1)
{
78 self . velocity = v_forward * 110;
self . velocity_z = 250 * ( random () + 1) ;
80 }
else
82 self . velocity_z = 250;
}
84
if ( self . flags & FL_ONGROUND )

86 self . flags = self . flags - FL_ONGROUND ;
};
88
// ( Add random statement to CheckDemonJump () to avoid

hang - ups and
90 // enable going for it no matter what )
92 float () CheckDemonJump =
{
94 local vector dist ;
local float d ;
96
if ( random () < 0.4)

98 return TRUE ;
11.3. Ordene los siguientes fragmentos de código de más de scripting a menos de scripting,
y explique cuáles son los principios que han contribuı́do a su ordenamiento.
class HELLO_WORLD
2
creation
4 make
feature
118
6 make is
local
8 io : BASIC_IO
do
10 !! io
io . put_string ( " %N Hello World !!!! " )
12 end -- make
14 end -- class HELLO_WORLD
16 program hello_prog
18 root
HELLO_WORLD : " make "
20
22 cluster
24 " ./ "
26 end
28 include " library / lib . pdl "
30
end -- hello_prog
1 while 1 ,
disp ( ’ hello world ’)
3 end
1 \ font \ HW = cmr10 scaled 3000

\ leftline {\ HW Hello World }
3 \ bye
1 PROC write . string ( CHAN output , VALUE string []) =

SEQ character . number = [1 FOR string [ BYTE 0]]
3 output ! string [ BYTE character . number ]
5 write . string ( terminal . screen , " Hello World ! " )
119
Capı́tulo 12
Seguridad basada en lenguajes de

programación
Mitchell 13.5
12.1. Ejercicios
12.1. En Java, hay varios mecanismos de seguridad a través del lenguaje, y muchos de
ellos interactúan. Los class loaders son parte del Java Runtime Environment (JRE)
y sirven para cargar dinámicamente, por demanda, clases en tiempo de ejecución.
No se puede cargar ninguna clase sin un class loader. Sabiendo el rol del Security
Manager en Java, explique cómo imagina que debe ser la relación entre el Security
Manager y un class loader para preservar seguridad.
12.2. Describa la intención del Proof-Carrying-Code y cómo provee seguridad.
12.3. En lenguajes inseguros, se pueden implementar polı́ticas de seguridad llamadas “eje-

cución defensiva”. Describa algunas de estas polı́ticas, por ejemplo, para pervenirse
de vulnerabilidades por debilidad en el sistema de tipos de un lenguaje de scripting.
12.4. La no interferencia es uno de los principios básicos de seguridad. Explique cómo los
niveles de visibilidad de un lenguaje orientado a objetos pueden contribuir a la no
interferencia. Ahora, explique cómo la visibilidad ortogonal (por ejemplo, el package
en Java) pueden contribuir a la implementación de polı́ticas de acceso a información
más complejas que las basadas únicamente en herencia.
12.5. Explique las vulnerabilidades asociadas a un sistema de tipos como el de un lenguaje

de scripting, que provee robustez y facilita casteos.
120
Apéndice A
Exámenes de ediciones anteriores
121
Paradigmas de la Programación – Primer Parcial
23 de Abril de 2015
Apellido y Nombre:
1. [10 pt.] Seleccione todas las respuestas correctas entre las diferentes opciones que se dan para
completar cada oración:
a) Una gramática independiente de contexto (context-free grammar)...

1) tiene predicados.
2) es inambigua.
3) tiene reglas de reescritura.
4) describe la sintaxis de un lenguaje.
5) es más expresiva que una gramática dependiente del contexto.
6) es tan expresiva como una máquina de Turing.
b) Las variables están compuestas de... (elija la opción más precisa)
1) un nombre y un valor.
2) un l-valor y un r-valor.
3) un identificador y un valor.
4) un identificador que está ligado a un valor que está ligado a una dirección en memoria.
5) un identificador que está ligado a una dirección en memoria que contiene un valor.
6) una dirección de memoria, un valor y un identificador en el texto del programa.
c) La clausura de una función es necesaria para...
1) definir funciones en un alcance global
2) mantener la referencia a las variables locales de la función si tenemos alcance dinámico
3) mantener la referencia a las variables locales de la función si tenemos alcance estático
4) mantener la referencia a las variables libres de la función si tenemos alcance dinámico
5) mantener la referencia a las variables libres de la función si tenemos alcance estático
d) La diferencia entre polimorfismo y sobrecarga es...
1) que sobrecarga se aplica sólo a algunos tipos, mientras que polimorfismo es más general.
2) que la sobrecarga se comprueba en tiempo de ejecución y el polimorfismo en tiempo de
compilación.
3) que en la sobrecarga tenemos diferentes implementaciones para un mismo sı́mbolo y en
el polimorfismo tenemos una sola implementación con tipos generales.
4) que la sobrecarga usa tipos concretos mientras que el polimorfismo usa variables de
tipo.
5) que la sobrecarga la analiza el compilador y el polimorfismo no.
e) Las excepciones se pueden usar para optimizar código...
1) porque tienen alcance dinámico.
2) porque son saltos explı́citos entre partes del programa.
3) porque son imperativas.
4) porque son funcionales.
1
2. [20 pt.] Muestre con un ejemplo que la siguiente gramática es ambigua, y modifı́quela para que
se convierta en una gramática inambigua.
<a> ::= <a> | 

 ::= <hoja> | <c> | <a>
<c> ::= bin <d> | bin <d> ban 
<hoja> ::= ’a’ | ’b’ | ’c’ | ’d’ | ’e’ | ’f’ | ’g’
3. [30 pt.] Diagrame una secuencia de pilas de ejecución que representen los los diferentes momen-
tos de la ejecución del siguiente programa, mostrando cómo se apilan y desapilan los diferentes
activation records a medida que se va ejecutando el programa. Asuma que el lenguaje de pro-
gramación tiene alcance estático.
Nota de estilo: El nivel de granularidad de la descripción puede limitarse a bloques del
texto del programa, no es necesario diagramar como estados distintos de la ejecución las
instrucciones que no apilen a otro bloque. Si lo desea, puede usar ı́ndices en el mismo texto
del programa para una representación más compacta de la pila.
var x=1;
function g(z) {return x+z;}
function f(y) {
var x = y*y;
return g(y);
}
f(2)
4. [20 pt.] En el siguiente programa tipo Algol,
begin
integer n;
begin
k := k+3;
print(n);
n := n+(2*k);
end;
n := 0;
p(n);
print(n);
end;
a) por valor?
c) por referencia?
5. [20 pt.] Calcule el tipo de datos de la siguiente función en ML. Provea el árbol sintáctico de
la función y aplique de forma explı́cita el algoritmo de inferencia de tipos, ya sea sobre el árbol
mismo o como sistema de ecuaciones.
fun a(x,y) = x+2*y;
2
Paradigmas de la Programación – Recuperatorio del Primer Parcial
17 de Junio de 2015
Apellido y Nombre:
a) ¿Se puede expresar con una gramática libre de contexto la asignación múltiple de variables?
1) No.
2) Sı́, si se trata de de asignación en secuencia, y no en espejo.
3) Sı́, si se trata de un número finito de variables.
4) Todas las anteriores.
5) Ninguna de las anteriores.
b) El siguiente código es código espagueti porque...
10 IF (X .GT. 1) GO TO 30
20 X = -X
IF (X .LT. 1) GO TO 60
30 IF (X*Y .LT. 1) GO TO 40
X = X-Y-Y
40 X = X+Y
60 CONTINUE
X = A
Y = B-A
GO TO 20
1) tiene bloques.
2) las lı́neas están numeradas.
3) no podemos armar un árbol sintáctico del programa.
4) usa expresiones GOTO.
c) Todo activation record necesariamente tiene...
1) control link
2) access link
3) variables locales
4) todas las anteriores
5) ninguna de las anteriores
d) Los tipos son...
1) reglas sobre cómo usar las variables.
2) analizados por el compilador posteriormente al análisis sintáctico.
3) conjuntos de valores.
e) Se usa alcance dinámico en las excepciones...
1) para no colisionar con el alcance de las variables.
2) porque se busca encontrar un patrón recorriendo la pila de ejecución.
3) porque el programador tiene más claro qué quiere que quien programó las librerı́as.
1
2. [20 pt.] Dada la siguiente gramática:
<s> ::= skip

<s> ::= <x> ’=’ <v>
<s> ::= <s1> <s2>
<s> ::= local <x> in <s> end
<s> ::= if <x> then <s1> else <s2> end
Añada las reglas de reescritura necesarias para que incluya las siguientes expresiones como parte
del lenguaje que describe la gramática:
if ( B ) { skip } elsif ( A ) { skip }

B := 5
3. [20 pt.] Diagrame una secuencia de pilas de ejecución que representen los diferentes momentos de
la ejecución del siguiente programa, mostrando cómo se apilan y desapilan los diferentes activa-
tion records a medida que se va ejecutando el programa. Asuma que el lenguaje de programación
tiene alcance dinámico.
var x=1;
function f1(z) {
f2(z - x);
}
function f2(z) {
if ( z <= 0 ) { return z; }
else { f1(z) }
}
f1(1)
4. [20 pt.] En el siguiente programa,
function fun(int a, int b, int c)

begin
a := b + c;
b := c + 1;
print a, b, c;
end
function main
begin
int i := 5;
int j := 10;
ink k := 15;
fun(i, j, j + k);
print i, j, k;
end
Qué secuencias de valores se imprimen si el programa tiene pasaje de parámetros...

a) por valor?
b) por referencia?
c) por valor-resultado?
la función y aplique de forma explı́cita el algoritmo de inferencia de tipos como sistema de
ecuaciones.
fun d(f,x) = f(x*2) andalso true
2
Paradigmas de la Programación – Segundo Parcial
11 de Junio de 2015
Apellido y Nombre:
Multiple Choice [10 pt.] Seleccione todas las respuestas correctas entre las diferentes opciones que
se dan para completar cada oración:
1. La diferencia entre interfaces de Java y clases abstractas de C++ es que...

a) las clases abstractas de C++ se pueden usar para expresar herencia múltiple en sus
descendientes, mientras que las interfaces de Java no.
b) las interfaces de Java no pueden heredar de ninguna clase, mientras que las clases
abstractas de C++ sı́.
c) las interfaces de Java se pueden usar para expresar herencia múltiple en sus descen-
dientes, mientras que las clases abstractas de C++ no.
d) las clases abstractas de C++ no pueden ser instanciadas, mientras que las interfaces
de Java sı́.
2. Tenemos un name clash cuando...
a) una clase hereda dos miembros con el mismo nombre de dos de sus madres.
b) las signaturas de dos clases cualquiera tienen un miembro en común.
3. Señale cuáles de las siguientes expresiones son true en Prolog, es decir, en qué casos se
encuentra una unificación exitosa para la expresión:
a) ’Pan’ = pan
b) Pan = pan
c) comida(pan) = pan
d) comida(pan,X) = comida(Y,salchicha)
e) comida(pan,X,cerveza) = comida(Y,hamburguesa)
f) comida(X) = X
g) meal(comida(pan),bebida(cerveza)) = meal(X,Y)
h) meal(comida(pan),X) = meal(X,bebida(cerveza))
Programación Lógica [20 pt.] La búsqueda en Prolog es exhaustiva, mientras que en otros len-
guajes se ejecuta la sentencia controlada por el primer patrón que hace pattern matching. Sin
embargo, existe una forma en prolog para cortar una búsqueda exhaustiva, usando el operador
cut, que termina la búsqueda cuando se encuentra el primer patrón que hace pattern matching.
El siguiente fragmento de Prolog es un ejemplo del uso de cut. Escriba un pseudocódigo en
imperativo (usando if ... then ... else ...) o funcional (usando guardas) con la misma
semántica.
apostar(X) :- tenerdinero(X),!.
apostar(X) :- tomarprestado(X).
1
Herencia múltiple [20 pt.] Cuando tenemos herencia múltiple hay que resolver la herencia de
información conflictiva de las diferentes clases madre. Detecte en el siguiente código información
conflictiva heredada de las diferentes clases madre y especifique en lenguaje natural por lo menos
dos estrategias posibles para resolverla (por ejemplo, la estrategia de Ruby con mixins y la
estrategia de C++, pero también podrı́a especificar una heurı́stica de su propia autorı́a para
resolver el problema).
class DispositivoUSB
{
private :
long ID ;
public :
D i s p o s i t i v o U S B ( long lI D )
: ID ( lID )
{
}
long ObtenerID ( ) { return ID ; }

};
class DispositivoRed
{
private :
long ID ;
public :
D i s p o s i t i v o R e d ( long lI D )
: ID ( lID )
{
}
long ObtenerID ( ) { return ID ; }

};
c l a s s A d a p t a d o r W i r e l e s s : public DispositivoUSB , public D i s p o s i t i v o R e d

{
public :
A d a p t a d o r W i r e l e s s ( long lUSBID , long lNetworkID )
: D i s p o s i t i v o U S B ( lUSBID ) , D i s p o s i t i v o R e d ( lNetworkID )
{
}
};
int main ( )
{
A d a p t a d o r W i r e l e s s c54G ( 5 4 4 2 , 1 8 1 7 4 2 ) ;
c o u t << c54G . ObtenerID ( ) ;
return 0 ;
}
2
Acoplamiento [20 pt.] El grado de interdependencia de dos componentes de software se puede ex-
presar en términos de acoplamiento. En las siguientes versiones del mismo programa, argumente
qué versión es más acoplada que la otra y por qué.
class RepositorioClientes {
private r e a d o n l y BasededatosID b a s e d e d a t o s ;
public R e p o s i t o r i o C l i e n t e s ( BasededatosID b a s e d e d a t o s )
{ this . basededatos = basededatos ; }
public void A n i a d i r ( s t r i n g NombreCliente )
{ b a s e d e d a t o s . A n i a d i r F i l a ( ” C l i e n t e ” , NombreCliente ) ; }
}
i n t e r f a c e BasededatosID {
void A n i a d i r F i l a ( s t r i n g Tabla , s t r i n g Valor ) ;

}
c l a s s B a s e d e d a t o s : BasededatosID {
public void A n i a d i r F i l a ( s t r i n g Tabla , s t r i n g Valor ) {}

}
class RepositorioClientes {
private r e a d o n l y B a s e d e d a t o s b a s e d e d a t o s ;
public R e p o s i t o r i o C l i e n t e s ( B a s e d e d a t o s b a s e d e d a t o s )
{ this . basededatos = basededatos ; }
public void A n i a d i r ( s t r i n g NombreCliente )
{ b a s e d e d a t o s . A n i a d i r F i l a ( ” C l i e n t e ” , NombreCliente ) ; }
}
class Basededatos {
public void A n i a d i r F i l a ( s t r i n g Tabla , s t r i n g Valor ) {}

}
3
Concurrencia [20 pt.] Escriba en pseudocódigo dos versiones secuenciales (no concurrentes) del
siguiente programa, una en paradigma funcional y otra en paradigma imperativo. Argumente
las ventajas y desventajas de las tres versiones del programa usando los conceptos de velocidad,
overhead y determinismo.
c l a s s Ejemplo extends RecursiveTask {
f i n a l int n ;
Ejemplo ( int n ) { t h i s . n = n ; }
I n t e g e r compute ( ) {
i f ( n <= 1 )
return n ;
Ejemplo f 1 = new Ejemplo ( n − 1 ) ;
f1 . fork ( ) ;
return f 2 . compute ( ) + f 1 . j o i n ( ) ;
}
}
Visibilidad [10 pt.] En el siguiente código en Ruby, describa la visibilidad de la variable cuenta.
class Ser
@@cuenta = 0
def i n i t i a l i z e
@@cuenta += 1
p u t s ” creamos un s e r ”
end
def m u e s t r a c u e n t a
”Hay #{@@cuenta} s e r e s ”
end
end
c l a s s Humano < S e r
super
p u t s ” creamos un humano”
end
end
c l a s s Animal < S e r
super
p u t s ” creamos un animal ”
end
end
c l a s s Perro < Animal
super
p u t s ” creamos un p e r r o ”
end
end
Humano . new
d = Perro . new
puts d . muestra cuenta
4
Paradigmas de la Programación – Recuperatorio del Segundo Parcial
17 de Junio de 2015
Apellido y Nombre:
a) La diferencia entre extends e implements en Java consiste en que...

1) extends crea relaciones de herencia, mientras que implements crea rela ciones de
implementación.
2) extends se aplica para heredar de clases, mientras que implements se a plica para
heredar de interfaces.
3) extends sólo permite herencia simple, mientras que implements permite herencia
múltiple.
b) Muchos lenguajes proveen sintaxis amigable para referirse a algunas clases dentro de la
jerarquı́a de clases, que son:
1) las clases hermanas de la clase desde las que se las refiere.
2) la clase madre de la clase desde que se la refiere.
3) las clases ancestro de la clase desde la que se está trabajando.
4) la propia clase desde la que se está trabajando.
5) las clases descendientes de la clase desde la que se está trabajando.
c) Señale cuáles de las siguientes expresiones son true en Prolog, es decir, en qué casos se
encuentra una unificación exitosa para la expresión:
1) ’Libro’ = libro
2) Revista = libro
3) Juan = leer(Juan)
4) convertir(booleano) = booleano
5) leer(odisea,Juan) = leer(Iliada,maria)
6) leer(odisea(juan),Maria) = leer(Juan,iliada(maria))
7) leer(odisea,Juan,iliada) = leer(Iliada,maria)
8) leer(odisea(juan),iliada(maria)) = leer(X,Y)
2. [20 pt.] Los actores se comunican mediante mensajes desordenados. Explique qué información
y métodos deberı́a añadir a un modelo basado en actores para poder procesar los mensajes
recibidos en el orden en el que fueron enviados.
1
3. [30 pt.] Reescriba el siguiente código en Java en un lenguaje declarativo, por ejemplo Haskell o
pseudocódigo declarativo, de forma que su semántica denotacional sea idéntica.
c l a s s P01 {
<T> T f 1 ( L i s t <T> l i s t ) {
i f ( l i s t . isEmpty ( ) ) throw new NoHayElemento ( ” l i s t a v a c i a ” ) ;
L i s t <T> e l e m e n t s = l i s t . t a i l ( ) ;
L i s t <T> r e s u l t = l i s t ;
while ( e l e m e n t s . nonEmpty ( ) ) {
r e s u l t = elements ;
elements = elements . t a i l ( ) ;
}
return r e s u l t . head ( ) ;
}
4. [20 pt.] El siguiente ejemplo en C++ causa un error de compilación. Por qué? cómo puede
solucionarse?
class trabajador
{
public :
void h o r a d e l e v a n t a r s e ( )
{ .... ... .... }
};
class estudiante
{
{ .... ... .... }
};
c l a s s ayudante alumno : public t r a b a j a d o r , public e s t u d i a n t e
{
};
int main ( )
{
ayudante alumno o b j ;
obj . h o r a d e l e v a n t a r s e ( )
}
2
5. [20 pt.] En el siguiente código java, inserte en el main los mecanismos de manejo de excepciones
necesarios para capturar la excepción de forma adecuada.
public c l a s s R e p a r t i r C o m e n s a l e s
{
public s t a t i c void main ( S t r i n g [ ] a r g s )
{
Mesa mesa = new Mesa ( 1 ) ;
System . out . p r i n t l n ( ”vamos a l l e n a r l a mesa 1 . . . ” ) ;
mesa . a n i a d i r C o m e n s a l ( ”Ana” ) ;
mesa . a n i a d i r C o m e n s a l ( ” Juan ” ) ;
mesa . a n i a d i r C o m e n s a l ( ” Maria ” ) ;
mesa . a n i a d i r C o m e n s a l ( ” Pedro ” ) ;
mesa . a n i a d i r C o m e n s a l ( ” Juana ” ) ;
mesa . a n i a d i r C o m e n s a l ( ” Esteban ” ) ;
mesa . a n i a d i r C o m e n s a l ( ” L ola ” ) ;
}
}
public c l a s s Mesa
{
private int numeroDeComensales ;
private int numeroDeMesa ;
public Mesa ( int numeroDeMesa )
{
t h i s . numeroDeMesa = numeroDeMesa ;
}
public void a n i a d i r C o m e n s a l ( s t r i n g comensal ) throws ExcepcionMesaLlena
{
i f ( numeroDeComensales > 5 )
{
throw new ExcepcionMesaLlena ( numeroDeComensales )
}
else
{
numeroDeComensales += 1 ;
}
}
}
3
Paradigmas de la Programación – Examen Final
3 de Julio de 2015
Apellido y Nombre:
se convierta en una gramática totalmente inambigua, sin ninguna ambigüedad.
<a> ::= <c>
<a> ::= 
 ::= ’c’ ’d’ ’e’
 ::= ’c’ ’d’
 ::= ’c’
<c> ::= ’d’ ’e’
<c> ::= ’e’
2. [10 pt.] Diagrame una secuencia de pilas de ejecución que representen los los diferentes momen-
tos de la ejecución del siguiente programa, mostrando cómo se apilan y desapilan los diferentes
activation records a medida que se va ejecutando el programa. Asuma que el lenguaje de pro-
gramación tiene alcance estático.
Nota de estilo: El nivel de granularidad de la descripción puede limitarse a bloques del
texto del programa, no es necesario diagramar como estados distintos de la ejecución las
instrucciones que no apilen a otro bloque. Si lo desea, puede usar ı́ndices en el mismo texto
del programa para una representación más compacta de la pila.
var x=1;
var y=5;
function g(z) {return x+z;}
function f(y) {
var x = y*y;
return g(y);
}
var x=5;
f(2)
begin
integer n;
begin
k := k+2;
print(n);
n := n+(2*k);
end;
n := 4;
p(n);
print(n);
end;
1
a) por valor?
c) por referencia?
fun a(x,y) = (x > 2) orelse (y < 10);
5. [10 pt.] En el siguiente código en Ruby, explique cómo se aproxima a la expresividad propia de
un lenguaje con herencia múltiple, incluso si Ruby es un lenguaje que no tiene herencia múltiple
sino simple. Compare este mecanismo con el de otro lenguaje que no tiene herencia múltiple sino
simple pero que usa otro mecanismo para aproximarse a la expresividad de la herencia múltiple:
Java con sus interfaces.
module EmailReporter
def s e n d r e p o r t
# Send an e m a i l
end
end
module PDFReporter
def s e n d r e p o r t
# Write a PDF f i l e
end
end
c l a s s Person
end
c l a s s Employee < Person

i n c l u d e EmailReporter
i n c l u d e PDFReporter
end
class Vehicle
end
c l a s s Car < V e h i c l e
i n c l u d e PDFReporter
i n c l u d e EmailReporter
end
6. [10 pt.] Señale cuáles de las siguientes expresiones son true en Prolog, es decir, en qué casos se
encuentra una unificación exitosa para la expresión, y cómo se pueden instanciar los valores de
las variables en las unificaciones exitosas.
a) ’Verdadero’ = verdadero
b) Verdadero = verdadero
c) booleano(verdadero) = verdadero
d) booleano(verdadero,X) = booleano(Y,falso)
2
e) booleano(verdadero,X,falso) = booleano(Y,falso)
f) booleano(X) = X
g) bool(booleano(verdadero),booleano(falso)) = bool(X,Y)
h) bool(booleano(verdadero),X) = bool(X,booleano(falso))
7. [10 pt.] Dibuje la jerarquı́a de clases en que se basa el siguiente código y explique la función de
la palabra clave virtual en este caso.
class A {
public :
explicit
A( i n t z )
: m z( z )
{}
int Z() const {
return m z ;
}
v i r t u a l v o i d Save ( s t d : : ostream& ) c o n s t = 0 ;
private :
int m z ;
};
c l a s s BA : p u b l i c A {
public :
BA( i n t z , i n t y )
: A( z ) , m y ( y )
{}
i n t Y( ) c o n s t {
return m y ;
}
v o i d Save ( s t d : : ostream& ) c o n s t ;
private :
int m y;
};
c l a s s CA : p u b l i c A {
public :
CA ( i n t z , i n t x )
: A( z ) , m x ( x )
{}
i n t X( ) c o n s t {
return m x ;
}
v o i d Save ( s t d : : ostream& ) c o n s t ;
private :
int m x;
};
3
8. [10 pt.] Escriba en pseudocódigo dos versiones secuenciales (no concurrentes) del siguiente
programa, una en paradigma funcional y otra en paradigma imperativo. Argumente las ventajas
y desventajas de las tres versiones del programa usando los conceptos de velocidad, overhead y
determinismo.
f i n a l int n ;
i f ( n <= 1 )
return n ;
f1 . fork ( ) ;
}
}
9. [20 pt.] En las siguientes funciones en ML:

e x c e p t i o n Excpt o f i n t ;
fun t w i c e ( f , x ) = f ( f ( x ) ) h a n d l e Excpt ( x ) => x ;
fun pred ( x ) = i f x = 0 then r a i s e Excpt ( x ) e l s e x −1;
fun dumb( x ) = r a i s e Excpt ( x ) ;
fun smart ( x ) = 1 + pred ( x ) h a n d l e Excpt ( x ) => 1 ;
a) twice(pred,1)
b) twice(dumb,1)
c) twice(smart,1)
Explique qué excepción se levanta en cada caso y dónde se levanta. Ayúdese de los respectivos
diagramas de pilas de ejecución
4
Ejercicios para libres
1. [-5 pt.] El siguiente es un ejemplo de “spaghetti code”. Reescrı́balo en pseudocódigo de forma
que NO use saltos (GOTO), y en cambio use programación estructurada en bloques.
10 i = 0
20 i = i + 1
30 PRINT i ; ” s q u a r e d = ” ; i ∗ i
50 GOTO 20
60 PRINT ” Program Completed . ”
70 END
2. [-5 pt.] Si el resultado del siguiente programa es 19, qué tipo de alcance tiene el lenguaje de
programación en el que está escrito, estático o dinámico?
val x = 4;
fun f ( y ) = x∗y ;
fun g ( x ) = l e t
f (3) + x ;
g(7);
3. [-5 pt.] Identifique en el siguiente código en C++ un problema con la herencia del miembro
meow.
class Felino {
public :
v o i d meow ( ) = 0 ;
};
c l a s s Gato : p u b l i c F e l i n o {
public :
v o i d meow ( ) { s t d : : c o u t << ”miau\n ” ; }
};
c l a s s Tigre : public Felino {

public :
v o i d meow ( ) { s t d : : c o u t << ”ROARRRRRR\n ” ; }
};
c l a s s Ocelote : public Felino {

public :
v o i d meow ( ) { s t d : : c o u t << ” r o a r r r r r \n ” ; }
};
5
4. [-5 pt.] En el siguiente código en Ruby, describa la visibilidad de la variable cuenta.
class Ser
@@cuenta = 0
@@cuenta += 1
end
end
end
super
end
end
super
end
end
super
end
end
Humano . new
d = Perro . new
6
6 de Agosto de 2015
Apellido y Nombre:
1. [10 pt.] Calcule el tipo de datos de la siguiente función en ML. Provea el árbol sintáctico de la
función y aplique de forma explı́cita el algoritmo de inferencia de tipos.
begin
integer n;
procedure p(k: integer, i:integer);
begin
k := k+2;
i := k+i;
print(n,k);
n := n+(2*k);
end;
n := 4;
m := 4;
p(n,m);
print(n,m);
end;
Qué valores se imprimen si el lenguaje tiene pasaje de parámetros...
a) por valor?
c) por referencia?
a) pred(X,var) = pred(var,X)
b) bin(X,c(d,X)) = bin(2,c(d,Y))
c) pred(X,Y) = pred(P,P)
d) bin(X,c(d,X)) = bin(2,c(X,Y))
e) pred(foo,L) = pred(A1,A1)
f) pred(var) = var
g) bin(X,c(d,X)) = bin(X,c(d,Y))
1
4. [10 pt.] En el siguiente programa en C++ indique si hay name clashes. Si los hay, identifı́quelos y
mencione alguna polı́tica para solucionarlos. Si no los hay, introdúzcalos y añada los mecanismos
para solucionarlos (no es necesario que sea el mecanismo que efectivamente implementa C++,
puede ser otra polı́tica). ¿En qué contexto se dan los name clashes?
c l a s s Persona
{
private :
s t d : : s t r i n g m strNombre ;
int m nEdad ;
bool m bEsVaron ;
public :
Persona ( s t d : : s t r i n g strNombre , int nEdad , bool bEsVaron )
: m strNombre ( strNombre ) , m nEdad ( nEdad ) , m bEsVaron ( bEsVaron )
{
}
s t d : : s t r i n g GetNombre ( ) { return m strNombre ; }

int GetEdad ( ) { return m nEdad ; }
bool EsVaron ( ) { return m bEsVaron ; }
};
c l a s s Empleado
{
private :
s t d : : s t r i n g m strEmpleador ;
double m d S a l a r i o ;
public :
Empleado ( s t d : : s t r i n g strEmpleador , double d S a l a r i o )
: m strEmpleador ( strEmpleador ) , m d S a l a r i o ( d S a l a r i o )
{
}
s t d : : s t r i n g GetEmpleador ( ) { return m strEmpleador ; }

double G e t S a l a r i o ( ) { return m d S a l a r i o ; }
};
c l a s s P r o f e s o r : public Persona , public Empleado

{
private :
int m nDictaGrado ;
public :
P r o f e s o r ( s t d : : s t r i n g strNombre , int nEdad , bool bEsVaron ,
s t d : : s t r i n g strEmpleador , double d S a l a r i o , int nDictaGrado )
Empleado ( strEmpleador , d S a l a r i o ) ,
m nDictaGrado ( nDictaGrado )
{
}
};
2
5. [20 pt.] Explique por qué se dice que las excepciones tienen alcance dinámico. Use como ejemplo
el siguiente código, describiendo los valores que tiene la variable x en el momento de ser atrapada
(handle) y comparando esos valores con los valores que tendrı́a la variable en el bloque de código
donde se encuentra el handle si su alcance fuera estático.
fun t w i c e ( f , x ) = f ( f ( x ) ) handle Excpt ( x ) => x ;
fun pred ( x ) = i f x = 0 then r a i s e Excpt ( x ) ; 5 ; e l s e x −1;
fun dumb( x ) = r a i s e Excpt ( x ) ; 3 ;
fun smart ( x ) = 1 + pred ( x ) ; 4 handle Excpt ( x ) => 1 ;
6. [10 pt.] En java existen dos formas de crear un nuevo thread explı́citamente: creando una subclase
de la clase Thread o bien implementando la interfaz Runnable. En ambos casos el nuevo thread
debe implementar el método run, que contendrá el código ejecutado por el thread. Cuál de estas
dos opciones crea un objeto más versátil y por qué?
7. [10 pt.] Diga si la sentencia
( ( 5 ) )
pertenece al lenguaje descripto por la siguiente gramática:

<s e x p > : : = <atomic symbol> | <n a t u r a l > | ” ( ” <s e x p > ” . ” <s e x p > ” ) ”
<atomic symbol> : : = <l e t t e r > <atom part> | ” : ” <atom part>
<n a t u r a l > : : = {<number>}+
<atom part> : : = <empty> | <l e t t e r > <atom part> | <number> <atom part>
<l e t t e r > : : = ” a ” | ”b” | . . . | ”z”
<number> : : = ”1” | ”2” | . . . | ”9”
<empty> : : = ””
Si pertenece, muestre la secuencia de reglas que lo generan, si no pertenece, agregue las reglas
necesarias para que la gramática pueda incluir esa sentencia en su lenguaje.
8. [10 pt.] Explique si el siguiente código da un error de compilación y por qué sı́ o por qué no.
class trabajador
{
public :
{ .... ... .... }
};
class estudiante
{
{ .... ... .... }
};
c l a s s ayudante alumno : public t r a b a j a d o r , public e s t u d i a n t e
{
};
int main ( )
{
ayudante alumno o b j ;
}
3
9. [10 pt.] Indique si el siguiente programa en C++ se podrı́a escribir en Java con una semántica
equivalente. Si no se puede, indique por qué. Si se puede, indique con qué recursos del lenguaje
se puede.
c l a s s Persona
{
private :
int m nEdad ;
bool m bEsVaron ;
public :
{
}

};
c l a s s Empleado
{
private :
public :
{
}

};

{
private :
int m nDictaGrado ;
public :
{
}
};
4
10 i = 0
20 i = i + 1
50 GOTO 20
70 END
val x = 4;
fun f ( y ) = x∗y ;
fun g ( x ) = l e t
f (3) + x ;
g(7);
meow.
class Felino {
public :
v o i d meow ( ) = 0 ;
};
public :
};

public :
};

public :
};
5
class Ser
@@cuenta = 0
@@cuenta += 1
end
end
end
super
end
end
super
end
end
super
end
end
Humano . new
d = Perro . new
6
3 de Julio de 2015
Apellido y Nombre:
1. [20 pt.] Estos dos programas, en dos lenguajes distintos, tienen la misma semántica. ¿Cuáles son
las diferencias entre estos dos lenguajes? Refiérase a los elementos de los programas que ejem-
plifican las diferencias entre estos dos lenguajes. Cuando sea relevante, argumente las ventajas
y desventajas de la forma de expresión de cada lenguaje.
i n t e r f a c e I t e r a b l e <T>
d e f each (& b l o c k : T −>)
end
i n t e r f a c e Addable<T>
d e f +( o t h e r : T)
end
d e f sum ( v a l u e s : I t e r a b l e <T>) where T : Addable<T>

count = 0
v a l u e s . each do | v a l u e |
count += v a l u e
end
count
end
d e f sum ( v a l u e s )
count = 0
v a l u e s . each do | v a l u e |
count += v a l u e
end
count
end
2. [20 pt.] Describa las diferencias semánticas en el siguiente programa si se implementa en un

lenguaje con alcance estático o con alcance dinámico. Si lo requiere, puede ayudarse de una
secuencia de pilas de ejecución.
gcd ’ 0 y = y
gcd ’ x y = gcd ’ ( y ‘mod‘ x ) x
myGCD x y | x < 0 = myGCD (−x ) y
| y < 0 = myGCD x (−y )
| y < x = gcd ’ y x
| otherwise = gcd ’ x y
1
3. [10 pt.] En el siguiente programa:
begin
integer a, b, c;
procedure p(x: integer, y: integer, z: integer);
begin
c := 5;
x := z;
c := 4;
y := z+a
end;
a := 2;
b := 4;
c := 1;
p(a, b, a+c);
print(b);
end;
a) por valor?
c) por referencia?
fun a(f,x,y) = f(x*2+3) andalso y
5. [10 pt.] Estos dos programas tienen una semántica aproximadamente equivalente. ¿Cuál de
los dos es orientado a objetos? ¿El que no es orientado a objetos, en qué paradigma podrı́a
clasificarse? Describa informalmente la semántica de estos programas. Describa muy brevemente
la estructura de cada uno de estos programas, marcando las diferencias entre ellos.
c l a s s Greeter
d e f i n i t i a l i z e ( name )
@name = name . c a p i t a l i z e
end
def salute
p u t s ” H e l l o #{@name } ! ”
end
end
g = G r e e t e r . new ( ” world ” )
g . salute
” H e l l o World ” . e a c h c h a r do | c h a r |
p r i n t char
end
p r i n t ’\n ’
2
6. [10 pt.] En el siguiente código, identifique las expresiones que expresan semántica exclusiva de
un programa concurrente y describa su semántica informalmente.
f i n a l int n ;
i f ( n <= 1 )
return n ;
f1 . fork ( ) ;
}
}

fun t w i c e ( f , x ) = f ( f ( x ) ) h a n d l e Excpt ( x ) => x ;
fun smart ( x ) = 1 + pred ( x ) h a n d l e Excpt ( x ) => 1 ;
a) twice(pred,1)
b) twice(dumb,1)
c) twice(smart,1)
Explique qué excepción se levanta en cada caso y dónde se levanta. Ayúdese de los respectivos
diagramas de pilas de ejecución
3
10 i = 0
20 i = i + 1
50 GOTO 20
70 END
val x = 4;
fun f ( y ) = x∗y ;
fun g ( x ) = l e t
f (3) + x ;
g(7);
meow.
class Felino {
public :
v o i d meow ( ) = 0 ;
};
public :
};

public :
};

public :
};
4
class Ser
@@cuenta = 0
@@cuenta += 1
end
end
end
super
end
end
super
end
end
super
end
end
Humano . new
d = Perro . new
5
6 de Agosto de 2015
Apellido y Nombre:
1. [20 pt.] Escriba el siguiente programa excepciones en lugar del manejo de errores mediante
estructuras de control.
Nota: no es necesario que el programa compile, puede usar pseudocódigo siempre que su semántica sea
ambigua.
codigoErrorType r e a d F i l e {
i n i t i a l i z e codigoError = 0;
// a b r i r e l a r c h i v o ;
i f ( elArchivoEstaAbierto ) {
// d e t e r m i n a r l a l o n g i t u d d e l a r c h i v o ;
i f ( obtenemosLongitudArchivo ) {
// a l o j a r e s a c a n t i d a d de memoria ;
i f ( tenemosSuficienteMemoria ) {
// leemos e l a r c h i v o a memoria ;
if ( falloLectura ) {
c o d i g o E r r o r = −1;
}
} else {
}
} else {
}
// c e r r a r e l a r c h i v o ;
i f ( e l A r c h i v o N o S e C e r r o && c o d i g o E r r o r == 0 ) {
} else {
c o d i g o E r r o r = c o d i g o E r r o r and −4;
}
} else {
}
return c o d i g o E r r o r ;
}
2. [10 pt.] Calcule el tipo de datos de la siguiente función en ML. Provea el árbol sintáctico de la
función y aplique de forma explı́cita el algoritmo de inferencia de tipos.
3. [20 pt.] Escriba un programa (puede ser en pseudocódigo) que de diferentes resultados si se usa
pasaje de parámetros por valor o por referencia.
1
4. [20 pt.] Indique si el siguiente programa en C++ se podrı́a escribir en Java con una semántica
equivalente. Si no se puede, indique por qué. Si se puede, indique con qué recursos del lenguaje
se puede.
c l a s s Persona
{
private :
int m nEdad ;
bool m bEsVaron ;
public :
{
}

};
c l a s s Empleado
{
private :
public :
{
}

};

{
private :
int m nDictaGrado ;
public :
{
}
};
2
5. [20 pt.] Diagrame la pila de ejecución del siguiente programa en Bash, incluyendo la estructura
de control links y access links, asumiendo que el lenguaje de programación tiene alcance estático.
x=1
f u n c t i o n g ( ) { echo $x ; x=2 ; }
f u n c t i o n f ( ) { l o c a l x=3 ; g ; }
f # d o e s t h i s p r i n t 1 , o r 3?
echo $x
Este programa está escrito en Bash, que en la realidad tiene alcance dinámico. Justifique por
qué puede ser que Bash se haya diseñado con lenguaje dinámico.
a) f(X,Y) = f(P,P)
b) a(X,c(d,X)) = a(2,c(d,Y))
c) a(X,c(d,X)) = a(X,c(d,Y))
d) a(X,c(d,X)) = a(2,c(X,Y))
e) f(foo,L) = f(A1,A1)
f) f(a) = a
g) f(X,a) = f(a,X)
3
10 i = 0
20 i = i + 1
50 GOTO 20
70 END
val x = 4;
fun f ( y ) = x∗y ;
fun g ( x ) = l e t
f (3) + x ;
g(7);
meow.
class Felino {
public :
v o i d meow ( ) = 0 ;
};
public :
};

public :
};

public :
};
4
class Ser
@@cuenta = 0
@@cuenta += 1
end
end
end
super
end
end
super
end
end
super
end
end
Humano . new
d = Perro . new
5
Paradigmas de la Programación – Primer Parcial
21 de Abril de 2016
Apellido y Nombre:
a) Una gramática independiente de contexto (context-free grammar)...

1) tiene predicados.
2) es inambigua.
3) tiene reglas de reescritura.
4) describe la sintaxis de un lenguaje.
5) es más expresiva que una gramática dependiente del contexto.
6) es tan expresiva como una máquina de Turing.
b) Las variables están compuestas de... (elija la opción más precisa)
1) un nombre y un valor.
2) un l-valor y un r-valor.
3) un identificador y un valor.
4) un identificador que está ligado a un valor que está ligado a una dirección en memoria.
5) un identificador que está ligado a una dirección en memoria que puede contener un
valor.
6) una dirección de memoria, un valor y un identificador en el texto del programa.
c) La clausura de una función es necesaria para...
1) definir funciones en un alcance global
2) mantener la referencia a las variables locales de la función si tenemos alcance dinámico
3) mantener la referencia a las variables locales de la función si tenemos alcance estático
4) mantener la referencia a las variables libres de la función si tenemos alcance dinámico
5) mantener la referencia a las variables libres de la función si tenemos alcance estático
d) La diferencia entre polimorfismo y sobrecarga es...
1) que sobrecarga se aplica sólo a algunos tipos, mientras que polimorfismo es más general.
2) que la sobrecarga se comprueba en tiempo de ejecución y el polimorfismo en tiempo de
compilación.
3) que en la sobrecarga tenemos diferentes implementaciones para un mismo sı́mbolo y en
el polimorfismo tenemos una sola implementación con tipos generales.
4) que la sobrecarga usa tipos concretos y el polimorfismo usa variables de tipo.
5) que la sobrecarga la analiza el compilador y el polimorfismo no.
e) Las excepciones se pueden usar para optimizar código...
1) porque tienen alcance dinámico.
2) porque son saltos explı́citos entre partes del programa.
3) porque son imperativas.
4) porque son funcionales.
1
se convierta en una gramática inambigua.
<s> ::= | <o>
 ::= ’i ’ <s> | ’ i ’ <s> ’ e ’ <s>
 ::= ’a ’ | ’b ’ | ’ c ’ | ’d ’
<o> ::= ’x ’ | ’ y ’ | ’ z ’ | ’w’
3. [10 pt.] En el siguiente programa, qué valores retornarán foo y bar si el alcance del lenguaje
es dinámico? y si es estático?
const int b = 5;
int foo ()
{
int a = b + 5;
return a ;
}
i n t bar ( )
{
int b = 2;
return foo ( ) ;
}
i n t main ( )
{
foo ( ) ;
bar ( ) ;
return 0;
}
4. [20 pt.] En este fragmento de código se captura una excepción y se vuelve a lanzar la misma
excepción. Explique qué sucede en este fragmento de código, ayudándose de un diagrama de una
secuencia de estados de la pila de ejecución, mostrando cómo se apilan y desapilan los diferentes
activation records a medida que se va ejecutando el programa. Para mayor claridad, puede
acompañarlo de una descripción verbal. Describa también verbalmente cuál serı́a el objetivo de
este programa. ¿Qué sentido tiene capturar una excepción para volver a lanzarla? ¿Es eso lo
único que se hace?
ITransaccion transaccion = null ;
try
{
t r a n s a c c i o n = s e s i o n . EmpiezaTransaccion ( ) ;
// h a c e r a l g o
t r a n s a c c i o n . Commit ( ) ;
}
catch
{
i f ( t r a n s a c c i o n != n u l l ) { t r a n s a c c i o n . R e s t a u r a r E s t a d o P r e v i o ( ) ; }
throw ;
}
2
fun f ( x , y , z ) = x && ( y o r z )
6. [20 pt.] El lenguaje de programación Scala implementa como parte del lenguaje una heurı́stica
llamada “linearización”, que permite determinar qué implementación se usará en un objeto que
hereda una componente con el mismo nombre de diferentes clases. Explique por qué es necesario
que el lenguaje implemente esta heurı́stica (qué problema resuelve) y dé un ejemplo donde se
muestre una configuración donde entrarı́a en juego esta heurı́stica para evitar el problema, por
ejemplo, la configuración conocida como el problema diamante.
7. [20 pt.] Java implementa un tipo de pasaje de parámetros que consiste en pasar por valor la
referencia a un objeto. Mediante este tipo de pasaje de parámetros, ¿Se puede implementar la
función swap para que intercambie el objeto A por el objeto B? ¿Se puede implementar la función
swap para intercambiar algún elemento, algún pedazo de software? ¿Cuál?
3
Paradigmas de la Programación – Segundo Parcial
14 de Junio de 2016
Apellido y Nombre:
1. [20 pt.] En el siguiente programa, identifique las porciones del programa que no son
funcionales, y mencione por qué no lo son. Escriba en pseudocódigo un programa funcional
con la misma semántica que este programa.
Module Modulo1
Dim t e x t o As S t r i n g = ” textoUno ”
P u b l i c Sub ConcatenaConGuion ( ByVal textoAConcatenar As S t r i n g )

t e x t o = t e x t o & ”−” & textoAConcatenar
End Sub
Sub Main ( )
ConcatenaConGuion ( ” textoDos ” )
End Sub
End Module
2. [10 pt.] En el siguiente programa en Rust, identifique porciones del programa que tienen
semántica puramente concurrente. Las porciones del programa que ha señalado, ¿son
construcciones lingüı́sticas para forzar atomicidad en porciones del código?
f n main ( ) {
l e t greeting = ” Hello ”;
l e t mut t h r e a d s = Vec : : new ( ) ;
f o r num i n 0 . . 1 0 {
t h r e a d s . push ( t h r e a d : : spawn ( move | | {
p r i n t l n ! ( ” { } from t h r e a d number {}” , g r e e t i n g , num ) ;
}));
}
f o r thread in threads {
t h r e a d . j o i n ( ) . unwrap ( ) ;
}
}
3. [10 pt.] Explique el rol del Security Manager en Java.
1
4. [10 pt.] Los actores (modelo de programación de concurrencia funcional) pueden realizar
una acción que consiste en redefinirse a sı́ mismos, es decir, cambiar el código que ejecutan.
Explique cómo esto se relaciona con el cambio de estado de un objeto en programación
orientada a objetos, y por qué los actores no recurren al concepto de estado que usan los
objetos.
5. [10 pt.] Dada la siguiente base de conocimiento en Prolog, explique cómo serı́a la sucesión
de objetivos que hay que satisfacer para contestar la consulta nieto(X,leoncio).
p r o g e n i t o r ( juan , a l b e r t o ) .
progenitor ( luis , alberto ) .
progenitor ( alberto , leoncio ) .
p r o g e n i t o r ( geronimo , l e o n c i o ) .
p r o g e n i t o r ( l u i s a , geronimo ) .
hermano (A, B) :−
p r o g e n i t o r (A, P) ,
p r o g e n i t o r (B, P) ,
A \== B .
n i e t o (A, B) :−
p r o g e n i t o r (A, P) ,
p r o g e n i t o r (P , B ) .
6. [10 pt.] En lenguajes inseguros, se pueden implementar polı́ticas de seguridad llamadas

“ejecución defensiva” o “programación defensiva”. Describa algunas de estas polı́ticas,
por ejemplo, para pervenirse de vulnerabilidades por debilidad en el sistema de tipos de
un lenguaje de scripting.
7. [20 pt.] A partir del siguiente programa en pseudocódigo, diagrame los diferentes mo-
mentos por los que pasa la pila de ejecución, y señale en esos momentos qué variables
pueden ser recolectadas por el recolector de basura (garbage collector). En los activation
records sólo necesita diagramar las variables locales. Asuma que todas las variables se
representan mediante punteros en los activation records, y que el valor de la variable se
encuentra en el heap, por lo tanto necesitan ser recolectadas por el recolector de basura.
Explique si la memoria asociada a alguna variable podrı́a haber sido liberada antes de
que el recolector de basura la libere, por ejemplo, manualmente.
int bla
{ int bli = ...
i n t blu = ...
int blo = ...
{
int ble = bli ∗ bli
}
bli = . . .
{
int ble = blo + blo
}
}
8. [10 pt.] Ordene los siguientes fragmentos de código de más de scripting a menos de
scripting, y explique cuáles son los principios que han contribuı́do a su ordenamiento.
PROGRAM HELLO
DO 1 0 , I =1 ,10
PRINT ∗ , ’ H e l l o World ’
10 CONTINUE
STOP
END
t e l l a p p l i c a t i o n ” S c r i p t a b l e Text E d i t o r ”
make new window
activate
s e t c o n t e n t s o f window 1 t o ” H e l l o World ! ” & r e t u r n
end t e l l
p r i n t ” H e l l o World ! ”
import s t d . s t d i o ;
i n t main ( ) { w r i t e f l n ( ” H e l l o world ! ” ) ; r e t u r n 0 ; }
Paradigmas de la Programación – Recuperatorio del Primer Parcial
21 de Junio de 2016
Apellido y Nombre:
1. [20 pt.] En Perl las variables pueden tener alcance estático (léxico) o dinámico, usando distintas
palabras clave en el momento de su asignación. En el siguiente programa se ve cómo las palabras
clave “local” y “my” tienen distintos efectos en la forma cómo las variables adquieren su valor.
Diga cuál de estas dos palabras claves se usa para que el valor de la variable se asigne con alcance
estática y cuál con alcance dinámico, y explique por qué.
sub v i s i b l e {
print ” l a v a r i a b l e t i e n e e l v a l o r $var \n” ;
}
sub uno {
l o c a l $var = ’ v a l o r uno ’ ;
visible ();
}
sub dos {
my $var = ’ v a l o r dos ’ ;
visible ();
}
$var = ’ g l o b a l ’ ;
visible (); # imprime ” g l o b a l ”
uno ( ) ; # imprime ” v a l o r uno”
dos ( ) ; # imprime ” g l o b a l ”
2. [10 pt.] Diagrame una secuencia de pilas de ejecución que representen los los diferentes momentos
de la ejecución del siguiente programa, mostrando cómo se apilan y desapilan los diferentes
activation records a medida que se va ejecutando el programa.
l e t fun g ( y ) = y+3
fun h ( z ) = g ( g ( z ) )
in
h(3)
end ;
fun f ( x , y , z ) = x && ( y o r z )
4. [20 pt.] Java tiene una construcción lingüı́stica llamada “try... catch... finally...” cuya
semántica consiste en que el bloque de código bajo el alcance de finally se ejecuta siempre, tanto
si se lanza una excepción bajo el alcance de try como si no se lanzó. Si se lanza una excepción, la
excepción funciona exactamente igual que si no existiera el bloque “finally” (aunque el bloque
1
finally se ejecuta en cualquier caso), si se puede capturar mediante el catch se captura, y si
no sigue buscando hasta que encuentra un catch que la pueda capturar. Sabiendo esto, explique
qué se imprime si ejecutamos los siguientes tres programas y por qué.
c l a s s Ejemplo1 {
public s t a t i c void main ( S t r i n g a r g s [ ] ) {
try {
System . out . p r i n t l n ( ” p r i m e r a s e n t e n c i a d e l b l o q u e t r y ” ) ;
int num=45/0;
System . out . p r i n t l n (num ) ;
}
catch ( ArrayIndexOutOfBoundsException e ) {
System . out . p r i n t l n ( ” ArrayIndexOutOfBoundsException ” ) ;
}
finally {
System . out . p r i n t l n ( ” b l o q u e f i n a l l y ” ) ;
}
System . out . p r i n t l n ( ” f u e r a d e l b l o q u e try −catch −f i n a l l y ” ) ;
}
}
try {
System . out . p r i n t l n ( ” p r i m e ra s e n t e n c i a d e l b l o q u e t r y ” ) ;
int num=45/0;
}
catch ( A r i t h m e t i c E x c e p t i o n e ) {
System . out . p r i n t l n ( ” A r i t h m e t i c E x c e p t i o n ” ) ;
}
finally {
}
}
}
try {
System . out . p r i n t l n ( ” p r i m e r a s e n t e n c i a d e l b l o q u e t r y ” ) ;
int num=45/3;
}
catch ( ArrayIndexOutOfBoundsException e ) {
}
finally {
}
}
}
2
5. [20 pt.] En muchos lenguajes de programación no se implementa herencia múltiple, sino que se
usan mecanismos alternativos. En este ejemplo de Scala, explique cómo se usa la construcción
trait de una forma parecida a las interfaces de Java o los mixins de Ruby para conseguir una
expresividad parecida a la herencia múltiple de C++.
t r a i t Cantante {
def c a n t a r { p r i n t l n ( ” cantando . . . ” ) }
//mas metodos
}
c l a s s Persona {
def e x p l i c a r { p r i n t l n ( ” humano ” ) }
//mas metodos
}
c l a s s Actor extends Persona with Cantante

c l a s s Actor extends Cantante with P e r f o r m e r
6. [20 pt.] En un lenguaje con pasaje por referencia, qué sentencias tenemos que incorporar para
que una función dé los mismos resultados que obtendrı́amos si el pasaje de parámetros fuera
por valor-resultado (call by value-result)? Por ejemplo, qué sentencias deberı́amos añadir y cómo
deberı́amos modificar la siguiente función:
p r o c e d u r e p ( var x , y : i n t e g e r ) ;
begin
...
x:=x+1;
y:=y+1
...
end ;
p(z , z )
3
Paradigmas de la Programación – Recuperatorio del Segundo Parcial
21 de Junio de 2016
Apellido y Nombre:
1. [20 pt.] Estos dos programas están escritos en Perl. ¿Cuál de los dos es funcional? Identifique
en el programa no funcional las partes del código que no son funcionales y explique cómo se
expresa la misma semántica en la versión funcional para que sea funcional.
my @numbers = qw( 1 3 5 6 7 8 ) ;
my $sum = 0 ;
fo r my $num ( @numbers ) { $sum += $num ; }
say $sum ;
my @numbers = qw( 1 3 5 6 7 8 ) ;
sub r e d u c e (&@) {
my ( $code , $ f i r s t , @ r e s t ) = @ ;
return $ f i r s t unless @r e s t ;
return $code −>(

$first ,
r e d u c e ( $code , @ re st ) ,
);
}
sub sum {
return r e d u c e { $ [ 0 ] + $ [ 1 ] } @ ;
}
say sum @numbers ; $
2. [10 pt.] En el siguiente programa en Elixir, identifique porciones del programa que tienen
semántica puramente concurrente. Las porciones del programa que ha señalado, ¿son construc-
ciones lingüı́sticas para forzar atomicidad en porciones del código?
t a s k = Task . async f n −> p e r f o r m c o m p l e x a c t i o n ( ) end
other time consuming action ()
Task . a w a i t t a s k
3. [20 pt.] A partir del siguiente programa en pseudocódigo, diagrame los diferentes momentos por
los que pasa la pila de ejecución, y señale en esos momentos qué variables pueden ser recolectadas
por el recolector de basura (garbage collector). En los activation records sólo necesita diagramar
las variables locales. Asuma que todas las variables se representan mediante punteros en los
activation records, y que el valor de la variable se encuentra en el heap, por lo tanto necesitan ser
1
recolectadas por el recolector de basura. Explique si la memoria asociada a alguna variable podrı́a
haber sido liberada antes de que el recolector de basura la libere, por ejemplo, manualmente.
int bla = . . .
{ int bli = . . .
i n t blu = . . .
int blo = . . .
{
int ble = b l i ∗ bla
}
bli = . . .
{
int ble = b l i + blo
}
}
4. [10 pt.] El siguiente script en AppleScript busca en Computerworld.com el contenido del texto
que hay en el portapapeles. Identifique los elementos del programa que lo caracterizan dentro
del paradigma de scripting y explı́quelos.
s e t u r l 1 t o ” h t t p : / /www. computerworld . com/ a c t i o n / g o o g l e S e a r c h . do ? cx = 0 1 4 . . . ”
s e t u r l 2 t o ”&x=0&y=0&c o f=FORID %3A9#1214”
t e l l a p p l i c a t i o n ” System Events ”
s e t myquery t o t h e c l i p b o a r d
end t e l l
s e t t h e q u e r y t o SaR ( myquery , ” ” , ”+”)
t e l l a p p l i c a t i o n ”Chrome”
activate
t e l l a p p l i c a t i o n ” System Events ”
t e l l p r o c e s s ”Chrome”
c l i c k menu item ”New Tab” o f menu ” F i l e ” o f menu bar 1
end t e l l
end t e l l
s e t theURL t o u r l 1 & t h e q u e r y & u r l 2
s e t URL o f document 1 t o theURL
end t e l l
5. [10 pt.] Dada la siguiente base de conocimiento en Prolog, explique cómo serı́a la sucesión de
objetivos que hay que satisfacer para contestar la consulta ama(X,mia).
hombre ( v i n c e n t ) .
mujer ( mia ) .
hombre ( j u l e s ) .
hombre ( john ) .
h i j a ( mia , john ) .
h i j o ( j u l e s , john ) .
ama(X,Y): − padre (X,Y ) .
padre (Y, Z): − hombre (Y) , h i j o ( Z ,Y ) .
padre (Y, Z): − hombre (Y) , h i j a ( Z ,Y ) .
6. [10 pt.] Explique cómo se usa la firma de código en los mecanismos de seguridad de Java.
7. [20 pt.] En Occam los programas se construyen con las siguientes primitivas lingüı́sticas:
2
SEQ : una secuencia de comandos que suceden en orden estricto.
PAR : una lista de comandos que se ejecutan sin especificar el orden.
CHAN canales de comunicación definidos para que los procesos se comuniquen (lectura o es-
critura).
En el siguiente programa en Occam:

CHAN a
VAR x , y
PAR
SEQ
x := 1
a!x
SEQ
a ?y
y := y + 2
Usando este programa como marco de comparación, explique cómo los actores implementan
concurrencia sin condiciones de carrera, explicando cómo se implementarı́a este programa en
programación con actores.
3
7 de Julio de 2016
Apellido y Nombre:
1. [5 pt.] El siguiente es un ejemplo de “spaghetti code”. Reescrı́balo en pseudocódigo de

forma que NO use saltos (GOTO), y en cambio use programación estructurada en bloques.
10 i = 0
20 i = i + 1
50 GOTO 20
60 PRINT ”Program Completed . ”
70 END
2. [10 pt.] Muestre con un ejemplo que la siguiente gramática es ambigua, y modifı́quela
para que se convierta en una gramática totalmente inambigua.
<a> ::= <c>
 ::= <a>
 ::= []
<c> ::= ’c’ ’d’ ’e’
<c> ::= ’c’ ’d’
<c> ::= ’e’
3. [15 pt.] Diagrame una secuencia de pilas de ejecución que representen los los diferentes
momentos de la ejecución del siguiente programa, mostrando cómo se apilan y desapilan
los diferentes activation records a medida que se va ejecutando el programa. Asuma que
el lenguaje de programación tiene alcance estático. Diga qué retorna f(2) si el lenguaje
tiene alcance estático, y qué retornarı́a con alcance dinámico. Señale también los puntos
de la ejecución en los que el recolector de basura puede recolectar variables y diga cuáles
pueden ser recolectadas.
var x=1;
var y=5;
f u n c t i o n g ( z ) { r e t u r n x+z ; }
function f (y) {
var x = y∗y ;
return g(y ) ;
}
var x=5;
f (2)
1
4. [10 pt.] Escriba un programa (puede ser en pseudocódigo) en el que el resultado sea
distinto si el pasaje de parámetros es por valor, por referencia o por valor-resultado.
Explique qué comparte el pasaje de parámetros por valor-resultado con el pasaje por
valor y qué comparte con el pasaje por referencia.
5. [10 pt.] El enlace dinámico (o dynamic dispatch) es un mecanismo de la programación

orientada a objetos por el cual se selecciona con qué método o función se responderá a
un determinado mensaje en tiempo de ejecución. Es necesario hacer esto en tiempo de
ejecución porque es imposible saber en tiempo de compilación cuál será el tipo del mensaje
recibido. En C++ el tipo de dispatch por defecto es estático, y para que se pueda realizar
dynamic dispatch hay que declarar un método como virtual. Los métodos virtuales se
implementan mediante una estructura de datos que se llama vtable o virtual table,
que define la correspondencia entre mensajes y métodos para cada clase. Comente la
utilidad y coste del dynamic dispatch en términos de overhead y flexibilidad. Establezca
un paralelismo con el polimorfismo de tipos mediante un ejemplo.
6. [10 pt.] Supongamos que un lenguaje de programación usa el sı́mbolo “=” como operador
de unificación, ¿qué imprimirı́a el siguiente programa?
var x ;
var y=1;
function f (a , b) {
i f ( a = b ) { print ” si ” }
e l s e { p r i n t ”no” }
}
f (x , y)
7. [10 pt.] Este código en Erlang implementa las mismas funcionalidades que los canales de
Go mediante los procesos y mensajes de Erlang. Identifique porciones del programa que
tienen semántica puramente concurrente. Identifique aquellas que tienen funcionalidades
especı́ficas para pasaje de mensajes, como en el modelo de actores.
defmodule GoChannel do
d e f make do
spawn(&GoChannel . l o o p / 0 )
end
d e f w r i t e ( channel , v a l ) do
send ( channel , { : w r i t e , v a l })
end
d e f r ead ( c h a n n e l ) do
send ( channel , { : read , s e l f })
r e c e i v e do
{ : read , channel , v a l } −> v a l
end
end
d e f l o o p do
r e c e i v e do
{ : read , c a l l e r } −> r e c e i v e do
2
{ : w r i t e , v a l } −> send ( c a l l e r , { : read , s e l f , v a l } ) ; l o o p
end
end
end
end

fun t w i c e ( f , x ) = f ( f ( x ) ) ha ndle Excpt ( x ) => x ;
fun smart ( x ) = 1 + pred ( x ) ha ndle Excpt ( x ) => 1 ;
a) twice(pred,1)
b) twice(dumb,1)
c) twice(smart,1)
Explique qué excepción se levanta en cada caso y dónde se levanta. Ayúdese de los res-
pectivos diagramas de pilas de ejecución.
9. [5 pt.] En Perl las variables pueden tener alcance estático (léxico) o dinámico, usando
distintas palabras clave en el momento de su asignación. En el siguiente programa se ve
cómo las palabras clave “local” y “my” tienen distintos efectos en la forma cómo las
variables adquieren su valor. Diga cuál de estas dos palabras claves se usa para que el
valor de la variable se asigne con alcance estática y cuál con alcance dinámico, y explique
por qué.
sub v i s i b l e {
print ” l a v a r i a b l e t i e n e e l v a l o r $var \n” ;
}
sub uno {
l o c a l $var = ’ v a l o r uno ’ ;
visible ();
}
sub dos {
my $var = ’ v a l o r dos ’ ;
visible ();
}
$var = ’ g l o b a l ’ ;
visible (); # imprime ” g l o b a l ”
uno ( ) ; # imprime ” v a l o r uno”
dos ( ) ; # imprime ” g l o b a l ”
10. [15 pt.] Escriba un programa (puede ser en pseudocódigo) en el que una variable sea el
medio por el cual se propagan efectos secundarios más allá del alcance de una función.
Relacione este fenómeno con los paradigmas funcional e imperativo, incluyendo en su
explicación los conceptos de determinismo en las componentes de software. Explique como
este comportamiento que puede originar tantos comportamientos inesperados puede llegar
a utilizarse de forma ventajosa en un esquema productor-consumidor.
3
1. [-10 pt.] Java tiene una construcción lingüı́stica llamada “try... catch... finally...”
cuya semántica consiste en que el bloque de código bajo el alcance de finally se ejecuta
siempre, tanto si se lanza una excepción bajo el alcance de try como si no se lanzó. Si
se lanza una excepción, la excepción funciona exactamente igual que si no existiera el
bloque “finally” (aunque el bloque finally se ejecuta en cualquier caso), si se puede
capturar mediante el catch se captura, y si no sigue buscando hasta que encuentra un
catch que la pueda capturar. Sabiendo esto, explique qué se imprime si ejecutamos los
siguientes tres programas y por qué.
try {
System . out . p r i n t l n ( ” primera s e n t e n c i a d e l b l o q u e t r y ” ) ;
int num=45/0;
}
catch ( ArrayIndexOutOfBoundsException e ){
}
finally {
}
System . out . p r i n t l n ( ” f u e r a d e l b l o q u e try−catch−f i n a l l y ” ) ;
}
}
try {
int num=45/0;
}
catch ( A r i t h m e t i c E x c e p t i o n e ){
}
finally {
}
}
}
try {
int num=45/3;
}
4
}
finally {
}
}
}

c l a s s S er
@@cuenta = 0
@@cuenta += 1
puts ” creamos un s e r ”
end
end
end
c l a s s Humano < S er
super
puts ” creamos un humano”
end
end
c l a s s Animal < S er
super
puts ” creamos un animal ”
end
end
super
puts ” creamos un p e r r o ”
end
end
Humano . new
d = Perro . new
puts d . m u e s t r a c u e n t a
5
3. [-5 pt.] Si el resultado del siguiente programa es 19, qué tipo de alcance tiene el lenguaje
de programación en el que está escrito, estático o dinámico?
val x = 4;
fun f ( y ) = x∗y ;
fun g ( x ) = l e t
f (3) + x ;
g(7);
4. [-5 pt.] Identifique en el siguiente código en C++ un problema con la herencia del miem-
bro meow.
cl ass Felino {
public :
v o i d meow ( ) = 0 ;
};
public :
v o i d meow ( ) { s t d : : co ut << ”miau\n ” ; }
};

public :
v o i d meow ( ) { s t d : : co ut << ”ROARRRRRR\n ” ; }
};

public :
v o i d meow ( ) { s t d : : co ut << ” r o a r r r r r \n ” ; }
};
6
19 de Diciembre de 2016
Apellido y Nombre:
1. [5 pt.] Calcule el tipo de datos de la siguiente función en ML. Provea el árbol sintáctico
de la función y aplique de forma explı́cita el algoritmo de inferencia de tipos, ya sea sobre
el árbol mismo o como sistema de ecuaciones.
fun a ( x , y ) = ( x > 2 ) o r e l s e ( y < 1 0 )
2. [5 pt.] Muestre con un ejemplo que la siguiente gramática es ambigua, y modifı́quela

para que se convierta en una gramática totalmente inambigua.
<a> ::= <c>
 ::= <a>
 ::= []
<c> ::= ’c’ ’d’ ’e’
3. [20 pt.] Diagrame la pila de ejecución del siguiente programa en Bash, incluyendo la
estructura de control links y access links, asumiendo que el lenguaje de programación
tiene alcance estático.
x=1
f u n c t i o n g ( ) { echo $x ; x=2 ; }
f u n c t i o n f ( ) { l o c a l x=3 ; g ; }
f # does t h i s p r i n t 1 , o r 3?
echo $x
4. [10 pt.] El programa anterior está escrito en Bash, que en la realidad tiene alcance
dinámico. Justifique por qué puede ser que Bash se haya diseñado con lenguaje dinámico.
5. [10 pt.] Si quiero un control fuerte de la seguridad de una aplicación, debo renunciar a
usar un lenguaje de scripting como por ejemplo JavaScript? Dé por lo menos un argu-
mento que muestre las vulnerabilidades de un lenguaje de scripting y por lo menos dos
argumentos o estrategias con las que podrı́a tratar de reducir los riesgos de un lenguaje de
scripting. Argumente qué ventajas aportan las caracterı́sticas del lenguaje que implican
vulnerabilidades.
6. [10 pt.] Explique por qué se eliminó la herencia múltiple en lenguajes creados poste-
riormente a C++, y qué caracterı́sticas tienen los mecanismos alternativos. Ayudándose
del siguiente texto, ejemplifique su explicación mediante las caracterı́sticas especı́ficas
de los mixins, y extrapole a las interfaces de Java (o a los traits de PHP o Scala
o a alguna caracterı́stica similar que usted conozca), notando semejanzas y diferencias.
¿Qué problemas tratan de evitar estos mecanismos? ¿Qué capacidades expresivas tienen?
1
A mixin can basically be thought of as a set of code that can be added
to one or more classes to add additional capabilities without using in-
heritance. In Ruby, a mixin is code wrapped up in a module that a class
can include or extend [...] Modules can either be included or extended
depending on whether the methods will be added as instance methods or
class methods, respectively.
7. [10 pt.] Señale cuáles de las siguientes expresiones son true en Prolog, es decir, en qué ca-
sos se encuentra una unificación exitosa para la expresión, y cómo se pueden instanciar
los valores de las variables en las unificaciones exitosas.
a) f(X,Y) = f(P,P)
b) a(X,c(d,X)) = a(2,c(d,Y))
c) a(X,c(d,X)) = a(X,c(d,Y))
d) a(X,c(d,X)) = a(2,c(X,Y))
e) f(foo,L) = f(A1,A1)
f) f(a) = a
g) f(X,a) = f(a,X)
8. [10 pt.] El enlace dinámico (o dynamic dispatch) es un mecanismo de la programación

orientada a objetos por el cual se selecciona con qué método o función se responderá a
un determinado mensaje en tiempo de ejecución. Es necesario hacer esto en tiempo de
ejecución porque es imposible saber en tiempo de compilación cuál será el tipo del mensaje
recibido. En C++ el tipo de dispatch por defecto es estático, y para que se pueda realizar
dynamic dispatch hay que declarar un método como virtual. Los métodos virtuales se
implementan mediante una estructura de datos que se llama vtable o virtual table,
que define la correspondencia entre mensajes y métodos para cada clase. Comente la
utilidad y coste del dynamic dispatch en términos de overhead y flexibilidad. Establezca
un paralelismo con el polimorfismo de tipos mediante un ejemplo.
9. [10 pt.] La siguiente función de Python añade un elemento a una lista dentro de un
diccionario de listas. Modifı́quelo usando excepciones para manejar un posible error de
llaves (KeyError) si la lista con el nombre no existe todavı́a en el diccionario, en lugar
de comprobar por adelantado si ya existe. Incluya una cláusula finally (que se ejecu-
tará independientemente de si se lanza una excepción o no).
def a n i a d i r a l i s t a e n d i c c i o n a r i o ( d i c c i o n a r i o , n o m b r e l i s t a , elemento ) :
i f n o m b r e l i s t a in d i c c i o n a r i o :
l = diccionario [ nombrelista ]
print ( ” %s ya t i e n e %d e l e m e n t o s . ” % ( n o m b r e l i s t a , l e n ( l ) ) )
else :
diccionario [ nombrelista ] = [ ]
print ( ”Creamos %s . ” % n o m b r e l i s t a )
d i c c i o n a r i o [ n o m b r e l i s t a ] . append ( elemento )
print ( ” Aniadimos %s a %s . ” % ( elemento , n o m b r e l i s t a ) )
10. [10 pt.] Este código en Erlang implementa las mismas funcionalidades que los canales de
Go mediante los procesos y mensajes de Erlang. Identifique porciones del programa que
2
tienen semántica puramente concurrente. Identifique aquellas que tienen funcionalidades
especı́ficas para pasaje de mensajes, como en el modelo de actores.
defmodule GoChannel do
d e f make do
spawn(&GoChannel . l o o p / 0 )
end
d e f w r i t e ( channel , v a l ) do
send ( channel , { : w r i t e , v a l })
end
d e f r ead ( c h a n n e l ) do
send ( channel , { : read , s e l f })
r e c e i v e do
{ : read , channel , v a l } −> v a l
end
end
d e f l o o p do
r e c e i v e do
{ : read , c a l l e r } −> r e c e i v e do
{ : w r i t e , v a l } −> send ( c a l l e r , { : read , s e l f , v a l } ) ; l o o p
end
end
end
end
11. [10 pt.] En el siguiente código en Scheme:

( define incr ())
( define get ( ) )
( l e t ((n 0))
( s e t ! i n c r ( lambda ( i ) ( s e t ! n (+ n i ) ) ) )
( s e t ! g e t ( lambda ( ) n ) ) )
Las variables incr y get son globales, y la variable n se comparte entre ambas. Explique lo
que hace este programa usando los conceptos de efectos secundarios y variable compartida,
y explique utilidades y problemas del estado explı́cito en programación.

1. [-10 pt.] Java tiene una construcción lingüı́stica llamada “try... catch... finally...”
cuya semántica consiste en que el bloque de código bajo el alcance de finally se ejecuta
siempre, tanto si se lanza una excepción bajo el alcance de try como si no se lanzó. Si
se lanza una excepción, la excepción funciona exactamente igual que si no existiera el
bloque “finally” (aunque el bloque finally se ejecuta en cualquier caso), si se puede
capturar mediante el catch se captura, y si no sigue buscando hasta que encuentra un
catch que la pueda capturar. Sabiendo esto, explique qué se imprime si ejecutamos los
siguientes tres programas y por qué.
3
try {
int num=45/0;
}
}
finally {
}
}
}
try {
int num=45/0;
}
catch ( A r i t h m e t i c E x c e p t i o n e ){
}
finally {
}
}
}
try {
int num=45/3;
}
}
finally {
}
}
}
4
2. [-5 pt.] Dada la siguiente base de conocimiento en Prolog, explique cómo serı́a la sucesión
de objetivos que hay que satisfacer para contestar la consulta primo(X,juan).
p r o g e n i t o r ( esteban , juan ) .
p r o g e n i t o r ( ana , juan ) .
p r o g e n i t o r ( esteban , t e r e s a ) .
p r o g e n i t o r ( ana , t e r e s a ) .
p r o g e n i t o r ( marisa , n o e l i a ) .
progenitor ( felix , noelia ) .
p r o g e n i t o r ( marisa , t r i s t a n ) .
progenitor ( victor , tristan ) .
hermano ( este ban , v i c t o r ) .
primo (X,Y): − t i o (Z ,X) , p r o g e n i t o r (Z ,Y) .
t i o (X,Y): − hermano (X, Z ) , p r o g e n i t o r (Z ,Y ) .
3. [-5 pt.] En el siguiente programa,

begin
integer n;
procedure p(k : i n t e g e r ) ;
begin
k := k+2;
print (n ) ;
n := n+(2∗k ) ;
end ;
n := 4 ;
p(n ) ;
print (n ) ;
end ;
a) por valor?
c) por referencia?
4. [5 pt.] El siguiente es un ejemplo de “spaghetti code”. Reescrı́balo en pseudocódigo de

forma que NO use saltos (GOTO), y en cambio use programación estructurada en bloques.
10 i = 0
20 i = i + 1
50 GOTO 20
60 PRINT ”Program Completed . ”
70 END

Guia de Lectura Paradigmas FaMAF-UNC

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Guia de Lectura Paradigmas FaMAF-UNC

Cargado por

Copyright:

Formatos disponibles

Guı́a de lectura para la materia

Licenciatura en Ciencias de la Computación

Esta guı́a es un documento de apoyo a la materia Paradigmas de la Programación de

2. Qué es y qué puede hacer un lenguaje de programación 6

3. Cómo funcionan los lenguajes de programación 16

9. Programación lógica 103

10.Programación concurrente 106

11.Paradigma de scripting 112

12.Seguridad basada en lenguajes de programación 120

A. Exámenes de ediciones anteriores 121

1.1. Nuestro objeto de estudio

1.2. Cuestiones fundamentales

1.3. Objetivos del curso “Paradigmas de la Progra-

1.4. Para qué sirve esta materia

1.5. Estructura de este apunte

Qué es y qué puede hacer un

Un lenguaje de programación es un lenguaje formal diseñado para realizar procesos

2.1. Sintaxis y semántica

2.2. Alcance de los lenguajes de programación

2.3. Sintaxis a través de gramáticas

2.4. Semántica operacional vs. lambda cálculo o de-

2.5. Para saber más

a) lo que significan las sentencias de un lenguaje de programación.

2.2. Una gramática independiente de contexto (context-free grammar)...

a) Si existe una secuencia de reglas de la gramática que puedan aplicarse sucesiva-

2.8. La semántica de los lenguajes de programación debe reflejar formalmente...

a) la intención del programador.

2.9. La semántica operacional...

a) describe el significado de un programa como una secuencia de transiciones de

2.10. La semántica denotacional...

a) explica el significado de un programa paso a paso.

2.12. Considerando la asignación múltiple de variables en Python, ¿es Python un lenguaje

2.14. Dada la siguiente gramática:

<e> ::= <n> | <e>+<e> | <e>-<e>

a) Enumere los conjuntos de no terminales y terminales.

Para obtener la derivación de la siguiente expresión:

a) ssh [-1246AaCfgKkMNnqsTtVvXxYy] [-b bind_address] [-c cipher_spec] [-D

b) <postal-trate> ::= <nombre-parte> <calle-trate> <relampagar-parte>

¿Cómo serı́a el tokenizer para reconocer las expresiones de un lenguaje de programa-

Determine cuáles de los siguientes son programas sintácticamente correctos. Derive,

[1 [[2 [[3] [4] [5]]] [6 [[7] [8]]]]]

Escriba una EBNF que formalice la estructura de datos descripta.

Cómo funcionan los lenguajes de

3.1. Estructura de un compilador

3.2. Estructuras de datos de bajo nivel

ref v – crea una celda de referencia que contiene el valor v

3.2. El identificador de una variable es...

a) la dirección de memoria donde se encuentra un valor que se usa en un programa.

a) el identificador de la variable se usa para ligarse a otra variable.

4.1. Código estructurado vs. código spaghetti

4.2. Estructura de bloque

Las nuevas variables se pueden declarar en varios puntos de un programa.

Cuando un programa inicia la ejecución de las instrucciones contenidas en un bloque

Cuando un programa sale de un bloque, parte o toda la memoria asignada a las

Un identificador de variable que no está declarado en el bloque actual se considera

Aunque la mayorı́a de los lenguajes de programación de propósito general modernos son

variables locales que se almacenan en la pila de ejecución, en el activation record aso-

parámetros de función que también se almacenan en el activation record asociada con

La mayorı́a de complicaciones y diferencias entre lenguajes están relacionadas con el

4.3. Activation records

El lenguaje de programación C está diseñado para ser fácil de compilar y ejecutar,

4.3.1. Detalle de ejecución de un activation record

a) unidades en la pila de ejecución

4.2. Todo activation record necesariamente tiene...