From: Leandro Lucarella <llucax@gmail.com>
Date: Mon, 22 Jun 2009 00:29:15 +0000 (-0300)
Subject: Corregir ortografía, errores de tipeo, etc.
X-Git-Tag: entrega-2010-10-08~37
X-Git-Url: https://git.llucax.com/z.facultad/75.00/informe.git/commitdiff_plain/4dec75812c56a0e0c6fb8d305349d32a09df10b0

Corregir ortografía, errores de tipeo, etc.

Corregir varios errores de ortografía, anglisismos (que paradógicamente es
un anglisismo), errores de tipeo y otros detalles de estilo.
---

diff --git a/source/d.rst b/source/d.rst
index 2105e79..35591d4 100644
--- a/source/d.rst
+++ b/source/d.rst
@@ -2,7 +2,7 @@
 .. Introducción y breve reseña del lenguaje de programación D. También
    se presentan las necesidades particulares de D con respecto al
    recolector de basura y su estado actual.
-   ESTADO: TERMINADO
+   ESTADO: TERMINADO, CORREGIDO
 
 
 .. _d_lang:
@@ -138,7 +138,7 @@ por C++, pudiendo extraer de él los mejores conceptos pero evitando sus
 mayores problemas también.
 
 Otra gran diferencia con C++ es la facilidad para ser analizado
-gramaticalmente (*parsing*), ya fue especialmente diseñado para ser sencillo
+sintácticamente (*parsing*), ya fue especialmente diseñado para ser sencillo
 y a diferencia de C y C++ su gramática es independiente del contexto
 (*context-free grammar*). Esto permite que D pueda ser compilado en pequeños
 pasos bien separados:
@@ -204,7 +204,7 @@ y meta-programación:
 
 Inferencia de tipos básica implícita y explícita (mediante ``typeof``):
    si no se especifica un tipo al declarar una variable, se infiere del tipo
-   de su inicializador.
+   de su valor de inicialización.
 
    Ejemplo::
 
@@ -237,7 +237,7 @@ Iteración sobre colecciones (``foreach``):
          total += i;
 
 *Templates*:
-   clases y funciones pueden ser parametrizadas. Esto permite desarrollar
+   clases y funciones pueden ser generalizadas. Esto permite desarrollar
    algoritmos genéricos sin importar el tipo de los datos de entrada, siempre
    y cuando todos los tipos tengan una *interfaz* común.   Esto también es
    conocido como *polimorfismo en tiempo de compilación*, y es la forma más
@@ -249,11 +249,11 @@ Iteración sobre colecciones (``foreach``):
       auto i = sumar!(int)(5, 6);    // i == 11
       auto f = sumar!(float)(5, 6); // j == 11.0f
 
-   Además se pueden definir bloques de declaraciones parametrizados (esto no
+   Además se pueden definir bloques de declaraciones generalizadas (esto no
    es posible en C++), permitiendo instanciar dicho bloque con parámetros
    particulares. Esto sirve como un mecanismo para la reutilización de código,
    ya que puede incluirse un mismo bloque en distintos lugares (por ejemplo
-   clases). Un bloque parametrizado puede verse como una especie de módulo.
+   clases). Un bloque generalizado puede verse como una especie de módulo.
 
    Ejemplo::
 
@@ -265,10 +265,10 @@ Iteración sobre colecciones (``foreach``):
       bloque!(int, float).x = 5;
       float f = bloque!(int, float).foo(7);
 
-   La utilidad más prominente de los bloques parametrizados se da al
+   La utilidad más prominente de los bloques generalizados se da al
    acompañarse de *mixins*.
 
-Instanciación implícita de funciones parametrizadas:
+Instanciación implícita de funciones generalizadas:
    el lenguaje es capaz de deducir los parámetros siempre que no hayan
    ambigüedades
 
@@ -334,8 +334,8 @@ Cantidad de parámetros variables para *templates*:
    si una función cumple ciertas reglas básicas (como por ejemplo no tener
    efectos colaterales) puede ser ejecutada en tiempo de compilación en vez de
    tiempo de ejecución. Esto permite hacer algunos cálculos que no cambian de
-   ejecución en ejecución al momento de compilar, mejorando la performance
-   o permitiendo formas avanzadas de metaprogramación. Esta característica se
+   ejecución en ejecución al momento de compilar, mejorando el rendimiento
+   o permitiendo formas avanzadas de meta-programación. Esta característica se
    vuelve particularmente útil al combinarse con *string mixins*.
 
    Ejemplo::
@@ -491,7 +491,7 @@ Objetos y arreglos *livianos*:
 Rendimiento:
    la :ref:`d_generic` permite realizar muchas optimizaciones ya que se
    resuelve en tiempo de compilación y por lo tanto aumentando la
-   *performance* en la ejecución.
+   rendimiento en la ejecución.
 
 Número de punto flotante de 80 bits:
    El tipo ``real`` de D_ tiene precisión de 80 bits si la plataforma lo
@@ -517,11 +517,11 @@ Control de alineación de miembros de una estructura:
 Programación de alto nivel
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Programa de alto nivel se refiere a construcciones más avanzadas que un loop.
-Expresiones semánticamente más ricas que permiten mayor expresividad al
-programador o le permiten focalizarse de mejora manera en los algoritmos
-independizándose del *hardware* o de como funciona una computadora. Es
-exactamente el opuesto a :ref:`d_low_level`.
+Programación de alto nivel se refiere a construcciones más avanzadas que una
+sentencia para iterar; expresiones con una semántica más ricas que permiten
+mayor expresividad al programador o le permiten focalizarse de mejora manera
+en los algoritmos independizándose del *hardware* o de como funciona una
+computadora. Es exactamente el opuesto a :ref:`d_low_level`.
 
 En general estas características tiene como efecto secundario una mejora de la
 productividad de los programadores. D_ adopta herramientas de muchos lenguajes
@@ -695,7 +695,7 @@ características más salientes se encuentran:
 
 Objetos *pesados*:
    objetos polimórficos como los de cualquier lenguaje con orientación real
-   a objetos. Estos objetos poseen una tabla virtual para *dispatch* dinámico,
+   a objetos. Estos objetos poseen una tabla virtual para despacho dinámico,
    todos los métodos son virtuales a menos que se indique lo contrario
    y tienen semántica de referencia [#drefsem]_. Estos objetos tienen un
    *overhead* comparados a los objetos *livianos* pero aseguran una semántica
@@ -879,7 +879,7 @@ Diseño por contrato:
 
    D_ implementa las siguientes formas de diseño por contrato (todas se
    ejecutan siempre y cuando no se compile en modo *release*, de manera de no
-   sacrificar *performance* cuando es necesario):
+   sacrificar rendimiento cuando es necesario):
 
    Pre y post condiciones:
       Ejemplo::
@@ -953,10 +953,10 @@ Inicialización garantizada:
 
    Ejemplo::
 
-      double d;         // inicializado a NaN
-      int x;             // inicializado a 0
-      Fecha f;          // inicializado a null
-      byte[5] a;       // inicializados todos los valores a 0
+      double d;      // inicializado a NaN
+      int x;         // inicializado a 0
+      Fecha f;       // inicializado a null
+      byte[5] a;     // inicializados todos los valores a 0
       long l = void; // NO inicializado (explícitamente)
 
 *RAII* (*Resource Adquisition Is Initialization*):
@@ -995,17 +995,17 @@ Guardias de bloque (*scope guards*):
       int f(Lock lock) {
          lock.lock();
          scope (exit)
-            lock.unlock();                  // ejecutado siempre que salga de f()
+            lock.unlock();              // ejecutado siempre que salga de f()
          auto trans = new Transaccion;
          scope (success)
-            trans.commit();                // ejecutado si sale con "return"
+            trans.commit();             // ejecutado si sale con "return"
          scope (failure)
-            trans.rollback();             // ejecutado si sale por una excepción
+            trans.rollback();           // ejecutado si sale por una excepción
          if (condicion)
-            throw Exception("error"); // ejecuta lock.unlock() y trans.rollback()
+            throw Exception("error");   // lock.unlock() y trans.rollback()
          else if (otra_condicion)
-            return 5;                         // ejecuta lock.unlock() y trans.commit()
-         return 0;                            // ejecuta lock.unlock() y trans.commit()
+            return 5;                   // lock.unlock() y trans.commit()
+         return 0;                      // lock.unlock() y trans.commit()
       }
 
    Esta es una nueva forma de poder escribir código *exception-safe*, aunque
diff --git a/source/dgc.rst b/source/dgc.rst
index 11d0c0c..4d91f8e 100644
--- a/source/dgc.rst
+++ b/source/dgc.rst
@@ -4,7 +4,7 @@
    de recolección de basura en dicho lenguaje (se explica por qué las
    particularidades descriptas en la sección anterior complican la
    recolección de basura y cuales son las que más molestan).
-   ESTADO: TERMINADO
+   ESTADO: TERMINADO, CORREGIDO
 
 
 .. _dgc:
@@ -63,8 +63,8 @@ mismas (o más) limitaciones.
 El control sobre la alineación de memoria es otra complicación sobre el
 recolector de basura, incluso aunque éste sea conservativo. Dado que tratar la
 memoria de forma conservativa byte a byte sería impracticable (tanto por la
-cantidad de falsos positivos que esto provocaría como por el impacto en la
-eficiencia por el exceso de posibles punteros a revisar, además de lo
+cantidad de falsos positivos que esto provocaría como por el impacto en el
+rendimiento por el exceso de posibles punteros a revisar, además de lo
 ineficiente que es operar sobre memoria no alineada), en general el recolector
 asume que el usuario nunca va a tener la única referencia a un objeto en una
 estructura no alineada al tamaño de palabra.
@@ -127,7 +127,7 @@ Orientación a objetos y finalización
 D_ soporta el paradigma de orientación a objetos, donde es común permitir que
 un objeto, al ser destruido, realice alguna tarea de finalización (a través de
 una función miembro llamada *destructor*, o ``~this()`` en D_). Esto significa
-que el recolector, al encontrar que un objeto no es más referenciados, debe
+que el recolector, al encontrar que no hay más referencias a un objeto, debe
 ejecutar el destructor.
 
 La especificación dice:
@@ -149,7 +149,7 @@ a otros objetos en un destructor.
 
 Esta restricción en realidad se ve relaja con el soporte de *RAII*. Si se
 utiliza la palabra clave ``scope`` al crear una serie de objetos, estos serán
-destruídos determinísticamente al finalizar el *scope* actual en el orden
+destruidos determinísticamente al finalizar el *scope* actual en el orden
 inverso al que fueron creados y, por lo tanto, un usuario podría hacer uso de
 los atributos que sean referencias a otros objetos creados con ``scope`` si el
 orden en que fueron creados (y por lo tanto en que serán destruidos) se lo
@@ -182,7 +182,7 @@ formas de mejorarlo.
 Como se mencionó en la sección :ref:`d_lang`, en D_ hay dos bibliotecas base
 para soportar el lenguaje (*runtimes*): Phobos_ y Tango_. La primera es la
 biblioteca estándar de D_, la segunda un proyecto más abierto y dinámico que
-surgió como alternativa a Phobos_ debido a que Phobos_ es muy desprolija y que
+surgió como alternativa a Phobos_ debido a que Phobos_ es muy descuidada y que
 era muy difícil impulsar cambios en ella. Ahora Phobos_ tiene el agravante de
 estar *congelada* en su versión 1 (solo se realizan correcciones de errores).
 
@@ -220,7 +220,7 @@ Organización del *heap*
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 La memoria del *heap* está organizada en *pools*. Un *pool* es una región de
-*páginas* contíguas. Una página es, en general, la unidad mínima de memoria que
+*páginas* contiguas. Una página es, en general, la unidad mínima de memoria que
 maneja un sistema operativo con soporte de memoria virtual. Cada página dentro
 de un *pool* sirve a su vez como contenedora de bloques (llamados *bin* en la
 :ref:`implementación <dgc_impl>`) de tamaño fijo. Todos los bloques
@@ -231,7 +231,7 @@ pertenecientes a la misma página tienen el mismo tamaño de bloque (ver figura
 o celdas en general se ubican en estos bloques (en uno del tamaño más pequeño
 que haya que sea suficientemente grande como para almacenar dicho objeto).  En
 caso de que un objeto sea mayor a una página, se utilizan la menor cantidad de
-páginas contíguas de un pool que tengan espacio suficiente para almacenar
+páginas contiguas de un pool que tengan espacio suficiente para almacenar
 dicho objeto.
 
 .. [#dgcpageplus] Además existe otro tamaño de bloque especial que se utiliza
@@ -342,7 +342,7 @@ Cada *pool* tiene la siguiente información asociada:
    *pool*.
 
 *pages*:
-   bloque de memoria contíguo de tamaño ``PAGE_SIZE * number_of_pages``
+   bloque de memoria contiguo de tamaño ``PAGE_SIZE * number_of_pages``
    (siendo ``PAGE_SIZE`` el tamaño de página, que normalmente son 4096 bytes).
 
 
@@ -353,7 +353,7 @@ Se trata del tamaño de los bloques que almacena esta página.
 
 Una página siempre almacena bloques del mismo tamaño, que pueden ser 16, 32,
 64, 128, 256, 512, 1024, 2048 o 4096 (llamado con el nombre especial
-``PAGE``). Además hay dos tamaños de bloque símbólicos que tienen un
+``PAGE``). Además hay dos tamaños de bloque simbólicos que tienen un
 significado especial:
 
 ``FREE``:
@@ -405,7 +405,7 @@ Objetos grandes
 ^^^^^^^^^^^^^^^
 El recolector de basura actual de D_ trata de forma diferente a los objetos
 grandes. Todo objeto grande empieza en un bloque con tamaño ``PAGE``
-y (opcionalmente) continúa en los bloques contíguos subsiguientes que tengan
+y (opcionalmente) continúa en los bloques contiguos subsiguientes que tengan
 el tamaño de bloque ``CONTINUATION`` (si el objeto ocupa más que una página).
 El fin de un objeto grande queda marcado por el fin del *pool* o una página
 con tamaño de bloque distinto a ``CONTINUATION`` (lo que suceda primero).
@@ -439,7 +439,7 @@ organización del *heap* que se explicó en la sección anterior.
 
 Recolección
 ^^^^^^^^^^^
-A grandes razgos el algoritmo de recolección puede resumirse de las dos fases
+A grandes rasgos el algoritmo de recolección puede resumirse de las dos fases
 básicas de cualquier algoritmo de :ref:`marcado y barrido <gc_mark_sweep>`::
 
    function collect() is
@@ -482,7 +482,7 @@ pausan y reanudan todos los hilos respectivamente::
       foreach thread in threads
          thread.resume()
 
-La función ``clear_mark_scan_bits()`` se encarga de resetear todos los
+La función ``clear_mark_scan_bits()`` se encarga de restablecer todos los
 atributos *mark* y *scan* de cada bloque del *heap*::
 
    function clear_mark_scan_bits() is
@@ -497,7 +497,7 @@ La función ``mark_free_lists()`` por su parte se encarga de activar el bit
 de marcado (que es iterativa y realiza varias pasadas sobre **todo** el
 *heap*, incluyendo las celdas libres) no visite las celdas libres perdiendo
 tiempo sin sentido y potencialmente manteniendo *vivas* celdas que en
-realdidad son *basura* (falsos positivos)::
+realidad son *basura* (falsos positivos)::
 
    function mark_free_lists() is
       foreach free_list in heap
@@ -540,9 +540,9 @@ los threads para terminar de marcar el *root set*::
 Dado que D_ soporta manejo de memoria manual al mismo tiempo que memoria
 automática, es posible que existan celdas de memoria que no estén en el *root
 set* convencional ni en el *heap* del recolector. Para evitar que se libere
-alguna celda que estaba siendo referenciada desde memoria administrada por el
-usuario, éste debe informarle al recolector sobre la existencia de estoas
-nuevas raíces. Es por esto que para concluir el marcado del *root set*
+alguna celda a la cual todavía existen referencias desde memoria administrada
+por el usuario, éste debe informarle al recolector sobre la existencia de
+estas nuevas raíces. Es por esto que para concluir el marcado del *root set*
 completo se procede a marcar las raíces definidas por el usuario::
 
    function mark_user_roots() is
@@ -588,12 +588,12 @@ celdas para visitar (con el bit *scan* activo)::
                               mark(pointer)
 
 Aquí puede verse, con un poco de esfuerzo, la utilización de la
-:ref:`abtracción tricolor <gc_intro_tricolor>`: todas las celdas alcanzables
+:ref:`abstracción tricolor <gc_intro_tricolor>`: todas las celdas alcanzables
 desde el *root set* son pintadas de *gris* (tienen los bits *mark* y *scan*
 activados), excepto aquellas celdas atómicas (es decir, que se sabe que no
 tienen punteros) que son marcadas directamente de *negro*. Luego se van
 obteniendo celdas del conjunto de las *grises*, se las pinta de *negro* (es
-decir, se desactiva el big *scan*) y se pintan todas sus *hijas* de *gris* (o
+decir, se desactiva el bit *scan*) y se pintan todas sus *hijas* de *gris* (o
 *negro* directamente si no tienen punteros). Este procedimiento se repite
 mientras el conjunto de celdas *grises* no sea vacío (es decir, que
 ``more_to_scan`` sea ``true``).
@@ -624,8 +624,8 @@ utilizadas en la fase de marcado::
                      return [pool, page, block_start]
       return [null, null, null]
 
-Cabe destacar que la función ``find_block()`` devuelve el pool, la página y el
-comienzo del bloque al que apunta el puntero, es decir, soporta punteros
+Cabe destacar que la función ``find_block()`` devuelve el *pool*, la página
+y el comienzo del bloque al que apunta el puntero, es decir, soporta punteros
 *interiores*.
 
 
@@ -695,7 +695,7 @@ grandes de ser necesario)::
 
 Esta reorganización de listas libres además mejoran la localidad de
 referencia y previenen la fragmentación. La localidad de referencia se ve
-mojorada debido a que asignaciones de memoria proximas en el tiempo serán
+mejorada debido a que asignaciones de memoria próximas en el tiempo serán
 también próximas en espacio porque pertenecerán a la misma página (al menos si
 las asignaciones son todas del mismo tamaño). La fragmentación se minimiza por
 el mismo efecto, primero se asignarán todos los bloques de la misma página.
@@ -720,7 +720,7 @@ recolector actual.
 Asignación de memoria
 ^^^^^^^^^^^^^^^^^^^^^
 La asignación de memoria del recolector es relativamente compleja, excepto
-cuando se asgina un objeto pequeño y ya existe algún bloque con el tamaño
+cuando se asigna un objeto pequeño y ya existe algún bloque con el tamaño
 preciso en la lista de libres. Para el resto de los casos la cantidad de
 trabajo que debe hacer el recolector para asignar la memoria es considerable.
 
@@ -744,7 +744,7 @@ La función ``find_block_size()`` sencillamente busca el tamaño de bloque se
 mejor se ajuste al tamaño solicitado (es decir, el bloque más pequeño lo
 suficientemente grande como para poder almacenar el tamaño solicitado). Una
 vez más el algoritmo distingue objetos grandes de pequeños. Los pequeños se
-asginan de las siguiente manera::
+asignan de las siguiente manera::
 
       function new_small(block_size) is
          block = find_block_with_size(block_size)
@@ -831,7 +831,7 @@ grande::
          return pages[0]
 
 De forma similar a la asignación de objetos pequeños, se intenta encontrar una
-serie de páginas contíguas, dentro de un mismo *pool*, suficientes para
+serie de páginas contiguas, dentro de un mismo *pool*, suficientes para
 almacenar el tamaño requerido y si esto falla, se realizan diferentes pasos
 y se vuelve a intentar. Puede observarse que, a diferencia de la asignación de
 objetos pequeños, si luego de la recolección no se pudo encontrar lugar
@@ -852,7 +852,7 @@ completamente libres::
             heap.remove(pool)
 
 Volviendo a la función ``new_big()``, para hallar una serie de páginas
-contíguas se utiliza el siguiente algoritmo::
+contiguas se utiliza el siguiente algoritmo::
 
       function find_pages(number_of_pages) is
          foreach pool in heap
@@ -862,7 +862,7 @@ contíguas se utiliza el siguiente algoritmo::
          return null
 
 Como se dijo, las páginas deben estar contenidas en un mismo *pool* (para
-tener la garantía de que sean contíguas), por lo tanto se busca *pool* por
+tener la garantía de que sean contiguas), por lo tanto se busca *pool* por
 *pool* dicha cantidad de páginas libres consecutivas a través del siguiente
 algoritmo::
 
@@ -894,7 +894,7 @@ propaga hasta la función ``new()`` que lanza una excepción.
 Liberación de memoria
 ^^^^^^^^^^^^^^^^^^^^^
 La liberación de la memoria asignada puede hacerse explícitamente. Esto
-saltéa el mecanismo de recolección, y es utilizado para dar soporte a menejo
+saltea el mecanismo de recolección, y es utilizado para dar soporte a manejo
 explícito de memoria asignada en el *heap* del recolector. En general el
 usuario no debe utilizar liberación explícita, pero puede ser útil en casos
 muy particulares::
@@ -939,7 +939,7 @@ Detalles de implementación
 Hay varias diferencias a nivel de implementación entre lo que se presentó en
 las secciones anteriores y como está implementado realmente el recolector
 actual. Con los conceptos e ideas principales del ya explicadas, se procede
-a ahondar con más detalle en como está construído el recolector y algunas de
+a ahondar con más detalle en como está construido el recolector y algunas de
 sus optimizaciones principales.
 
 Vale aclarar que el recolector de basura actual está implementado en D_.
@@ -1008,7 +1008,7 @@ facilitar la comprensión):
       tratar de asignar memoria no se puede hallar celdas libres en el *heap*
       del recolector, se pide más memoria al sistema operativo sin correr una
       recolección para intentar recuperar espacio. Esto es particularmente
-      útil para secciones de un programa donde la eficiencia es crítica y no
+      útil para secciones de un programa donde el rendimiento es crítico y no
       se pueden tolerar grandes pausas como las que puede provocar el
       recolector.
 
@@ -1104,7 +1104,7 @@ La estructura ``Pool`` está compuesta por los siguientes atributos (ver figura
 Como se observa, además de la información particular del *pool* se almacena
 toda la información de páginas y bloques enteramente en el *pool* también.
 Esto simplifica el manejo de que lo es memoria *pura* del *heap*, ya que queda
-una gran porción contínua de memoria sin estar intercalada con
+una gran porción continua de memoria sin estar intercalada con
 meta-información del recolector.
 
 Para poder acceder a los bits de un bloque en particular, se utiliza la
@@ -1130,16 +1130,16 @@ un puntero al primer elemento de la lista en particular.
 
 La implementación utiliza a los bloques de memoria como nodos directamente.
 Como los bloques siempre pueden almacenar una palabra (el bloque de menor
-tamaño es de 16 bytes y una palabra ocupa comunmente entre 4 y 8 bytes según
+tamaño es de 16 bytes y una palabra ocupa comúnmente entre 4 y 8 bytes según
 se trabaje sobre arquitecturas de 32 o 64 bits respectivamente), se almacena
 el puntero al siguiente en la primera palabra del bloque.
 
 
 Algoritmos
 ^^^^^^^^^^
-Los algoritmos en la implementación real están considerablemente menos
-modularizados que los presentados en la sección :ref:`dgc_algo`. Por ejemplo,
-la función ``collect()`` es una gran función de 300 líneas de código.
+Los algoritmos en la implementación real son considerablemente menos modulares
+que los presentados en la sección :ref:`dgc_algo`. Por ejemplo, la función
+``collect()`` es una gran función de 300 líneas de código.
 
 A continuación se resumen las funciones principales, separadas en categorías
 para facilitar la comprensión. Los siguientes son métodos de la estructura
@@ -1303,17 +1303,17 @@ para facilitar la comprensión. Los siguientes son métodos de la estructura
       guarda los registros en el *stack* y llama a ``fullcollect()``. El
       algoritmo presentado en :ref:`dgc_algo_mark` es simbólico, ya que si los
       registros se apilaran en el *stack* dentro de otra función, al salir de
-      esta se volverían a desapilar, por lo tanto debe ser hecho en la misma
+      esta se volverían a des-apilar, por lo tanto debe ser hecho en la misma
       función ``collect()`` o en una función que luego la llame (como en este
       caso).
 
    *fullcollect(stackTop)*:
-      realiza la recolección de basura. Es análoga a ``collect()`` pero
-      considerablemente menos modularizada, todos los pasos se hacen
-      directamente en esta función: marcado del *root set*, marcado iterativo
-      del *heap*, barrido y reconstrucción de la lista de libres. Además
-      devuelve la cantidad de páginas que se liberaron en la recolección, lo
-      que permite optimizar levemente la función ``bigAlloc()``.
+      realiza la recolección de basura. Es análoga a ``collect()`` pero es
+      considerablemente menos modular, todos los pasos se hacen directamente
+      en esta función: marcado del *root set*, marcado iterativo del *heap*,
+      barrido y reconstrucción de la lista de libres. Además devuelve la
+      cantidad de páginas que se liberaron en la recolección, lo que permite
+      optimizar levemente la función ``bigAlloc()``.
 
 
 Finalización
@@ -1332,7 +1332,7 @@ y proveer finalización asegurada puede ser muy deseable.
 Memoria *encomendada*
 ^^^^^^^^^^^^^^^^^^^^^
 El algoritmo actual divide un *pool* en dos áreas: memoria *encomendada*
-(*committed* en inglés) y *no-encomentada*. Esto se debe a que originalmente
+(*committed* en inglés) y *no-encomendada*. Esto se debe a que originalmente
 el compilador de D_ DMD_ solo funcionaba en Microsoft Windows y este sistema
 operativo puede asignar memoria en dos niveles. Por un lado puede asignar al
 proceso un espacio de memoria (*address space*) pero sin asignarle la memoria
@@ -1385,7 +1385,7 @@ modernas que pueden observarse en el estado del arte (como :ref:`regiones
 <gc_free_list>`), es relativamente sofisticada. El esquema de *pools*
 y bloques permite disminuir considerablemente los problemas de *fragmentación*
 de memoria y evita búsquedas de *huecos* que pueden ser costosas (como
-*best-fit* [#dgcbestfit]_) o desperdiciar mucho especio (como *first-fit*
+*best-fit* [#dgcbestfit]_) o desperdiciar mucho espacio (como *first-fit*
 [#dgcfirstfit]_), logrando un buen equilibrio entre velocidad y espacio
 desperdiciado.
 
@@ -1419,7 +1419,7 @@ cada pasada se realiza por sobre todo el *heap*).
 
 Conjuntos de bits para indicadores
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-El algoritmo cláscio propone almacenar en la propia celda la marca (para la
+El algoritmo clásico propone almacenar en la propia celda la marca (para la
 fase de marcado) y otros indicadores. El algoritmo del recolector actual
 utiliza conjuntos de bits. Esto trae dos ventajas principales:
 
@@ -1428,7 +1428,7 @@ utiliza conjuntos de bits. Esto trae dos ventajas principales:
   de información.
 
 * Mejora la localidad de referencia, ya que los indicadores se escriben de
-  forma muy compacta y en una región de memoria contígua que generalmente
+  forma muy compacta y en una región de memoria contigua que generalmente
   puede entrar en el cache o en pocas páginas de memoria acelerando
   considerablemente la fase de marcado.
 
@@ -1441,7 +1441,7 @@ Problemas y limitaciones
 
 A continuación se presentan los principales problemas encontrados en la
 implementación actual del recolector de basura de D_. Estos problemas surgen
-principalmente de la observación del código y de aproximadamente 3 años de
+principalmente de la observación del código y de aproximadamente tres años de
 participación y observación del grupo de noticias, de donde se obtuvieron los
 principales problemas percibidos por la comunidad que utiliza el lenguaje.
 
@@ -1451,7 +1451,7 @@ Complejidad del código y documentación
 El análisis del código fue muy complicado debido a la falta de documentación
 y desorganización del código. Además se nota que el recolector ha sido escrito
 en una fase muy temprana y que a ido evolucionando a partir de ello de forma
-desprolija y sin ser rescrito nunca para aprovechar las nuevas características
+descuidada y sin ser rescrito nunca para aprovechar las nuevas características
 que el lenguaje fue incorporando (por ejemplo *templates*).
 
 Estos dos problemas (código complicado y falta de documentación) producen un
@@ -1553,9 +1553,9 @@ Se recuerda que la semántica de dicha función es la misma que la de la funció
 ``new_big()`` presentada en :ref:`dgc_algo_alloc`.
 
 Además, como se comentó en la sección anterior, los algoritmos en la
-implementación real están considerablemente menos modularizados que los
-presentados en la sección :ref:`dgc_algo`. Por ejemplo, la función
-``fullcollect()`` son 300 líneas de código.
+implementación real son considerablemente menos modulares que los presentados
+en la sección :ref:`dgc_algo`. Por ejemplo, la función ``fullcollect()`` son
+300 líneas de código.
 
 
 Memoria *encomendada*
@@ -1571,16 +1571,16 @@ discutible.
 
 Precisión
 ^^^^^^^^^
-Este fue historicamente uno de los problemas principales del recolector de D_
+Este fue históricamente uno de los problemas principales del recolector de D_
 [NGD46407]_ [NGD35364]_. Sin embargo, desde que, en la versión 1.001, se ha
 incorporado la capacidad de marcar un bloque como de datos puros (no contiene
 punteros, el atributo ``NO_SCAN``) [NGA6842]_, la gravedad de esos problemas ha
-disminuído considerablemente, aunque siguieron reportándose problemas más
+disminuido considerablemente, aunque siguieron reportándose problemas más
 esporádicamente [NGD54084]_ [NGL13744]_.
 
 De todas maneras queda mucho lugar para mejoras, y es un tema recurrente en el
 grupo de noticias de D_ y se han discutido formas de poder hacer que, al menos
-el *heap* sea preciso [NGD44607]_ [NGD29291]_. Además se mostro un interés
+el *heap* sea preciso [NGD44607]_ [NGD29291]_. Además se mostró un interés
 general por tener un recolector más preciso [NGDN87831]_, pero no han habido
 avances al respecto.
 
@@ -1624,7 +1624,7 @@ memoria [NGD75952]_ [NGDN87831]_.
 Además se ha mostrado un interés por tener un nivel de concurrencia aún mayor
 en el recolector, para aumentar la concurrencia en ambientes *multi-core* en
 general pero en particular para evitar grandes pausas en programas con
-requerimientos de tiempo real, historicamente una de las principales críticas
+requerimientos de tiempo real, históricamente una de las principales críticas
 al lenguaje [NGDN87831]_ [NGL3937]_ [NGD22968]_ [NGA15246]_ [NGD5622]_
 [NGD2547]_ [NGD18354]_.
 
@@ -1648,26 +1648,26 @@ un recolector que de este tipo de garantías [NGD88298]_.
 
 Además los objetos pueden ser finalizados tanto determinísticamente
 (utilizando ``delete`` o ``scope``; ver secciones :ref:`d_low_level`
-y :ref:`d_dbc`) como no deterministicamente (cuando son finalizados por el
+y :ref:`d_dbc`) como no determinísticamente (cuando son finalizados por el
 recolector). En el primer caso se puede, por ejemplo, acceder sus atributos
 u otra memoria que se conozca *viva*, mientras que en el segundo no. Sin
 embargo un destructor no puede hacer uso de esta distinción, haciendo que la
 finalización determinística tenga a fines prácticos las mismas restricciones
-que la finalización no deterministica. Es por esto que se ha sugerido permitir
+que la finalización no determinística. Es por esto que se ha sugerido permitir
 al destructor distinguir estos dos tipos de finalización [NGD89302]_.
 
 
 Eficiencia
 ^^^^^^^^^^
-La eficiencia en general del recolector es una de las críticas frecuentes. Si
+El rendimiento en general del recolector es una de las críticas frecuentes. Si
 bien hay muchos problemas que han sido resueltos, en especial por la inclusión
 de un mínimo grado de precisión en la versión 1.001, en la actualidad se
 siguen encontrando en el grupo de noticias críticas respecto a esto
 [NGD43991]_ [NGD67673]_ [NGD63541]_ [NGD90977]_.
 
-La principal causa de la ineficiencia del recolector actual es, probablemente,
-lo simple de su algoritmo principal de recolección. Más allá de una
-organización del *heap* moderadamente apropiada y de utilizar conjuntos de
+La principal causa del bajo rendimiento del recolector actual es,
+probablemente, lo simple de su algoritmo principal de recolección. Más allá de
+una organización del *heap* moderadamente apropiada y de utilizar conjuntos de
 bits para la fase de marcado, el resto del algoritmo es casi la versión más
 básica de marcado y barrido. Hay mucho lugar para mejoras en este sentido.
 
@@ -1699,7 +1699,7 @@ Conjuntos de bits para indicadores:
    desperdiciados en bits inutilizados).
 
 Repetición de código:
-   Hay algunos fragmentos de código repetidos inecesariamente. Por ejemplo en
+   Hay algunos fragmentos de código repetidos innecesariamente. Por ejemplo en
    varios lugares se utilizan arreglos de tamaño variable que se implementan
    repetidas veces (en general como un puntero al inicio del arreglo más el
    tamaño actual del arreglo más el tamaño de la memoria total asignada
@@ -1708,7 +1708,7 @@ Repetición de código:
 Uso de señales:
    el recolector actual utiliza las señales del sistema operativo ``SIGUSR1``
    y ``SIGUSR2`` para pausar y reanudar los hilos respectivamente. Esto
-   puede traer incovenientes a usuarios que desean utilizar estas
+   puede traer inconvenientes a usuarios que desean utilizar estas
    señales en sus programas (o peor aún, si interactúan con bibliotecas
    de C que hacen uso de estas señales) [NGD5821]_.
 
diff --git a/source/gc.rst b/source/gc.rst
index a221059..ef01f69 100644
--- a/source/gc.rst
+++ b/source/gc.rst
@@ -2,7 +2,7 @@
 .. Introducción a la importancia de la recolección de basura y sus
    principales técnicas, con sus ventajas y desventajas. También se da
    un breve recorrido sobre el estado del arte.
-   ESTADO: TERMINADO
+   ESTADO: TERMINADO, CORREGIDO
 
 
 .. _gc:
@@ -66,12 +66,12 @@ recolectores de basura (aunque no se limitaron a este lenguaje las
 investigaciones).
 
 En las primeras implementaciones de recolectores de basura la penalización en
-la eficiencia del programa se volvía prohibitiva para muchas aplicaciones. Es
+el rendimiento del programa se volvía prohibitiva para muchas aplicaciones. Es
 por esto que hubo bastante resistencia a la utilización de recolectores de
 basura, pero el avance en la investigación fue haciendo que cada vez sea una
-alternativa más viable al manejo manual de memoria, incluso para apliaciones
-con altos requerimientos de eficiencia. En la actualidad un programa que
-utiliza un recolector moderno puede ser comparable en eficiencia con uno que
+alternativa más viable al manejo manual de memoria, incluso para aplicaciones
+con altos requerimientos de rendimiento. En la actualidad un programa que
+utiliza un recolector moderno puede ser comparable en rendimiento con uno que
 utiliza un esquema manual. En particular, si el programa fue diseñado con el
 recolector de basura en mente en ciertas circunstancias puede ser incluso más
 eficiente que uno que hace manejo explícito de la memoria. Muchos recolectores
@@ -181,11 +181,11 @@ puede no ser evitable (incluso cuando el programador no cometa errores) en
 lenguajes de programación que requieran un recolector de basura conservativo.
 
 Por último, siendo que el recolector de basura es parte del programa de forma
-indirecta, es común ver en la literatura que se direfencia entre
-2 partes del programa, el recolector de basura y el programa en sí. Dado que
-para el recolector de basura, lo único que interesa conocer del programa en
-sí son los cambios al grafo de conectividad de las celdas, normalmente se lo
-llama *mutator* (mutador).
+indirecta, es común ver en la literatura que se diferencia entre dos partes
+del programa, el recolector de basura y el programa en sí. Dado que para el
+recolector de basura, lo único que interesa conocer del programa en sí son los
+cambios al grafo de conectividad de las celdas, normalmente se lo llama
+*mutator*.
 
 
 
@@ -322,7 +322,7 @@ casos de que el grafo contenga ciclos [#gccycle]_. De forma similar a la
 búsqueda, que puede realizarse *primero a lo ancho* (*breadth-first*)
 o *primero a lo alto* (*depth-first*) del grafo, el marcado de un grafo
 también puede realizarse de ambas maneras. Cada una podrá o no tener efectos
-en la eficiencia, en particular dependiendo de la aplicación puede convenir
+en el rendimiento, en particular dependiendo de la aplicación puede convenir
 uno u otro método para lograr una mejor localidad de referencia.
 
 .. [#gccycle] Un ciclo es un camino donde el *vértice inicial* es el mismo
@@ -330,7 +330,7 @@ uno u otro método para lograr una mejor localidad de referencia.
    completamente arbitrarios, ya que cualquier *vértice interior* puede ser un
    *vértice terminal*.
 
-Un algoritmo simple (recursivo) de marcado *primero a lo alto*  puede ser el
+Un algoritmo simple (recursivo) de marcado *primero a lo alto* puede ser el
 siguiente (asumiendo que partimos con todos los vértices sin marcar)
 [#gcpseudo]_::
 
@@ -598,8 +598,8 @@ Muchos algoritmos utilizan tres colores para realizar el marcado. El tercer
 color, gris generalmente, indica que una celda debe ser visitada. Esto permite
 algoritmos :ref:`concurrentes <gc_concurrent>` e :ref:`incrementales
 <gc_inc>`, además de otro tipo de optimizaciones.  Entonces, lo que plantea
-esta abtracción es una nueva partición del heap al momento de marcar, esta vez
-son 3 porciones: blanca, gris y negra.
+esta abstracción es una nueva partición del heap al momento de marcar, esta
+vez son tres porciones: blanca, gris y negra.
 
 Al principio todas las celdas se pintan de blanco, excepto el *root set* que
 se punta de gris. Luego se van obteniendo celdas del conjunto de las grises
@@ -818,14 +818,14 @@ inicial* es el mismo que el *vértice final*.
 Cuando esto sucede, las celdas que participan del ciclo tienen siempre su
 contador mayor que 0, sin embargo puede no haber ningún elemento del *root
 set* que apunte a una celda dentro del ciclo, por lo tanto el ciclo es
-*basura* (al igual que cualquier otra celda que sea referenciada por el ciclo
-pero que no tenga otras referencias externas) y sin embargo los contadores no
-son 0. Los ciclos, por lo tanto, *rompen* la invariante del conteo de
-referencia.
+*basura* (al igual que cualquier otra celda para la cual hayan referencias
+desde el ciclo pero que no tenga otras referencias externas) y sin embargo los
+contadores no son 0. Los ciclos, por lo tanto, violan la invariante del conteo
+de referencia.
 
 Hay formas de solucionar esto, pero siempre recaen en un esquema que va por
 fuera del conteo de referencias puro. En general los métodos para solucionar
-esto son variados y van desde realizar un marcado del subgrafo para detectar
+esto son variados y van desde realizar un marcado del sub-grafo para detectar
 nodos hasta tener otro recolector completo de *emergencia*, pasando por tratar
 los ciclos como un todo contar las referencias al ciclo completo en vez de
 a cada celda en particular.
@@ -847,7 +847,7 @@ A continuación se presenta un ejemplo gráfico para facilitar la comprensión
 del algoritmo. Por simplicidad se asumen celdas de tamaño fijo con dos
 punteros, ``left`` (``l``) y ``right`` (``r``) y se muestra el contador de
 referencias abajo del nombre de cada celda. Se parte con una pequeña
-estructura ya construída y se muestra como opera el algoritmo al eliminar
+estructura ya construida y se muestra como opera el algoritmo al eliminar
 o cambiar una referencia (cambios en la conectividad del grafo). En un
 comienzo todas las celdas son accesibles desde el *root set* por lo tanto son
 todas parte del *live set*.
@@ -1732,7 +1732,7 @@ celdas *vivas* del *Fromspace* al *Tospace* de manera contigua, como si
 estuvieran asignando por primera vez. Como la posición en memoria de las
 celdas cambia al ser movidas, es necesario actualizar la dirección de memoria
 de todas las celdas *vivas*. Para esto se almacena una dirección de memoria de
-redirección, *forwarding address*, en las celdas que mueven. La *forwarding
+re-dirección, *forwarding address*, en las celdas que mueven. La *forwarding
 address* sirve a su vez de marca, para no recorrer una celda dos veces (como
 se explica en :ref:`gc_intro_mark`). Cuando se encuentra una celda que ya fue
 movida, simplemente se actualiza la referencia por la cual se llegó a esa
@@ -1803,7 +1803,7 @@ Al igual que el :ref:`gc_mark_sweep` este algoritmo es :ref:`indirecto
 <gc_concurrent>`. Las diferencias con los esquemas vistos hasta ahora son
 evidentes. La principal ventaja sobre el marcado y barrido (que requiere una
 pasada sobre el *live set*, el marcado, y otra sobre el *heap* entero, el
-barrido) es que este método require una sola pasada y sobre las celdas vivas
+barrido) es que este método requiere una sola pasada y sobre las celdas vivas
 del *heap* solamente. La principal desventaja es copia memoria, lo que puede
 ser particularmente costoso, además de requerir, como mínimo, el doble de
 memoria de lo que el *mutator* realmente necesita. Esto puede traer en
@@ -2159,7 +2159,7 @@ la próxima iteración. Para realizar esto en recolectores :ref:`indirectos
 cuando el *mutator* cambia una referencia, se marca *gris* la celda que la
 contiene, de modo que el recolector vuelva a visitarla.
 
-En general la eficiencia de los recolectores incrementales disminuye
+En general el rendimiento de los recolectores incrementales disminuye
 considerablemente cuando el *mutator* actualiza muy seguido el grafo de
 conectividad, porque debe re-escanear sub-grafos que ya había escaneado una
 y otra vez. A esto se debe también que en general el tiempo de procesamiento
@@ -2298,15 +2298,16 @@ una celda *muerta*, la vuelve a enlazar en la lista de libres. Este es un
 esquema simple pero con limitaciones, entre las principales, el costo de
 asignar puede ser alto si hay muchos tamaños distintos de celda y soportar
 tamaño de celda variable puede ser complejo o acarrear muchas otras
-ineficiencias. :ref:`gc_mark_sweep` en general usa este esquema, al igual que
-:ref:`gc_rc`.
+ineficiencias. El :ref:`marcado y barrido <gc_mark_sweep>` en general usa este
+esquema, al igual que el :ref:`conteo de referencias <gc_rc>`.
 
 Otro forma de organizar el *heap* es utilizándolo como una especie de *stack*
 en el cual para asignar simplemente se incrementa un puntero. Este esquema es
 simple y eficiente, si el recolector puede mover celdas (ver
 :ref:`gc_moving`); de otra manera asignar puede ser muy costoso si hay que
 buscar un *hueco* en el heap (es decir, deja de reducirse a incrementar un
-puntero). El clásico ejemplo de esta familia es :ref:`gc_copy`.
+puntero). El clásico ejemplo de esta familia es el algoritmo visto en
+:ref:`gc_copy`.
 
 Sin embargo, entre estos dos extremos, hay todo tipo de híbridos. Existen
 recolectores basados en *regiones*, que se encuentran en un punto intermedio.
@@ -2392,7 +2393,7 @@ para tener un recolector de basura (y en especial aquellos que son de relativo
 alto nivel) en general disponen de recolectores precisos.
 
 Hay casos donde se posee información de tipos para algunas celdas solamente,
-o más comunmente se posee información de tipos de celdas que se encuentran en
+o más comúnmente se posee información de tipos de celdas que se encuentran en
 el *heap* pero no para el *stack* y registros (por ejemplo [MOLA06]_). En
 estos casos se puede adoptar un esquema híbrido y tratar algunas referencias
 de forma conservativa y otras de forma precisa, de manera de mitigar, aunque
@@ -2405,19 +2406,20 @@ El ejemplo de recolector conservativo por excelencia es el recolector
 `Boehm-Demers-Wiser`_ ([BOEH88]_, [BOEH91]_, [BOEH93]_, [BOEHWD]_) aunque
 puede comportarse de forma semi-precisa si el usuario se encarga de darle la
 información de tipos (en cuyo caso el recolector deja de ser transparente para
-el usuario). Otros ejemplos de recolectores con cierto grado de
-conservativismo son el :ref:`recolector actual de D <dgc_actual>` y [BLAC08]_.
+el usuario). Otros ejemplos de recolectores con cierto grado de precisión son
+el :ref:`recolector actual de D <dgc_actual>` y [BLAC08]_.
 
 
 
 .. _gc_part:
 
-Recolección particionada / generacional
+Recolección por particiones / generacional
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Otra forma de reducir la cantidad de pausas y la cantidad de trabajo realizado
-por el recolector en general es particionando el *heap* de manera tal de
-recolectar solo las partes donde más probabilidad de encontrar *basura* haya.
+por el recolector en general es dividiendo el *heap* en particiones de manera
+tal de recolectar solo las partes donde más probabilidad de encontrar *basura*
+haya.
 
 Entonces, si el recolector tiene algún mecanismo para identificar zonas de
 alta concentración de *basura* puede hacer la recolección solo en ese área
@@ -2443,40 +2445,40 @@ donde el trabajo va a ser mejor recompensado (ver :vref:`fig:gc-part`).
 
 
 Sin embargo encontrar zonas de alta concentración no es trivial. La forma más
-divulgada de encontrar estas zonas es particionando el *heap* en un área
+divulgada de encontrar estas zonas es dividiendo el *heap* en una partición
 utilizada para almacenar celdas *jóvenes* y otra para celdas *viejas*. Una
-celda *vieja* es aquella que ha *sobrevivido* una cantidad N de recolecciones,
-mientras que el resto se consideran *jóvenes* (las celdas *nacen* jóvenes).
-Los recolectores que utilizan este tipo de partición son ampliamente conocido
-como recolectores **generacionales**. La *hipótesis generacional* dice que el
-área de celdas jóvenes tiene una mayor probabilidad de ser un área de alta
-concentración de basura [JOLI96]_. Basandose en esto, los recolectores
-generacionales primero intentan recuperar espacio del área de celdas jóvenes
-y luego, de ser necesario, del área de celdas viejas. Es posible tener varias
-generaciones e ir subiendo de generación a generación a medida que es
-necesario. Sin embargo en general no se obtienen buenos resultados una vez que
-se superan las 3 particiones. La complejidad que trae este método es que para
-recolectar la generación joven es necesario tomar las referencias de la
-generación vieja a la joven como parte del *root set* (de otra forma podrían
-tomarse celdas como *basura* que todavía son utilizadas por las celdas
-viejas). Revisar toda la generación vieja no es una opción porque sería
-prácticamente lo mismo que realizar una recolección del *heap* completo. La
-solución está entonces, una vez más, en instrumentar el *mutator* para que
+celda *vieja* es aquella que ha *sobrevivido* una cantidad *N* de
+recolecciones, mientras que el resto se consideran *jóvenes* (las celdas
+*nacen* jóvenes).  Los recolectores que utilizan este tipo de partición son
+ampliamente conocido como recolectores **generacionales**. La *hipótesis
+generacional* dice que el área de celdas jóvenes tiene una mayor probabilidad
+de ser un área de alta concentración de basura [JOLI96]_. Basándose en esto,
+los recolectores generacionales primero intentan recuperar espacio del área de
+celdas jóvenes y luego, de ser necesario, del área de celdas viejas. Es
+posible tener varias generaciones e ir subiendo de generación a generación
+a medida que es necesario. Sin embargo en general no se obtienen buenos
+resultados una vez que se superan las 3 particiones. La complejidad que trae
+este método es que para recolectar la generación joven es necesario tomar las
+referencias de la generación vieja a la joven como parte del *root set* (de
+otra forma podrían tomarse celdas como *basura* que todavía son utilizadas por
+las celdas viejas). Revisar toda la generación vieja no es una opción porque
+sería prácticamente lo mismo que realizar una recolección del *heap* completo.
+La solución está entonces, una vez más, en instrumentar el *mutator* para que
 avise al recolector cuando cambia una referencia de la generación vieja a la
-joven (no es necesario monitorear las referencias en sentido inverso ya que
+joven (no es necesario vigilar las referencias en sentido inverso ya que
 cuando se recolecta la generación vieja se hace una recolección del *heap*
 completo).
 
-Sin embargo, a pesar de ser este el esquema más difundido para particionar el
+Sin embargo, a pesar de ser este el esquema más difundido para dividir el
 *heap* y realizar una recolección parcial sobre un área de alta concentración
 de basura no es la única. Otros recolectores proponen hacer un análisis
 estático del código revisando la conectividad entre los objetos según sus
-tipos (esto es posible solo en lenguajes con tipado estático), de manera tal
+tipos (esto es posible solo en lenguajes con *tipado* estático), de manera tal
 de separar en distintas áreas grupos de tipos que no pueden tener referencias
-entre sí [HIRZ03]_. Este análisis hace que sea inecesario instrumentar el
+entre sí [HIRZ03]_. Este análisis hace que sea innecesario instrumentar el
 *mutator* para reportar al recolector cambios de referencias
 inter-particiones, sencillamente porque queda demostrado que no existe dicho
-tipo de referencias. Esto quita una de las principale ineficiencias
+tipo de referencias. Esto quita una de las principales ineficiencias
 y complejidades del esquema generacional.
 
 
diff --git a/source/intro.rst b/source/intro.rst
index 393a10b..900ac5c 100644
--- a/source/intro.rst
+++ b/source/intro.rst
@@ -1,7 +1,7 @@
 
 .. Introducción al trabajo, objetivos, alcance, limitaciones y organización
    del documento.
-   ESTADO: TERMINADO
+   ESTADO: TERMINADO, CORREGIDO
 
 
 .. _intro:
@@ -19,7 +19,7 @@ esta característica y hubo una gran cantidad de investigación al respecto,
 tomando particular importancia.
 
 Nuevos algoritmos fueron desarrollados para atacar distintos problemas
-particulares y para mejorar la *performance*, que ha sido una inquietud
+particulares y para mejorar el rendimiento, que ha sido una inquietud
 incesante en la investigación de recolectores de basura. Sin embargo el
 lenguaje más masivo que ha adoptado un recolector de basura (al menos en el
 ámbito empresarial) fue Java_, con el cual la investigación sobre recolección
@@ -103,7 +103,7 @@ especial.
 Organización
 ----------------------------------------------------------------------------
 
-Este trabajo se encuentra dividido en 7 cápitos que se describen
+Este trabajo se encuentra dividido en 7 capítulos que se describen
 a continuación:
 
 1. :ref:`intro`: breve descripción del problema a tratar, presentando
diff --git a/source/resumen.rst b/source/resumen.rst
index dc64cd5..a781c2a 100644
--- a/source/resumen.rst
+++ b/source/resumen.rst
@@ -1,6 +1,6 @@
 
 .. Resumen del trabajo
-   ESTADO: TERMINADO
+   ESTADO: TERMINADO, CORREGIDO
 
 
 .. _resumen:
@@ -14,7 +14,7 @@ El problema del manejo de memoria ha sido un factor clave en los lenguajes de
 programación desde que empezaron a forjarse los primero lenguajes con un
 mínimo nivel de abstracción, dado que la administración de memoria explícita
 ha sido un flagelo constante en el mundo de la informática, provocando
-pérdidas de memoria que degradan la eficiencia de programas de larga vida
+pérdidas de memoria que degradan el rendimiento de programas de larga vida
 y siendo la principal fuente de problemas de seguridad, entre otros problemas.
 
 Es por esto que se desde la primera aparición de lenguajes de más alto nivel,