Reutilización de Contenedores Parametrizables con Lenguajes de Semántica Limitada

En el día

Tribunal de la tesis

      El tribunal fue nombrado por el Rector de la Universidad, Maestro Guillermo Malavassi, y propuesto por el Director del Instituto de Enseñanza y Posgrado (IEPI), Maestro Mario Granados Moreno.

Resumen       En esta disertación se contesta afirmativamente la siguiente pregunta: ¿Es posible implementar contenedores polimórficos si el lenguaje no tiene apoyo directo para parametrización? El alcanzar esta meta es muestra de que las avanzadas construcciones sintácticas que se han utilizado en varios lenguajes de alto nivel no son la única forma de construir bibliotecas de componentes reutilizables. Por eso se muestra cómo es posible reutilizar con eficiencia la implementación Pascal de varios contenedores, pese a que Pascal es un lenguaje que no cuenta con plantillas ni con paquetes genéricos. Como base para encontrar métodos que mejoren la reutilización de contenedores, también se ha hecho un análisis de las facilidades de abstracción que ofrecen los lenguajes de programación.       El aporte principal de este trabajo consiste en utilizar de mejor manera el lenguaje, para aumentar significativamente la reutilización de componentes de programación. Para eso se ha hecho un exhaustivo estudio de las cualidades de los contenedores y de los objetos que en ellos están almacenados, para luego obtener bibliotecas que muestran las ventajas que se obtendrían de una implementación que use polimorfismo uniforme, sin pagar un alto precio en uso de memoria o de velocidad de ejecución, ni requerir que el lenguaje usado tenga plantillas o paquetes genéricos. No se ha hecho énfasis en proponer nuevas construcciones sintácticas para aumentar la expresividad de los lenguajes de programación, de manera que el programador pueda usar parametrización y polimorfismo en sus programas, pues ya los lenguajes de alto nivel más utilizados las tienen.       Dos objetivos muy importantes se alcanzan al implementar los contenedores siguiendo las ideas desarrolladas en esta investigación. Primero, la reutilización se da a nivel del código compilado, y segundo, se evita distribuir los códigos fuente de los algoritmos. Al alcanzar estos dos objetivos, se allana el camino para que luego sea posible incluir dentro del sistema operativo, como un servicio adicional, una biblioteca de contenedores que pueda ser compartida por todos los programas, lo que ayudará a mejorar la eficiencia de los sistemas de cómputo. Esto no es posible si la reutilización de contenedores se continúa haciendo en la forma tradicional, usando parametrización textual.       Se incluye la implementación del módulo Pascal Binder.pas, que sirve para reutilizar con comodidad contenedores, entre ellos la lista. También se han hecho pruebas para mostrar que es aceptable la eficiencia de los contenedores parametrizados usando los métodos aquí expuestos.       Las ideas desarrolladas en esta investigación han sido implementadas en el lenguaje Pascal, pero los principios aquí enunciados son aplicables a otras plataformas, en especial al lenguaje C++. Por eso, estas técnicas sirven para sugerir mejores formas de utilizar la expresividad adicional, respecto de Pascal, de lenguajes como Ada y C++, para obtener mejores bibliotecas sin sacrificar la eficiencia de los programas.

Abstract Reuse of Parameterized Containers in Limited Semantic Languages       In this dissertation we answer positively the following question: Is it possible to implement polymorphic containers using a language that lacks support for parameterization? Reaching this goal can show that the advanced syntactic constructs used in high level languages are not the only way to obtain reusable software components. This is why it is shown how to reuse with efficiency several containers implemented in Pascal, even though Pascal is a language that lacks both templates and generic packages. As the basis for improving container reuse, an analysis of abstraction facilities in programming languages has been done.       The main contribution in this work is to put the language to a better use, to improve software reuse. For this, an exhaustive study of containers and their stored values has been carried out, to obtain libraries that exhibit the benefits of an implementation where uniform polymorphism was used, without paying a high price in either memory usage or program speed, nor requiring the language to support either templates or generic packages. No emphasis was put on proposing new syntactic constructs to augment the expressiveness of computer languages, to support either parameterization or polymorphism, as the more popular high level languages already have them.       When implementing containers using the ideas developed in this research two important goals are reached. First, software reuse is achieved at the level of compiled code, and second, distribution of the reused algorithms' source code is avoided. Achieving these two goals clears the way to later include in the operating system, at a later time and as another service, a library of containers that can be shared among programs, to improve the efficiency of computing systems. This is not possible when software reuse is done the traditional way, using textual parameterization.       The implementation of the Pascal module Binder.pas is included. It is the basis to reuse containers with ease, including the list. Tests have been run to show that the efficiency of containers parameterized using the methods developed here is acceptable.       The ideas in this work were developed in the context of the Pascal language, but the principles developed can be applied to other languages, especially C++. This is why these techniques can be applied to put to a better use the additional expressiveness that languages, such as Ada or C++, have with respect to Pascal, without decreasing program performance.

Dedicatoria

Agradecimientos

      En nuestras conversaciones, mi amigo Joseph Bannister siempre me ha inducido a terminar mi trabajo de doctorado. Le agradezco a José Ronald Argüello, con quien he tenido muchas diferencias a lo largo de años de trabajo, el haberse tomado el riesgo de dirigirme en esta investigación.

      Mi esposa Norma constantemente me impulsó a continuar. No sólo me dio apoyo financiero, que mucho ayuda siempre, sino que supo convencerme de continuar cada vez que yo encontraba una excusa para dedicarme a otra cosa. Sin ella, yo nunca habría llegado al final, y por ella lo he hecho.

Índice general

• 1. Introducción
• 2. Antecedentes
• 3. Abstracción en Pascal
• 4. Operaciones básicas
• 5. Operaciones básicas de un contenedor
• 6. Operaciones básicas de un iterador
• 7. Parametrización de contenedores
• 8. Análisis de resultados
• 9. Conclusión

Tabla de contenidos

[-]	Tribunal de la tesis		[-]	Índice		[-]	Tabla de contenidos
[-]	Resumen		[-]	Dedicatoria		[-]	Bibliografía
[-]	Abstract		[-]	Agradecimientos		[-]	Referencia

• 1. Introducción
  • 1.1 Motivación
  • 1.2 Enfoque general
  • 1.3 Ventajas de usar Pascal
  • 1.4 Mezcla de inglés y español
  • 1.5 Organización de la disertación
  • 1.6 Guía de lectura
• 2. Antecedentes
  • 2.1 Contexto histórico
  • 2.2 Estado del arte
  • 2.3 Diferencias de este trabajo
• 3. Abstracción en Pascal
  • 3.1 Generalidades
  • 3.2 Procedimientos y funciones
  • 3.3 Tipos Abstractos de Datos
  • 3.4 Contenedores
  • 3.5 Iteradores
  • 3.6 Herencia
  • 3.7 Parametrización
  • 3.8 Polimorfismo
  • 3.9 Excepciones
• 4. Operaciones básicas
  • 4.1 Init(o)
  • 4.2 Clear(o)
  • 4.3 Erase(o)
  • 4.4 Done(o)
  • 4.5 Copy(x,y)
  • 4.6 Clone(o,p)
  • 4.7 Move(x,y)
  • 4.8 Swap(x,y)
  • 4.9 Equal(x,y)
  • 4.10 Less(x,y)
  • 4.11 OK(o)
  • 4.12 Fix(o)
  • 4.13 Store(o,F)
  • 4.14 Load(o,F)
  • 4.15 Print(o,F)
  • 4.16 Read(o,F)
  • 4.17 Get(o,v)
  • 4.18 Put(o,v)
• 5. Operaciones básicas de un contenedor
  • 5.1 Empty(C)
  • 5.2 Full(C)
  • 5.3 Count(C)
  • 5.4 Behave(C,b,sw)
  • 5.5 Behaviour(C,b)
  • 5.6 Insert(C,p,o)
  • 5.7 Remove(C,p)
  • 5.8 Find(C,o)
  • 5.9 Valid(C,p)
  • 5.10 Retrieve(C,p)
  • 5.11 Next(C,p)
  • 5.12 Prev(C,p)
• 6. Operaciones básicas de un iterador
  • 6.1 I.Init()
  • 6.2 I.Bind(C)
  • 6.3 I.Finished()
  • 6.4 I.Current()
  • 6.5 I.Next()
  • 6.6 I.Advance()
  • 6.7 I.From(p)
  • 6.8 I.Range(p,q)
  • 6.9 I.Done()
• 7. Parametrización de contenedores
  • 7.1 Fundamentos
  • 7.2 La unidad Binder.pas
  • 7.3 El contenedor Lista parametrizable
  • 7.4 El contenedor Árbol parametrizable
  • 7.5 Iteradores parametrizables
  • 7.6 Parametrizador de plantillas CTPinst
  • 7.7 Uso de los valores almacenados en el contenedor
  • 7.8 El contenedor Vector parametrizable
  • 7.9 Apoyo del compilador para parametrizar contenedores
• 8. Análisis de resultados
  • 8.1 Comparación de estilos de codificación
  • 8.2 Requerimientos
  • 8.3 Limitaciones
  • 8.4 Análisis de rendimiento
  • 8.5 Ventajas y cualidades de Binder.pas
  • 8.6 Enseñanza de la Parametrización
• 9. Conclusión
  • 9.1 Contribuciones de esta disertación
  • 9.2 Direcciones futuras de investigación

Acerca del autor

Adolfo Di Mare <adolfo@di-mare.com>

Acerca de este documento