X-Git-Url: https://git.llucax.com/z.facultad/75.31/presentacion.git/blobdiff_plain/6d7a6a64987f5160f7d457cd8f6311ffb0ba1281..a1aa0c314b9356e8f406d91a2da2d1adf47a754c:/presentacion_d.lyx

diff --git a/presentacion_d.lyx b/presentacion_d.lyx
index 7893921..fdfcccc 100644
--- a/presentacion_d.lyx
+++ b/presentacion_d.lyx
@@ -35,29 +35,99 @@ Leandro Lucarella (77891)
 \layout Date
 
 30 de Mayo de 2005
+\layout Standard
+
+
+\begin_inset LatexCommand \tableofcontents{}
+
+\end_inset 
+
+
 \layout Section
 
 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
+
+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
 
-El lenguaje sigue, al día de hoy, sin estar completamente definido y con
- algunas cosas sin implementar.
+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
@@ -168,6 +238,11 @@ i
 .
 \layout Subsection
 
+
+\begin_inset LatexCommand \label{sub:Tipos-derivados}
+
+\end_inset 
+
 Tipos derivados
 \layout Standard
 
@@ -288,7 +363,7 @@ typedef
 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
 
@@ -427,6 +502,11 @@ f.mes = 5;
 f.print();
 \layout Subsubsection
 
+
+\begin_inset LatexCommand \label{sub:tipo-class}
+
+\end_inset 
+
 class
 \layout Standard
 
@@ -435,6 +515,16 @@ Las clases son la forma en la que D implementa la orientaci
  Por ahora sólo adelantaremos que es muy similar a un struct, sólo que guarda
  algo más de información de control (como la tabla virtual) para poder implement
 ar polimorfismo y herencia.
+\layout Subsubsection
+
+interface
+\layout Standard
+
+Las interfaces son un caso particular de clases, que no puede tener atributos,
+ sólo métodos.
+ Una clase puede implementar varias interfaces, por lo que esto no e es
+ más que una forma limitada de implementar herencia múltiple, eliminando
+ el problema de la representación en memoria de los datos.
 \layout Section
 
 Expresiones
@@ -450,7 +540,7 @@ Operaciones
 
 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
@@ -575,7 +665,7 @@ c1 is c3; // true
 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
 
@@ -610,6 +700,11 @@ Finalmente provee un operador de resoluci
  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
 
@@ -682,7 +777,7 @@ Las variables globales (que incluye a las est
 \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 
@@ -757,7 +852,7 @@ Las uniones ocupan en memoria, como m
 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 
@@ -772,6 +867,11 @@ Las estructuras, al igual que en C, se almacenan de forma cont
  compilador optimiza.
 \layout Subsubsection
 
+
+\begin_inset LatexCommand \label{sub:repr-class}
+
+\end_inset 
+
 class
 \layout Standard
 
@@ -830,11 +930,11 @@ Fetch
 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 
@@ -842,18 +942,138 @@ El llamado a funciones se hace a trav
 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
+
+Este lenguaje soporta punteros y referencias, aunque estas últimas son implícita
+s (el compilador decide cuando usar una referencia y cuando una copia).
+ En términos generales, las instancias de clase siempre se referencian a
+ través de una referencia (jamás se copia un objeto implícitamente).
+ Como se explicó en la sección 
+\begin_inset LatexCommand \vref{sub:Operaciones}
+
+\end_inset 
+
+, se proveen operaciones para tomar la dirección de una variable (su 
+\emph on 
+almacén
+\emph default 
+) y desreferenciamiento y aritmética de punteros.
+ Además se pueden convertir punteros de forma implícita siguiendo algunas
+ reglas.
+ Por ejemplo cualquier puntero puede ser convertido implícitamente a un
+ puntero a 
+\emph on 
+void
+\emph default 
+ (sin tipo) o a un puntero a una clase ancestro (si es una instancia de
+ clase).
+ También se ha dicho que, al igual que en C, hay una relación muy estrecha
+ entre puntero y array, por lo que cualquier array puede ser convertido
+ implícitamente a un puntero.
 \layout Subsection
 
+
+\begin_inset LatexCommand \label{sub:Recolección-de-basura}
+
+\end_inset 
+
 Recolección de basura
-\layout Subsection
+\layout Standard
+
+D provee un recolector de basura, aunque aún no hay muchas definiciones
+ con respecto a su tipo.
+ Por el tipo de API que se provee para controlar el recolector de basura,
+ parece ser del tipo 
+\emph on 
+mark-sweep
+\emph default 
+ o 
+\emph on 
+copy collection
+\emph default 
+ 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
+
+Aunque no parece haber nada definido aún con respecto al recolector de basura
+ (más que estudiar empíricamente la implementación actual o basarse en lo
+ que provee la biblioteca estándar para manipular al recolector), se menciona
+ en varios lugares que el ciclo de colección sólo puede ser lanzado cuando
+ se intenta alocar nueva memoria.
+ Es decir, que se puede confiar en que el recolector no va a interrumpir
+ la ejecución del programa en un fragmento de código en el que no se aloca
+ memoria.
+ De cualquier manera, la biblioteca estándar también provee métodos para
+ desactivar momentáneamente al recolector, por si hay partes críticas del
+ programa que no deban ser interrumpidas.
+\layout Standard
+
+Además se menciona que el ciclo de recolección debe correr solo; es decir,
+ que mientras corre el ciclo de recolección no puede haber ningún otro hilo
+ del programa corriendo al mismo tiempo (cosa que tiene mucho sentido, de
+ otra forma sería virtualmente imposible seguir el rastro de la memoria).
+\layout Subsubsection
+
+Casos límite
+\layout Standard
+
+D se enfrenta a un problema poco común en la recolección de basura, ya que
+ la mayor parte de los lenguajes que lo implementan no permiten un manejo
+ de bajo nivel de la memoria.
+ Hay varias circunstancias en las cuales el recolector de basura de D puede
+ fallar.
+ Veamos algunos casos:
+\layout LyX-Code
+
+void* p;
+\layout LyX-Code
+
+...
+\layout LyX-Code
+
+int x = cast(int)p;
+\layout Standard
+
+En este caso, el comportamiento es indefinido ya que el recolector no verifica
+ raíces que no sean punteros.
+ Otro caso:
+\layout LyX-Code
+
+void* p = cast(void*)12345678;
+\layout Standard
+
+Si por casualidad la dirección de memoria está siendo manejada por el recolector
+ de basura, estamos ante un problema.
+ Otros caso que podrían resultar un tanto confuso es que no se puede confiar
+ en que un puntero conserve la dirección a la que apunta de forma invariante,
+ ya que el recolector de basura puede moverlo.
+ Por lo tanto un código como el siguiente:
+\layout LyX-Code
+
+int* p1, p2;
+\layout LyX-Code
+
+...
+\layout LyX-Code
+
+if (p1 < p2) ...;
+\layout Standard
 
-Instrucciones
+tiene un comportamiento aleatorio.
+ Y esto sólo por nombrar algunos problemas que puede acarrear el manejo
+ de bajo nivel de la memoria usando un recolector de basura.
+ Claro que si uno necesita un manejo de tan bajo nivel, para estos casos
+ se puede usar memoria no administrada por el recolector.
 \layout Subsection
 
 
@@ -864,42 +1084,1307 @@ Instrucciones
 Rutinas
 \layout Standard
 
-Los procedimientos son un caso particular de funciones que no devuelven
- nada (void)
+D provee varios tipos de rutinas, aunque todos basado en el mismo tipo básico,
+ las funciones.
+\layout Subsubsection
+
+Funciones planas (sin contexto)
+\layout Standard
+
+Estas son las funciones más básicas.
+ 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 exactamente la cantidad de parámetros que se especifica en su declaración.
+\layout Standard
+
+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 
+\emph on 
+scope
+\emph default 
+ limitado).
+\layout Subsubsection
+
+Funciones con contexto
+\layout Standard
+
+Como ya hemos visto, en D hay algunas funciones que necesitan un 
+\emph on 
+contexto
+\emph default 
+.
+ En esta categoría caen tanto los métodos de una instancia de clase como
+ las funciones anidadas.
+\layout Standard
+
+En el caso de los métodos es muy claro y simple, además de la función, se
+ necesita saber sobre qué objeto se está aplicando, así que simplemente
+ se agrega a los parámetros declarados un puntero (o referencia) a una instancia
+ de la clase.
+\layout Standard
+
+Con las funciones anidadas puede resultar un poco más confuso.
+ Estás funciones necesitan el 
+\emph on 
+frame pointer
+\emph default 
+ de la función 
+\emph on 
+padre
+\emph default 
+ (lexicográficamente hablando) para poder obtener sus variables locales.
+ Podría pensarse entonces, como si estás funciones agregan un parámetro
+ extra con el puntero a ese 
+\emph on 
+frame pointer
+\emph default 
+.
+\layout Subsubsection
+
+Funciones virtuales
+\layout Standard
+
+Las funciones virtuales tienen la particularidad de no conocerse su dirección
+ 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,
+ la dirección de la función a llamar.
+ D provee funciones virtuales solamente como métodos de instancias de clase
+ y lo hace de forma implícita (queda en manos del compilador determinar
+ si una función debe ser virtual o no), es por esto que guarda, como se
+ explicó en la sección 
+\begin_inset LatexCommand \vref{sub:repr-class}
+
+\end_inset 
+
+, una tabla virtual, en donde se almacena el puntero a cada función virtual
+ de una clase.
+ Entonces para llamar a una función virtual, se obtiene el objeto al que
+ pertenece (
+\emph on 
+contexto
+\emph default 
+) que tiene una tabla virtual.
+ El offset de esa función en la tabla virtual sí se conoce en tiempo de
+ compilación así que simplemente se ejecuta la función apuntada por vtable+4+off
+set (el 4 es porque lo primero que se almacena en la vtable es el puntero
+ al objeto de tipo ClassInfo).
 \layout Subsubsection
 
 Pasaje de parámetros
 \layout Standard
 
-Por copia en demanda (copy on write) y objetos por referencia.
+Las funciones toman parámetros, que son siempre por copia en su implementación
+ real.
+ El pasaje por referencia se resuelve al igual que en C, utilizando punteros.
+ 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, aunque sintácticamente sea utilizada como una
+ variable común, semánticamente se comporta como un puntero.
+\layout Standard
+
+Varias veces se menciona que los parámetros se copian si hay escritura (
+\emph on 
+copy on write
+\emph default 
+) en la documentación de D, pero se comprobó empíricamente que, como se
+ especifica en la sección de manejo de memoria, la copia por demanda se
+ realiza solamente en la biblioteca estándar, no es algo que provea el lenguaje.
+\layout Subsubsection
+
+Funciones con parámetros variables
+\layout Standard
+
+Además soporta, al igual que C, parámetros variables, simplemente proveyendo
+ métodos para obtener variables de la pila arbitrariamente.
+ Es decir, a la hora de compilarse un llamado a una rutina con parámetros
+ variables, se apilan todos los parámetros, se hace el 
+\emph on 
+call
+\emph default 
+, y luego se desapilan.
+ La función llamada tiene entonces, métodos para obtener esos parámetros
+ extra que no figuraban en la declaración de la función.
 \layout Subsubsection
 
-Anidamiento
+
+\begin_inset LatexCommand \label{sub:Sobrecarga-de-funciones}
+
+\end_inset 
+
+Sobrecarga de funciones
+\layout Standard
+
+D permite sobrecargar funciones.
+ Es decir, tener 2 funciones con el mismo nombre pero distintas firmas (cantidad
+ y/o tipo de parámetros).
+ Al igual que C++, no permite sobrecargar por el tipo de retorno solamente,
+ ya que por proveer conversiones implícitas sería imposible desambiguar
+ muchos casos.
+ Por supuesto esto también debe poder traducirse a funciones planas por
+ lo que debe haber una forma de identificar unívocamente a cada función
+ (con un nombre único, asociado a su dirección de memoria).
+ Para esto se utiliza una técnica conocida como 
+\emph on 
+name mangling
+\emph default 
+, que consiste en transformar los nombres de funciones a un nombre único,
+ aunque no hay ninguna definición aún al respecto de como debe hacerlo D
+ (fundamental para poder interactuar entre distintos compiladores, ya que
+ de otra manera no podría encontrar los símbolos en código objeto compilado
+ por otro compilador).
+\layout Standard
+
+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
+\emph default 
+ para obtener su identificador único y ahora si proseguir como si fuera
+ un función común y corriente.
 \layout Section
 
 Estructura del programa
+\layout Standard
+
+La estructura general de un programa D es muy similar a la de uno en C++.
+ Simplemente se compone de funciones y tipos definidos por el usuario.
+ Existe una función especial llamada 
+\family typewriter 
+main()
+\family default 
+ que es el punto de partida del programa, indispensable a menos que estemos
+ construyendo una biblioteca.
 \layout Subsection
 
-Módulos, espacios de nombres, Interfaces
-\layout Section
+Módulos
+\layout Standard
 
-Orientación a objetos
-\layout Subsection
+D elimina el preprocesador e incorpora el concepto de módulo (a diferencia
+ de C++ que utiliza espacios de nombre).
+ El módulo tiene alcance de archivo y tiene correspondencia 1 a 1 con la
+ ruta y nombre del archivo.
+ Por ejemplo el módulo 
+\family typewriter 
+mi.primer.modulo
+\family default 
+ se busca en 
+\family typewriter 
+mi/primer/modulo.d
+\family default 
+.
+ A la ruta representada como módulo se la llama 
+\emph on 
+paquete
+\emph default 
+; es decir, el módulo 
+\family typewriter 
+modulo
+\family default 
+ pertenece al paquete 
+\family typewriter 
+mi.primer
+\family default 
+.
+ El módulo entonces provee un espacio de nombres, cuyos símbolos pueden
+ ser importados en otros módulos.
+ Por ejemplo:
+\layout Standard
+
+modulo1.d:
+\layout LyX-Code
+
+import modulo2;
+\layout LyX-Code
+
+class C
+\layout LyX-Code
+
+{
+\layout LyX-Code
+
+        float i;
+\layout LyX-Code
+
+}
+\layout LyX-Code
+
+void func(modulo2.C c)
+\layout LyX-Code
+
+{
+\layout LyX-Code
+
+        printf("c.i = %d
+\backslash 
+n", c.i);
+\layout LyX-Code
+
+}
+\layout Standard
+
+modulo2.d:
+\layout LyX-Code
+
+class C
+\layout LyX-Code
+
+{
+\layout LyX-Code
+
+        int i;
+\layout LyX-Code
+
+}
+\layout Standard
+
+modulos.d
+\layout LyX-Code
 
-TAD's
+import modulo1;
+\layout LyX-Code
+
+import modulo2;
+\layout LyX-Code
+
+int main()
+\layout LyX-Code
+
+{
+\layout LyX-Code
+
+        func(new modulo2.C);
+\layout LyX-Code
+
+        return 0;
+\layout LyX-Code
+
+}
+\layout Standard
+
+Como se puede observar, no es imperativo poner el modulo al que pertenece
+ un símbolo, a menos que se lo quiera desambiguar (si hay 2 símbolos con
+ el mismo nombre en 2 módulos distintos).
 \layout Subsection
 
-Polimorfismo
-\layout Comment
+Compilación condicional
+\layout Standard
 
-Si hay orientación a objetos y describir cómo es.
-\layout Section
+Al no proveer un precompilador, D provee un mecanismo de compilación condicional
+ 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
+ invariante de representación de una clase o de pre y post condiciones de
+ funciones.
+ Ejemplo:
+\layout LyX-Code
 
-Paralelismo / Concurrencia
-\layout Section
+version (OPTIMIZE)
+\layout LyX-Code
 
-¿Para qué no sirve este lenguaje?
-\layout Section
+{
+\layout LyX-Code
+
+    version (DEBUG) printf(
+\begin_inset Quotes eld
+\end_inset 
 
-¿Para qué sí sirve este lenguaje? 
+entrando a optimización
+\begin_inset Quotes erd
+\end_inset 
+
+);
+\layout LyX-Code
+
+    optimizar();
+\layout LyX-Code
+
+}
+\layout Standard
+
+D además provee varios identificadores de versión predefinidos, como la
+ plataforma, 
+\emph on 
+endianess
+\emph default 
+, sistema operativo, etc.
+\layout Standard
+
+Además provee otros métodos, como 
+\family typewriter 
+static if
+\family default 
+, 
+\family typewriter 
+static assert
+\family default 
+, 
+\family typewriter 
+iftype
+\family default 
+ o 
+\family typewriter 
+debug
+\family default 
+, 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
+
+D, al igual que C, permite embeber assembly en el lenguaje.
+ Esto es útil para hacer código de alta performance para fragmentos críticos,
+ ya que D está pensando como un lenguaje de alta performance y apto para
+ 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
+
+Como ya se ha mencionado, D provee orientación a objetos principalmente
+ a través de el tipo class (ver sección 
+\begin_inset LatexCommand \vref{sub:tipo-class}
+
+\end_inset 
+
+), pero provee algunos mecanismos también a través de los módulos o struct.
+\layout Subsection
+
+Abstracción
+\layout Standard
+
+La abstracción de datos puede darse a nivel de class, struct o module.
+ Ambos proveen mecanismos para poder efectuar operaciones sobre un dato
+ sin conocerlo.
+ En el caso de struct y class es exactamente igual en cuanto a abstracción.
+ El módulo es un poco diferente ya que hay sólo una instancia del mismo
+ (es decir, todos sus datos son estáticos), pero también puede servir para
+ abstraer.
+ D provee sintaxis acoplada (
+\emph on 
+bundle
+\emph default 
+) a través del operador de 
+\emph on 
+scope
+\emph default 
+ 
+\begin_inset Quotes eld
+\end_inset 
+
+.
+\begin_inset Quotes erd
+\end_inset 
+
+, que se utiliza tanto para class como para struct y module.
+ El module, al no ser un tipo en sí, no soporta sintaxis desacoplada (
+\emph on 
+unbundle
+\emph default 
+).
+ Lo mismo pasa con los métodos estáticos de clase.
+\layout Standard
+
+Todos los objetos en D son con estado explícito, aunque pueden 
+\emph on 
+emularse
+\emph default 
+ objetos 
+\emph on 
+inmutables
+\emph default 
+ declarándolos 
+\family typewriter 
+const
+\family default 
+, pero esto no hace se se resuelvan en tiempo de compilación, en realidad
+ tienen estado sólo que el compilador no deja que se modifique.
+ Es decir, no hay forma de tener abstracción declarativa.
+\layout Subsubsection
+
+Propiedades
+\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 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
+ no tome argumentos y devuelva un valor se convierte en una propiedad de
+ lectura.
+ Incluyendo ambos se pueden tener propiedades de lectura/escritura.
+ Veamos un ejemplo:
+\layout LyX-Code
+
+class C
+\layout LyX-Code
+
+{
+\layout LyX-Code
+
+        int _i;
+\layout LyX-Code
+
+        int read() { return _i; }
+\layout LyX-Code
+
+        int write(int i) { return _i = i; }
+\layout LyX-Code
+
+        int rw() { return _i; }
+\layout LyX-Code
+
+        int rw(int i) { return _i = i; }
+\layout LyX-Code
+
+}
+\layout LyX-Code
+
+int main()
+\layout LyX-Code
+
+{
+\layout LyX-Code
+
+        C c = new C;
+\layout LyX-Code
+
+        // c.read = 1; NO COMPILA
+\layout LyX-Code
+
+        c.write = 2;
+\layout LyX-Code
+
+        printf("c.read = %d
+\backslash 
+n", c.read);
+\layout LyX-Code
+
+        // printf("c.read = %d
+\backslash 
+n", c.write); NO COMPILA
+\layout LyX-Code
+
+        c.rw = 3;
+\layout LyX-Code
+
+        printf("c.rw = %d
+\backslash 
+n", c.rw);
+\layout LyX-Code
+
+        return 0;
+\layout LyX-Code
+
+}
+\layout Standard
+
+Además todos los tipos básicos poseen propiedades, algunas comunes a todos
+ (como 
+\family typewriter 
+sizeof
+\family default 
+, que devuelve su tamaño, en general estos son todos resueltos en tiempo
+ de compilación) y otros particulares de cada tipo (como 
+\family typewriter 
+length
+\family default 
+ para los array, que devuelve la cantidad de elementos que almacena).
+\layout Subsubsection
+
+Sobrecarga de operadores
+\layout Standard
+
+Otro mecanismo importante de abstracción que provee D es la sobrecarga de
+ 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 azúcar sintáctico y un caso particular de sobrecarga de funciones
+ (ver página 
+\begin_inset LatexCommand \pageref{sub:Sobrecarga-de-funciones}
+
+\end_inset 
+
+).
+\layout Subsection
+
+Seguridad
+\layout Standard
+
+D provee mecanismos de seguridad, tanto a nivel de módulo como de clase
+ y estructuras, aunque se ha comprobado empíricamente que el compilador
+ no lo está chequeando por el momento.
+ Por ejemplo, el siguiente código compila y corre:
+\layout LyX-Code
+
+class C
+\layout LyX-Code
+
+{
+\layout LyX-Code
+
+        private int i;
+\layout LyX-Code
+
+}
+\layout LyX-Code
+
+int main()
+\layout LyX-Code
+
+{
+\layout LyX-Code
+
+        C c = new C;
+\layout LyX-Code
+
+        c.i = 1;
+\layout LyX-Code
+
+        return 0;
+\layout LyX-Code
+
+}
+\layout Subsection
+
+Herencia
+\layout Standard
+
+El único tipo que permite herencia es class (y su sub-tipo interface).
+ D permite herencia simple entre clases comunes y una herencia múltiple
+ limitada a través de las interfaces.
+ Es decir, una clase sólo puede heredar de una sola clase, pero puede implementa
+r muchas interfaces.
+\layout Subsection
+
+Polimorfismo
+\layout Standard
+
+D implementa polimorfismo principalmente (pero no únicamente) a través de
+ las clases (e interfaces) y sus funciones virtuales, pero también a través
+ de la sobrecarga de funciones en general.
+\layout Subsubsection
+
+
+\begin_inset LatexCommand \label{sub:Polimorfismo-estático}
+
+\end_inset 
+
+Polimorfismo estático
+\layout Standard
+
+D provee tipos genéricos, también conocidos en el mundo de los lenguajes
+ compilados como 
+\emph on 
+templates
+\emph default 
+ o polimorfismo estático, ya que permite que una función o clase se comporte
+ 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
+
+D provee algunas pocas primitivas para el soporte de concurrencia.
+ En la biblioteca estándar provee una clase para ejecutar múltiples hilos
+ y provee en el lenguaje la palabra reservada 
+\family typewriter 
+synchronized
+\family default 
+ para agregar bloqueo y desbloqueo de exclusión mutua (
+\emph on 
+mutex
+\emph default 
+) automáticamente antes y después (respectivamente) de bloque que encierra.
+ También puede usarse como clasificador de almacén (es decir, para proteger
+ una variable) o como modificador de una función (para proteger dicha función)
+ o de clase o de cualquier otra sentencia.
+\layout Standard
+
+Es necesario utilizar la clase 
+\family typewriter 
+Thread
+\family default 
+ para ejecutar múltiples hilos ya que el recolector de basura tiene que
+ saber de todos los hilos que están corriendo para poder administrar su
+ memoria (y frenarlos ante un ciclo de recolección), aunque técnicamente
+ podría evitarse ya que se puede acceder a cualquier biblioteca de C (incluyendo
+ la de hilos).
+\layout Section
+
+
+\begin_inset LatexCommand \label{sec:Programación-segura}
+
+\end_inset 
+
+Programación segura
+\layout Standard
+
+Uno de los objetivos principales de D es implementar técnicas de programación
+ segura, para tratar de evitar (o al menos detectar) la mayor cantidad de
+ errores de manera simple.
+ Veamos entonces algunos mecanismos que provee para satisfacer este objetivo.
+\layout Subsection
+
+Programación por contrato
+\layout Standard
+
+La programación por contrato consiste en imponer ciertas reglas que se cumplan
+ en distintos momentos del programa.
+ Básicamente provee 3 conceptos para verificar estos 
+\emph on 
+contratos
+\emph default 
+: 
+\emph on 
+assert
+\emph default 
+, invariantes de representación y pre y post condiciones.
+ Esto parece contradecir el objetivo de D de ser un lenguaje de alta performance
+, ya que si se hacen muchos chequeos, inevitablemente se sacrifica performance.
+ Pero esto no es necesariamente cierto, ya que todos estos mecanismos pueden
+ ser desactivados en tiempo de compilación, logrando tener un código para
+ depuración muy robusto y lleno de chequeos y un código para producción
+ muy eficiente y rápido.
+\layout Subsubsection
+
+assert
+\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 evalúa en tiempo de ejecución que una expresión evalúe a 
+\emph on 
+true
+\emph default 
+.
+ Si no es así, simplemente el programa lanza una excepción.
+\layout Subsubsection
+
+Invariante de representación
+\layout Standard
+
+Las clases puede incluir un invariante de presentación.
+ Esto es un fragmento de código que se ejecuta cada vez que se cambia una
+ instancia de la clase (excepto cuando los cambios se realizan desde una
+ función miembro.
+ Esto permite asegurar que los objetos estén siempre en estado consistente,
+ mientras se ejecute código que no conoce su representación.
+ Por ejemplo:
+\layout LyX-Code
+
+class Fecha
+\layout LyX-Code
+
+{
+\layout LyX-Code
+
+        int dia = 1;
+\layout LyX-Code
+
+        int mes = 1;
+\layout LyX-Code
+
+        invariant
+\layout LyX-Code
+
+        {
+\layout LyX-Code
+
+                assert(1 <= dia && dia <= 31);
+\layout LyX-Code
+
+                assert(1 <= mes && mes <= 12);
+\layout LyX-Code
+
+        }
+\layout LyX-Code
+
+        void p()
+\layout LyX-Code
+
+        {
+\layout LyX-Code
+
+                int d = dia;
+\layout LyX-Code
+
+                dia = 50; // ok, dentro de la clase no se chequea
+\layout LyX-Code
+
+                dia = d;
+\layout LyX-Code
+
+                printf("%02d-%02d
+\backslash 
+n", dia, mes);
+\layout LyX-Code
+
+        }
+\layout LyX-Code
+
+}
+\layout LyX-Code
+
+Fecha f = new Fecha;
+\layout LyX-Code
+
+f.p(); // ok
+\layout LyX-Code
+
+f.dia = 40; // error!
+\layout Subsubsection
+
+Pre y post condiciones
+\layout Standard
+
+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
+
+long raiz(long x)
+\layout LyX-Code
+
+    in
+\layout LyX-Code
+
+    {
+\layout LyX-Code
+
+        assert(x >= 0);
+\layout LyX-Code
+
+    }
+\layout LyX-Code
+
+    out (result)
+\layout LyX-Code
+
+    {
+\layout LyX-Code
+
+        assert((result * result) == x);
+\layout LyX-Code
+
+    }
+\layout LyX-Code
+
+    body
+\layout LyX-Code
+
+    {
+\layout LyX-Code
+
+        return cast(long) std.math.sqrt(cast(float) x);
+\layout LyX-Code
+
+    }
+\layout Standard
+
+El parámetro del bloque 
+\family typewriter 
+out
+\family default 
+ es el valor devuelto por el cuerpo de la función.
+ Entonces cuando se llame a 
+\family typewriter 
+raiz(8)
+\family default 
+, el compilador (a menos que esté en modo 
+\emph on 
+release
+\emph default 
+) lo traducirá a:
+\layout LyX-Code
+
+assert(8 >= 0); // ok
+\layout LyX-Code
+
+long tmp = raiz(8); // devuelve 2 por la conversión a long
+\layout LyX-Code
+
+assert((2 * 2) == 8); // error!
+\layout Subsection
+
+Casos de prueba
+\layout Standard
+
+D provee dentro del lenguaje herramientas para realizar casos de prueba
+ (
+\emph on 
+unit tests
+\emph default 
+) para asegurarse que una clase se comporte como debe.
+ Este código se ejecuta cuando se inicia el programa si se compila con la
+ opción de 
+\family typewriter 
+unittest
+\family default 
+.
+ Por ejemplo:
+\layout LyX-Code
+
+class C
+\layout LyX-Code
+
+{
+\layout LyX-Code
+
+        unittest
+\layout LyX-Code
+
+        {
+\layout LyX-Code
+
+                assert(ok());
+\layout LyX-Code
+
+        }
+\layout LyX-Code
+
+        static bit ok() { return false; }
+\layout LyX-Code
+
+}
+\layout Standard
+
+Un programa que use esta clase saldrá apenas se inicia con una excepción
+ por el 
+\family typewriter 
+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