2. PRINCIPIOS DE DISEÑO DE LOS LENGUAJES ......................................................................................................................

2.1. HISTORIA Y CRITERIOS DE DISEÑO.............................................................................................................................................. 2

2.2. EFICIENCIA ............................................................................................................................................................................ 3
o Eficiencia del código .......................................................................................................................................................... 3
o Eficiencia de Compilación .................................................................................................................................................. 3
o Capacidad de implementación .......................................................................................................................................... 3
o Eficiencia de la programación ........................................................................................................................................... 3
o Confiabilidad...................................................................................................................................................................... 3
o Legibilidad ......................................................................................................................................................................... 3
o Capacidad de mantenimiento ........................................................................................................................................... 3
2.3. REGULARIDAD ....................................................................................................................................................................... 3
o Generalidad ....................................................................................................................................................................... 3
o Ortogonalidad ................................................................................................................................................................... 4
o Uniformidad ...................................................................................................................................................................... 4
2.4. PRINCIPIOS ADICIONALES SOBRE DISEÑO DE LOS LENGUAJES .......................................................................................................... 4
 Simplicidad ........................................................................................................................................................................ 4
 Expresividad....................................................................................................................................................................... 4
 Extensibilidad .................................................................................................................................................................... 5
 Capacidad de restricción ................................................................................................................................................... 5
 Consistencia ante notaciones y reglas convencionales aceptadas .................................................................................... 5
 Precisión ............................................................................................................................................................................ 5
 Independencia de la máquina ........................................................................................................................................... 6
 Seguridad........................................................................................................................................................................... 6
2. Principios de diseño de los lenguajes
 El éxito o fracaso de un LP puede depender de las interacciones complejas entre los mecanismos del mismo.
 Toda aplicación de programación es distinta y requiere de abstracciones diferentes, por lo que, con el diseño del lenguaje,
debemos o bien proporcionar abstracciones adecuadas para situaciones particulares o herramientas de tipo general para la
creación sobre demandas de dichas abstracciones.
 Por lo tanto, el diseño del LP depende mucho del uso pretendido y los requisitos de este uso. En esto es similar a la
programación misma, se trata de una actividad orientada a metas.

2.1. Historia y criterios de diseño

 Al iniciarse los LP, existía un criterio de diseño primordial, eficiencia en la ejecución (las máquinas eran extremadamente
lentas). Este era el objetivo de algunos LP como FORTRAN.
 Naturalmente, se podía olvidar que la razón principal de la existencia de un LP de alto nivel era facilitar la escritura del
programa.
 Esta capacidad de escritura (la cualidad de un lenguaje que le permite a un programador su uso para expresar una
computación con claridad, corrección, de manera concisa y con rapidez) siempre quedó en segundo término en relación
con la eficiencia.
 Años 60:
o Tanto COBOL como Algol60 pueden considerarse como pasos hacia criterios más generales que la simple
eficiencia del código generado.
o Algol60:
 La estructura en bloques y la disponibilidad de la recursión hacía más adecuado para expresar
algoritmos en una forma lógicamente clara y concisa, promoviendo una mayor capacidad de escritura.
 Fue diseñado como un LP para comunicar algoritmos entre personas, por lo que su legibilidad (la
cualidad de un lenguaje que le permite a un programador comprender y entender de manera fácil y con
precisión la naturaleza de una computación) también era una meta importante en el diseño.
o Algol68:
 Intentó reducir la complejidad del lenguaje al hacerse totalmente general (muy pocas restricciones) y
ortogonal (se pudieran combinar sus características en cualquier forma significativa).
o COBOL:
 Intentaba mejorar una legibilidad de los programas haciendo que los programas se parecieran más al
inglés escrito ordinario.
o Simula67:
 Tenía como meta proveer mecanismos de abstracción más poderosos.
 Introducen el concepto de clase.
 Años 70 a 80:
o Llegó un mayor énfasis en la simplicidad y la abstracción, como PASCAL, C, Euclid, CLU, Modula-2 y Ada.
 Años 80 a 90:
o Continuó con el interés de mejorar la precisión lógica o matemática de los lenguajes, como Ml, Haskell y
Lisp/Scheme.
 Últimos 15 años:
o El desarrollo de mayor importancia ha sido el éxito práctico de los lenguajes orientados a objetos, como
Smalltalk, C++ y Java.
 Las metas de diseño de mayor éxito han sido:
o La correspondencia de los mecanismos de abstracción con las necesidades de las tareas de programación.
o El uso de bibliotecas para ampliar la resolución de tareas específicas.
o El uso de técnicas orientadas a objetos para aumentar la flexibilidad y reutilización del código.

2 Longinos Recuero Bustos (http://longinox.blogspot.com)

2.2. Eficiencia
 Este principio puede abarcar prácticamente todos los demás principios en varias formas:
o Eficiencia del código:
 El diseño del lenguaje debe ser tal que un compilador pueda generar un código ejecutable eficiente
(optimizabilidad).
o Eficiencia de Compilación:
 Compilación rápida, usando un compilador de tamaño reducido.
 La verificación de errores puede ser un problema grave de eficiencia, ya que verificar la existencia de
un error en tiempo de compilación puede hacer ineficiente al compilador, y la generación de código
para verificar el error durante la ejecución podría hacer que el código objetivo resulte ineficiente.
 Por otra parte, ignorar esa verificación, viola otro principio de diseño, la confiabilidad (el aseguramiento
de que un programa no se comportará en formas no esperadas durante su ejecución).
o Capacidad de implementación:
 Es la eficiencia con la que se puede escribir un compilador.
 El éxito de un lenguaje se puede obstaculizar simplemente porque es demasiado difícil escribir un
compilador.
o Eficiencia de la programación:
 Rapidez y facilidad en la escritura de programas en el lenguaje.
 Facilidad para expresar procesos y estructuras complejas (capacidad de expresión del lenguaje).
 Resumiendo, facilidad con la que se puede correlacionar el diseño en la cabeza del programador con el
código real.
 Lo conciso de la sintaxis y evitar detalles innecesarios, como son las declaraciones de variables, a
menudo también se consideran factores importantes en este tipo de eficiencia.
o Confiabilidad:
 Se puede considerar la confiabilidad como un problema de eficiencia en sí mismo.
 Un programa que no sea confiable genera muchos costos adicionales (modificaciones, pruebas, …).
 Este tipo de eficiencia es un problema de consumo de recursos en la ingeniería del software.
o Legibilidad:
 Facilidad con la que un lenguaje puede ser comprendido.
o Capacidad de mantenimiento:
 Facilidad con la cual se pueden localizar errores y corregirse, así como agregarse nuevas
características.

2.3. Regularidad
 Es una cualidad algo mal definida de un lenguaje que expresa lo bien que están integradas las características del mismo.
 Una mayor regularidad implica:
o Pocas restricciones en el uso de constructores.
o Menos interacciones raras entre dichos constructores.
o En general, menos sorpresas en la forma en que se comportan las características del lenguaje.

 La regularidad se puede dividir en tres conceptos:

o Generalidad:
 Un lenguaje logra tener generalidad eliminando casos especiales en la disponibilidad y uso de los
constructores y combinando constructores íntimamente relacionados en uno solo más general.
 Algunos ejemplos de violación de este concepto podrían ser la carencia de:
 Variables de procedimientos (Pascal).
 Anidación de funciones / procedimientos (C).
 Arreglos de longitud variable (Pascal).
 Extensión y creación de operadores (==, +, …) hacia nuevos tipos de datos (C) .

3 Longinos Recuero Bustos (http://longinox.blogspot.com)

 o Ortogonalidad:
 Los constructores del lenguaje no deben comportarse de manera diferente en contextos diferentes, por
lo que las restricciones que dependen del contexto son no ortogonales, en tanto que las que se aplican
independientemente del contexto son no generales.
 Los constructores del lenguaje se pueden combinar en cualquier forma significativa y que la interacción
entre los constructores o el contexto del uso no debe generar restricción o comportamientos
inesperados.
 Los constructores no pueden comportarse de manera diferente en contextos diferentes.
 Algunos ejemplos de violación de este concepto podrían ser la carencia de:
 Las funciones solo devuelven valores escalares o apuntadores (Pascal).
 Las variable locales sólo pueden declararse al principio de un bloque (C).
 Paso de todos los parámetros por valor, excepto los arreglos (C).
 La ortogonalidad fue una meta principal de Algol68 y se mantiene como el mejor ejemplo de un
lenguaje donde los constructores pueden combinarse en todas las formas significativas.

o Uniformidad:
 Las cosas similares deben verse de forma similar y tener significados similares, y a la inversa, las
cosas diferentes se tienen que ver de forma diferente.
 Las no uniformidades son de dos tipos:
 Cosas similares no parecen ser o se no comportan de manera similar.
 Cosas no similares, parecen ser o se comportan de manera similar.
 Ejemplo de violación de este concepto puede ser:
 En C++ es necesario un punto y coma después de la definición de clase, pero está prohibido
después de la definición de una función.

class A { ... };
int f() { ... }

 El afán por hacer imponer una meta, como puedan ser la generalidad o la ortogonalidad en el diseño de un lenguaje,
puede resultar peligroso.
 Si una no regularidad no puede justificarse de forma razonable entonces se puede decir que es un error de diseño.

2.4. Principios adicionales sobre diseño de los lenguajes

 Simplicidad:
o La simplicidad parecía ser un principio fácil de lograr, pero en la práctica es asombrosamente difícil.
o No debe confundirse simplicidad con regularidad, Algol68 es uno de los lenguajes más regulares, pero no es
simple.
o Tampoco tener muy pocos constructores básicos es simplicidad, LISP y Prolog tienen unos cuantos
constructores básicos, pero dependen de un ambiente de ejecución complejo.
o Un LP demasiado simple puede hacer que la tarea de utilizarlo resulte más compleja. BASIC es un lenguaje
simple, pero la carencia de algunos constructores fundamentales (declaraciones, bloques, …) hace mucho más
difícil de programar aplicaciones grandes.
o “Todo debería hacerse tan simple como sea posible, pero no más simple”. Albert Einstein.
o La sobresimplicidad puede hacerse que el lenguaje sea difícil de utilizar, carente de expresividad, legibilidad o
seguridad y sujeto a demasiadas restricciones.
 Expresividad:
o Es la facilidad con que un lenguaje puede expresar procesos y estructuras complejas.
o Es una ayuda a la eficiencia de programación.
o Uno de los primeros adelantos en expresividad fue la adición de la recursión en los LP (LISP y Algol60)
o Puede entrar en conflicto con la simplicidad.

4 Longinos Recuero Bustos (http://longinox.blogspot.com)

 o Es una de las razones del aumento de popularidad de los lenguajes orientados a objetos.
o En ocasiones la expresividad se considera como concisa, lo que puede, sin embargo, comprometer la
legibilidad, como por ejemplo en la siguiente expresión de C:

while(*s++ == *t++);
 Extensibilidad:
o Principio que indica que debería de haber algún mecanismo general que permita al usuario añadir nuevas
características al lenguaje.
o Podría significar simplemente el añadir:
 Nuevos tipos al lenguaje.
 Nuevas funciones a una biblioteca.
 Nuevas palabras claves.
o A lo largo de los últimos 10 años la extensibilidad ha pasado a ser de importancia primordial como una
propiedad de los lenguajes. En concreto la simplicidad sin extensibilidad, prácticamente tiene garantizado el
fracaso del lenguaje.

 Capacidad de restricción:
o Un diseño de lenguaje debería dar la posibilidad de que un programador pudiera programar de una forma útil
empleando un conocimiento mínimo del lenguaje, por lo que el diseño de un lenguaje debería promover la
capacidad de definir subconjuntos del lenguaje.
o Esto resulta útil de dos maneras:
 No es necesario que el programador aprenda todo el lenguaje para utilizarlo con efectividad.
 Un escritor de compilador podría elegir implementar únicamente un subconjunto en el caso de que la
implementación de todo lenguaje resultara demasiado costosa e innecesaria.

 Consistencia ante notaciones y reglas convencionales aceptadas:

o Un LP debería ser fácil de aprender por un programador experimentado.
o Por lo tanto un lenguaje debe incorporar tantas características y conceptos posibles que se hayan convertido en
estándar.
o Ley del mínimo asombro:
 Las cosas no deberían de parecer y comportarse de manera totalmente inesperadas.
 Por ejemplo, FORTRAN ignora los espacios en blanco y esto podría viola la ley del mínimo asombro:

DO 99 I = 1.10

Pudiera parecer que se quiere ejecutar 99 veces la asignación del valor 1.10 a la variable I, cuando
en realidad lo que se hace es asignar el valor 1.10 a la variable DO99I.

 Precisión:
o A veces conocida como claridad.
o Es la existencia de una definición precisa para un lenguaje, de tal manera que el comportamiento de los
programas pueda ser predecible.
o Pasos para lograrlo:
 Publicación de un manual o informe del lenguaje por parte del diseñador.
 Adopción de un estándar emitido por una organización nacional o internacional de estándares:
 ANSI.
 ISO.
 …

5 Longinos Recuero Bustos (http://longinox.blogspot.com)

 Independencia de la máquina:
o El método primordial para lograr la independencia de la máquina es el uso de tipos de datos predefinidos que no
involucran detalles de asignación de memoria o de la arquitectura de máquina.
o Desafortunadamente, este tipo de datos no pueden nunca estar totalmente libres de problemas de la máquina.

 Seguridad:
o Este principio se basa en minimizar los errores de programación y permitir que dichos errores sean detectados e
informados.
o La seguridad está íntimamente relacionada con la confiabilidad y con la precisión.
o Este es el principio que condujo a los diseñadores del lenguaje a introducir los tipos, la verificación de tipos y las
declaraciones de variables en los lenguajes de programación.
o Con esto se puede comprometer tanto la expresividad como lo conciso del lenguaje.

6 Longinos Recuero Bustos (http://longinox.blogspot.com)