Introducción
\layout Standard
-El lenguaje de programación D fue concebido en el año 1999 como una reingeniería
- de C y C++, que apunta a un lenguaje compilado de alto rendimiento pero
- con un nivel un poco más alto que C o C++.
- D pretende ser compatible con C (al menos a nivel de código objeto), pero
-
+El lenguaje de programación D fue concebido en el año 1999 como una re-ingenierí
+a de C y C++ y siguen en la actualidad sin estar completamente definido
+ y con algunas cosas sin implementar.
+ Este lenguaje es compilado y de alto rendimiento pero con un nivel un poco
+ más alto que C o C++ (pero sin sacrificar la posibilidad de hacer cosas
+ de bajo nivel y muy eficientes).
+ D es compatible binariamente con C, pero
\series bold
no
\series default
con C++.
\layout Standard
-Una de las cosas más importantes que elimina D es el preprocesador de C,
- poniendo la funcionalidad necesaria directamente en el compilador (incluyendo
- manejo de módulos, compilación condicional, etc.).
+Uno de los principales objetivos de D es ser un lenguaje de programación
+ multi-paradigma, poniendo mucho énfasis en la practicidad (no pretende
+ ser un lenguaje académico estrictamente atado a un paradigma en particular).
+ También pone mucho énfasis en la programación segura (a pesar de dejar
+ bajar a un nivel muy bajo, al punto de poder embeber assembly, tiene muchas
+ herramientas para detectar y evitar errores).
+\layout Subsection
+
+
+\begin_inset LatexCommand \label{sub:Objetivo-del-lenguaje}
+
+\end_inset
+
+Objetivo del lenguaje
\layout Standard
-El lenguaje sigue, al día de hoy, sin estar completamente definido y con
- algunas cosas sin implementar.
+D, oficialmente, tiene los siguientes objetivos:
+\layout Itemize
+
+Reducir el costo de desarrollo en al menos un 10% agregando características
+ que mejoren la productividad y ajustando las características del lenguaje
+ para que los errores más comunes que más cuestan reparar sean evitados
+ de base.
+\layout Itemize
+
+Hacer más fácil escribir programas portables entre compiladores, arquitecturas
+ y sistemas operativos.
+\layout Itemize
+
+Soportar programación multi-paradigma; es decir, como mínimo, soportar los
+ paradigmas: imperativo, estructurado, orientado a objetos y programación
+ genérica.
+\layout Itemize
+
+Tener una curva de aprendizaje corta para programadores que se sienten a
+ gusto con C o C++.
+\layout Itemize
+
+Proveer acceso irrestricto de bajo nivel cuando sea necesario.
+\layout Itemize
+
+Hacer que implementar un compilador sea mucho más sencillo que para C++.
+\layout Itemize
+
+Ser compatible con la ABI
+\begin_inset Foot
+collapsed false
+
+\layout Standard
+
+Application Binary Interface, i.e.
+ mantener compatibilidad a nivel de código objeto con C.
+\end_inset
+
+ local de C.
+\layout Itemize
+
+Tener gramática libre de contexto.
+\layout Itemize
+
+Escribir fácilmente aplicaciones internacionalizadas.
+\layout Itemize
+
+Incorporar Programación por Contrato y metodologías de casos de prueba.
+\layout Itemize
+
+Ser capaz de construir programas independientes y livianos.
\layout Section
Sistema de tipos
.
\layout Subsection
+
+\begin_inset LatexCommand \label{sub:Tipos-derivados}
+
+\end_inset
+
Tipos derivados
\layout Standard
typedef es similar al alias, con la salvedad de que define un tipo semánticament
e distinto (por más que la estructura en memoria y la forma de manejarlo
sea idéntica).
- Como concecuencia de esto, se efectua chequeo de tipos y, por ejemplo,
+ Como consecuencia de esto, se efectúa chequeo de tipos y, por ejemplo,
no puedo asignar a una variable de un tipo que es un typedef de otro:
\layout LyX-Code
D provee las operaciones básicas que provee prácticamente cualquier lenguaje:
asignación, comparación, incremento, decremento, suma, resta, multiplicación,
- división, resto, algebra booleana (and, or, xor, not), shifting.
+ división, resto, álgebra booleana (and, or, xor, not), shifting.
\layout LyX-Code
int i = 1 << 1; // 0001b << 1 == 0010b == 2
c1 == c2; // true
\layout Standard
-y algunas operaciones propias de los arrays y hashes (array asociatios),
+y algunas operaciones propias de los arrays y hashes (array asociativos),
como para saber si existe una clave o concatenación y slicing de arrays.
\layout LyX-Code
definidas dentro de tipos compuestos (como estructuras o uniones) o módulos.
\layout Subsection
+
+\begin_inset LatexCommand \label{sub:Variables}
+
+\end_inset
+
Variables
\layout Standard
\emph on
libre
\emph default
- que se le pide al sistema operativo a medida que se nececesita (heap).
+ que se le pide al sistema operativo a medida que se necesita (heap).
Una particularidad extra de D es que los tipos definidos por el usuario
de tipo
\series bold
struct
\layout Standard
-Las estructuras, al igual que en C, se almacenan de forma contínua ocupando,
+Las estructuras, al igual que en C, se almacenan de forma continua ocupando,
como mínimo,
\begin_inset Formula $\sum S_{i}$
\end_inset
Incrementar IP
\layout Enumerate
-Executar instrucción
+Ejecutar instrucción
\layout Standard
El llamado a funciones se hace a través de la pila, ya que soporta recursión
- y hay una pila por cada hilo, ya que soporta multiples hilos.
+ y hay una pila por cada hilo, ya que soporta múltiples hilos.
Además de la cadena dinámica (para el llamado recursivo) tiene cadena estática,
ya que soporta funciones anidadas, con el modelo estático, que busca las
variables en el
padre estructural
\emph default
de la función y no en la función apilada inmediatamente arriba.
-\layout Comment
-
-Mencionar operaciones básicas: asignación, jump, push, pop, call, return
\layout Subsection
+
+\begin_inset LatexCommand \label{sub:Punteros}
+
+\end_inset
+
Punteros
\layout Standard
implícitamente a un puntero.
\layout Subsection
+
+\begin_inset LatexCommand \label{sub:Recolección-de-basura}
+
+\end_inset
+
Recolección de basura
\layout Standard
\emph on
copy collection
\emph default
- ya que se proveen funciones para agregar raices y también parece implementar
+ ya que se proveen funciones para agregar raíces y también parece implementar
algún tipo de algoritmo generacional ya que además de proveer un método
para realizar una recolección completa, provee uno para realizar una recolecció
n generacional.
\layout Standard
En este caso, el comportamiento es indefinido ya que el recolector no verifica
- raices que no sean punteros.
+ raíces que no sean punteros.
Otro caso:
\layout LyX-Code
Son funciones de nivel 0 (en cuanto a anidamiento) o estáticas (ya sean
anidadas o de clase), por lo que no necesitan de un contexto (cadena estática)
más que la ubicación de la porción de variables globales (estáticas).
- Toman exáctamente la cantidad de parámetros que se especifica en su declaración.
+ Toman exactamente la cantidad de parámetros que se especifica en su declaración.
\layout Standard
-Por supuesto estás funciones tienen acceso sólamente a las variables estáticas
+Por supuesto estás funciones tienen acceso solamente a las variables estáticas
(conocidas en tiempo de compilación y almacenadas en el bloque de datos
del programa), ya sean variables estáticas locales de una función o variables
estáticas de clase (recordar que son todas variables globales con un
\layout Standard
Las funciones virtuales tienen la particularidad de no conocerse su dirección
- de memoria en tiempo de compilación, por lo tante es necesario agragar
+ de memoria en tiempo de compilación, por lo tanto es necesario agregar
un nivel de indirección al llamarlas.
Es por esto también que es imposible que exista algún tipo de función virtual
sin contexto, ya que debe haber algún contexto que indique, como mínimo,
Hay un caso muy particular en D, que son las clases, que siempre son pasadas
por referencias.
Es decir, una variable de clase (que referencia una instancia de una clase)
- es siempre de tipo puntero, auque sintácticamente sea utilizada como una
+ es siempre de tipo puntero, aunque sintácticamente sea utilizada como una
variable común, semánticamente se comporta como un puntero.
\layout Standard
por otro compilador).
\layout Standard
-Entonces el compilador, a la hora de evualuar la dirección de una función
+Entonces el compilador, a la hora de evaluar la dirección de una función
sobrecargada, debe fijarse su nombre y sus parámetros, hacer el
\emph on
name mangling
\layout Standard
Al no proveer un precompilador, D provee un mecanismo de compilación condicional
- directamente incluída en el lenguaje.
- Simplemente se agregan bloques de código que se compilan sólamente si se
+ directamente incluida en el lenguaje.
+ Simplemente se agregan bloques de código que se compilan solamente si se
le pasa un cierto parámetro al compilador indicando que porción compilar.
Este concepto va un poco más allá, ya que hay compilación condicional incluso
de bloques no son puestos explícitamente como tales, como los bloques de
, pero son todas vueltas de tuerca sobre el mismo concepto.
\layout Subsection
+
+\begin_inset LatexCommand \label{sub:Assembly-embebido}
+
+\end_inset
+
Assembly embebido
\layout Standard
el desarrollo de aplicaciones de sistema (como controladores, etc).
\layout Section
+
+\begin_inset LatexCommand \label{sec:Orientación-a-objetos}
+
+\end_inset
+
Orientación a objetos
\layout Standard
D provee un mecanismo muy interesante y práctico, las propiedades.
Una clase (o estructura) puede tener métodos especiales que pueden ser
llamados como si fueran atributos de la clase.
- No es más que azucar sintáctico pero es muy útil y está implementado de
+ No es más que azúcar sintáctico pero es muy útil y está implementado de
una forma muy simple.
Cualquier método que tenga un sólo argumento y devuelva un valor del mismo
tipo se convierte en una propiedad de escritura y cualquier método que
operadores.
Se puede sobrecargar los operadores de clases y estructuras, de manera
tal de hacerlos ver sintácticamente como tipos nativos del lenguaje.
- También es azucar sintáctico y un caso particular de sobrecarga de funciones
+ También es azúcar sintáctico y un caso particular de sobrecarga de funciones
(ver página
\begin_inset LatexCommand \pageref{sub:Sobrecarga-de-funciones}
de la sobrecarga de funciones en general.
\layout Subsubsection
+
+\begin_inset LatexCommand \label{sub:Polimorfismo-estático}
+
+\end_inset
+
Polimorfismo estático
\layout Standard
de distinta manera pero se resuelve en tiempo de compilación.
\layout Section
+Excepciones
+\layout Standard
+
+D provee un mecanismo de manejo de excepciones, con la sintaxis clásica
+ de tipo
+\family typewriter
+try-catch-finally
+\family default
+.
+ D, al igual que C++, dice que el manejo de excepciones puede no ser
+\emph on
+performance-critical
+\emph default
+, ya que debe manejar sólo casos muy esporádicos, situaciones inesperadas.
+ D es más consistente en el uso de excepciones que C++, ya que utiliza excepcion
+es en muchos lugares en la biblioteca estándar, cosa que C++ no suele hacer
+ y por lo cual el manejo de excepciones en ese lenguaje no suele ser muy
+ utilizado.
+\layout Standard
+
+Sin embargo no hay mucho más definido en D que la sintaxis del manejo de
+ excepciones, nada se define sobre el mecanismo (excepto en Windows, donde
+ dice que respeta la
+\emph on
+Microsoft Windows Structured Exception Handling
+\emph default
+).
+ Es por eso que me limitaré a ejemplificar el manejo de excepciones a un
+ ejemplo nada más:
+\layout LyX-Code
+
+int main()
+\layout LyX-Code
+
+{
+\layout LyX-Code
+
+ try
+\layout LyX-Code
+
+ {
+\layout LyX-Code
+
+ try
+\layout LyX-Code
+
+ {
+\layout LyX-Code
+
+ throw new Exception("first");
+\layout LyX-Code
+
+ }
+\layout LyX-Code
+
+ finally
+\layout LyX-Code
+
+ {
+\layout LyX-Code
+
+ printf("finally
+\backslash
+n");
+\layout LyX-Code
+
+ throw new Exception("second");
+\layout LyX-Code
+
+ }
+\layout LyX-Code
+
+ }
+\layout LyX-Code
+
+ catch(Exception e)
+\layout LyX-Code
+
+ {
+\layout LyX-Code
+
+ printf("catch %.*s
+\backslash
+n", e.msg);
+\layout LyX-Code
+
+ }
+\layout LyX-Code
+
+ printf("done
+\backslash
+n");
+\layout LyX-Code
+
+}
+\layout Standard
+
+Los bloques
+\emph on
+try-catch-finally
+\emph default
+ pueden estar anidados.
+\layout Section
+
Paralelismo / Concurrencia
\layout Standard
la de hilos).
\layout Section
+
+\begin_inset LatexCommand \label{sec:Programación-segura}
+
+\end_inset
+
Programación segura
\layout Standard
Este es el tipo más básico de contrato, provisto también de una forma más
primitiva por C (a través del precompilador).
- Simplemente evalua en tiempo de ejecución que una expresión evalue a
+ Simplemente evalúa en tiempo de ejecución que una expresión evalúe a
\emph on
true
\emph default
Pre y post condiciones
\layout Standard
-Toda función puede tener, además de su cuerpo, un bloque de código de precondici
-ones y/o un bloque de código de postcondiciones, que será ejecutado antes
+Toda función puede tener, además de su cuerpo, un bloque de código de pre-condic
+iones y/o un bloque de código de post-condiciones, que será ejecutado antes
y/o después de ejecutar la función (respectivamente).
Veamos un ejemplo:
\layout LyX-Code
assert
\family default
.
+\layout Section
+
+Conclusiones
+\layout Standard
+
+Para analizar si el lenguaje cumple sus objetivos, vamos a analizar esos
+ objetivos (ver página
+\begin_inset LatexCommand \pageref{sub:Objetivo-del-lenguaje}
+
+\end_inset
+
+) punto por punto.
+ Para el análisis se asume que todo lo propuesto en el lenguaje está correctamen
+te implementado (que, como vimos a lo largo de este documento, no es necesariame
+nte cierto).
+\layout Paragraph
+
+Reducir el costo de desarrollo en al menos un 10% agregando características
+ que mejoren la productividad y ajustando las características del lenguaje
+ para que los errores más comunes que más cuestan reparar sean evitados
+ de base.
+\layout Standard
+
+Es difícil evaluar la ganancia en el costo de desarrollo (más aún si no
+ está claro en comparación a qué se quiere reducir el costo), pero sin dudas
+ el disponer de un recolector de basura, propiedades y otras muchas característi
+cas muy deseables deben reducir de forma considerable el costo de desarrollo.
+\layout Standard
+
+Con respecto a los mecanismos para evitar los errores más comunes, por lo
+ que he probado del lenguaje parece cumplirlo bastante bien, si uno se toma
+ el trabajo de utilizar todas las herramientas que se le provee, en particular
+ de las comentadas en la sección
+\begin_inset LatexCommand \vref{sec:Programación-segura}
+
+\end_inset
+
+.
+\layout Standard
+
+En términos generales podría decirse que sí, cumple este objetivo.
+\layout Itemize
+
+Hacer más fácil escribir programas portables entre compiladores, arquitecturas
+ y sistemas operativos.
+\layout Paragraph
+
+Soportar programación multi-paradigma; es decir, como mínimo, soportar los
+ paradigmas: imperativo, estructurado, orientado a objetos y programación
+ genérica.
+\layout Standard
+
+Definitivamente cumple con estos objetivos mínimos, es un lenguaje netamente
+ imperativo, con soporte de estructuras y todos los requerimientos de la
+ programación orientada a objetos (a través de las clases, ver sección
+\begin_inset LatexCommand \vref{sec:Orientación-a-objetos}
+
+\end_inset
+
+).
+ Además provee un mecanismo para programación genérica, a través de templates
+ (ver sección
+\begin_inset LatexCommand \vref{sub:Polimorfismo-estático}
+
+\end_inset
+
+).
+\layout Paragraph
+
+Tener una curva de aprendizaje corta para programadores que se sienten a
+ gusto con C o C++.
+\layout Standard
+
+Aunque tiene varias diferencias con C y C++, la sintaxis es muy similar
+ y su uso en general también.
+ Particularmente encuentro bastante molesto y confuso que las instancias
+ de clase se manejen por referencia (en realidad encuentro confuso que sean
+ una excepción).
+ A pesar de esto, sin dudas la curva de aprendizaje es corta (aunque no
+ nula), así que creo que este objetivo también lo cumple satisfactoriamente.
+\layout Paragraph
+
+Proveer acceso irrestricto de bajo nivel cuando sea necesario.
+\layout Standard
+
+Definitivamente también lo cumple.
+ Soporta punteros (pág.
+
+\begin_inset LatexCommand \pageref{sub:Punteros}
+
+\end_inset
+
+), assembly embebido (pág.
+
+\begin_inset LatexCommand \pageref{sub:Assembly-embebido}
+
+\end_inset
+
+), alocación de memoria manual (pág.
+
+\begin_inset LatexCommand \pageref{sub:Variables}
+
+\end_inset
+
+), control sobre el recolector de basura (pág.
+
+\begin_inset LatexCommand \pageref{sub:Recolección-de-basura}
+
+\end_inset
+
+), etc.
+\layout Paragraph
+
+Hacer que implementar un compilador sea mucho más sencillo que para C++.
+\layout Standard
+
+Esto tampoco puede ser evaluado certeramente de forma sencilla, pero viendo
+ como se simplificaron varias características de C++ que son particularmente
+ complicadas de implementar (como la herencia múltiple) es de esperarse
+ que hacer un compilador de D sea más sencillo que uno de C++, pero no podría
+ afirmarlo porque tampoco conozco las complicaciones que adhiere D con las
+ características no presentes en C++, como para saber cómo sale en el balance.
+\layout Paragraph
+
+Ser compatible con la ABI local de C.
+\layout Standard
+
+Lo cumple, puede interactuar con C sin inconvenientes.
+\layout Paragraph
+
+Tener gramática libre de contexto.
+\layout Standard
+
+Tampoco es algo que haya podido probar de forma sería, pero se eliminan
+ construcciones de C que dependían del contexto como
+\family typewriter
+(foo) - p;
+\family default
+ que en C/C++ puede ser interpretado como la resta de
+\family typewriter
+ p
+\family default
+ a
+\family typewriter
+foo
+\family default
+ si
+\family typewriter
+ foo
+\family default
+ es una variable o como
+\family typewriter
+-p
+\family default
+
+\emph on
+casteado
+\emph default
+ a
+\family typewriter
+foo
+\family default
+ si
+\family typewriter
+foo
+\family default
+ es un tipo definido por el usuario.
+ En D esa expresión es la resta, ya que para hacer el
+\emph on
+cast
+\emph default
+ hay que usar el operador:
+\family typewriter
+cast(foo) - p
+\family default
+.
+\layout Standard
+
+Entonces, si bien no puedo asegurar que el objetivo esté cumplido, sí puedo
+ asegurar que está más cercano a tener una gramática menos dependiente del
+ contexto que C/C++.
+\layout Paragraph
+
+Escribir fácilmente aplicaciones internacionalizadas.
+\layout Standard
+
+Tengo la sensación de haber visto en algún momento que había una forma de
+ poner literales de string internacionalizables en el lenguaje, con el siguiente
+ formato:
+\family typewriter
+_
+\begin_inset Quotes erd
+\end_inset
+
+hola
+\begin_inset Quotes erd
+\end_inset
+
+
+\family default
+.
+ Esa característica parece que no existe más, al menos en la documentación,
+ así que realmente no veo de qué manera se cumple este objetivo.
+\layout Paragraph
+
+Incorporar Programación por Contrato y metodologías de casos de prueba.
+\layout Standard
+
+Lo cumple muy bien, utilizando todo lo visto en la sección
+\begin_inset LatexCommand \vref{sec:Programación-segura}
+
+\end_inset
+
+.
+\layout Paragraph
+
+Ser capaz de construir programas independientes y livianos.
+\layout Standard
+
+Los programas son sin dudas menos livianos e independientes que los de C,
+ porque además de depender de la biblioteca estándar de C (aunque no depende
+ necesariamente, la biblioteca estándar de D la usa extensivamente), depende
+ de la biblioteca propia de D, que incluye al código del recolector de basura.
+ Compilando estáticamente, un programa que no hace nada:
+\layout LyX-Code
+
+int main()
+\layout LyX-Code
+
+{
+\layout LyX-Code
+
+ return 0;
+\layout LyX-Code
+
+}
+\layout Standard
+
+su versión en C y C++ ocupan 460KB, mientras que la versión en D ocupa 1.2MB.
+\layout Standard
+
+Sin embargo, si hacemos el clásico ejemplo de
+\emph on
+hello world
+\emph default
+:
+\layout LyX-Code
+
+int main()
+\layout LyX-Code
+
+{
+\layout LyX-Code
+
+ printf("hola mundo!
+\backslash
+n");
+\layout LyX-Code
+
+ return 0;
+\layout LyX-Code
+
+}
+\layout Standard
+
+Si la versión en C++ la escribimos usando la STL
+\begin_inset Foot
+collapsed false
+
+\layout Standard
+
+Standard Template Library (la biblioteca estándar de C++)
+\end_inset
+
+:
+\layout LyX-Code
+
+#include <iostream>
+\layout LyX-Code
+
+int main()
+\layout LyX-Code
+
+{
+\layout LyX-Code
+
+ std::cout << "hola mundo!
+\backslash
+n";
+\layout LyX-Code
+
+ return 0;
+\layout LyX-Code
+
+}
+\layout Standard
+
+En C sigue ocupa 461KB, en D sigue ocupando 1.2MB y la versión en C++ pasa
+ a ocupar 1.1MB, lo que pone en evidencia la alta complejidad de la biblioteca
+ estándar de C++.
+\layout Standard
+
+Por lo tanto, si bien D no puede ser tan liviano como C, sí puede sacarle
+ una buena ventaja a C++ en lo que es el manejo de
+\emph on
+strings
+\emph default
+ u otras estructuras que provee la STL en C++ que son muy complejas.
\the_end
projects / z.facultad / 75.31 / presentacion.git / commitdiff