[svnbook-pt-br commit] r273 - trunk/book

codesite-noreply at google.com codesite-noreply at google.com
Sat Nov 22 00:26:42 CST 2008


Author: brunolmfg
Date: Fri Nov 21 22:25:42 2008
New Revision: 273

Modified:
    trunk/book/ch08-embedding-svn.xml

Log:
Tradução do capítulo 8, seção:
   * Usando as APIs
     - A Biblioteca Apache Portable Runtime

Modified: trunk/book/ch08-embedding-svn.xml
==============================================================================
--- trunk/book/ch08-embedding-svn.xml	(original)
+++ trunk/book/ch08-embedding-svn.xml	Fri Nov 21 22:25:42 2008
@@ -739,7 +739,7 @@
        o qual pode ser encontrado em <ulink
        url="http://subversion.tigris.org/hacking.html" />.  Este
        documento contém informações úteis que, embora destinadas a
-      desenvolvedores e would-be developers do próprio Subversion, é
+      desenvolvedores e aos próprios desenvolvedores do Subversion, é
        igualmente aplicável a pessoas desenvolvendo com o Subversion como um
        conjunto de bibliotecas de terceiros.
        <footnote>
@@ -759,7 +759,7 @@
          originalmente esculpida fora do código de seu servidor como uma  
tentativa em
          separar as partes específicas de SO das porções independentes
          de SO.  O resultado foi uma biblioteca que oferece uma API
-        genérica para executar operações that differ levemente—ou
+        genérica para executar operações que diferem levemente—ou
          agressivamente—de SO para SO.  Enquanto o Servidor HTTP da  
Apache foi
          obviamente o primeiro usuário da biblioteca APR, os  
desenvolvedores do
          Subversion imediatamente reconheceram o valor de usar APR
@@ -769,74 +769,74 @@
          compila e executa também.  Atualmente esta lista inclui todos os  
sabores de
          Unix, Win32, BeOS, OS/2, e Mac OS X.</para>

-      <para>In addition to providing consistent implementations of
-        system calls that differ across operating systems,
+      <para>Além de oferecer implementações consistentes de
+        chamadas de sistemas que diferem entre os sistemas operacionais,
          <footnote>
-          <para>Subversion uses ANSI system calls and datatypes as much
-            as possible.</para>
+          <para>O Subversion usa chamadas de sistema e tipos de dado em  
ANSI
+            sempre que possível.</para>
          </footnote>
-        APR gives Subversion immediate access to many custom
-        datatypes, such as dynamic arrays and hash tables.  Subversion
-        uses these types extensively.  But
-        perhaps the most pervasive APR datatype, found in nearly every
-        Subversion API prototype, is the
-        <structname>apr_pool_t</structname>—the APR memory pool.
-        Subversion uses pools internally for all its memory allocation
-        needs (unless an external library requires a different memory
-        management mechanism for data passed through its API),
+        a APR dá ao Subversion acesso imediato a vários tipos de dado
+        personalizados, como matrizes dinâmicas e tabelas hash.  O  
Subversion
+        usa estes tipos extensivamente.  Mas
+        talvez o mais difundido tipo de dado da APR, encontrado em quase  
todo
+        protótipo da API do Subversion, seja o
+        <structname>apr_pool_t</structname>—o recipiente de memória  
da APR.
+        O Subversion usa recipientes internamente para todas as suas  
necessidades de alocação de
+        memória (a menos que uma biblioteca externa requeira um mecanismo  
de gerenciamento
+        de memória diferente para que dados passem através de sua API),
          <footnote>
-          <para>Neon and Berkeley DB are examples of such libraries.</para>
+          <para>Neon e Berkeley DB são exemplos de tais bibliotecas.</para>
          </footnote>
-        and while a person coding against the Subversion APIs is
-        not required to do the same, they <emphasis>are</emphasis>  
required to provide
-        pools to the API functions that need them.  This means that
-        users of the Subversion API must also link against APR, must
-        call <function>apr_initialize()</function> to initialize the
-        APR subsystem, and then must create and manage pools for use with
-        Subversion API calls, typically by using
+        e enquanto uma pessoa codifica com as APIs do Subversion não
+        é necessário fazer o mesmo, eles <emphasis>são</emphasis>  
requeridos para fornecer
+        recipientes para as funções da API que precisam deles.  Isto  
significa que
+        usuários da API do Subversion devem também vincular à APR, devem
+        chamar <function>apr_initialize()</function> para inicializar o
+        subsistema da APR, e então devem criar e gerenciar os recipientes  
para usar com
+        as chamadas da API do Subversion, normalmente pelo uso de
          <function>svn_pool_create()</function>,
-        <function>svn_pool_clear()</function>, and
+        <function>svn_pool_clear()</function>, e
          <function>svn_pool_destroy()</function>.</para>

        <sidebar>
-        <title>Programming with Memory Pools</title>
+        <title>Programando com Recipientes de Memória</title>

-        <para>Almost every developer who has used the C programming
-          language has at some point sighed at the daunting task of
-          managing memory usage.  Allocating enough memory to use,
-          keeping track of those allocations, freeing the memory when
-          you no longer need it—these tasks can be quite
-          complex.  And of course, failure to do those things properly
-          can result in a program that crashes itself, or worse,
-          crashes the computer.</para>
+        <para>Quase todo desenvolvedor que usou a linguagem de programação
+          C teve em algum ponto suspirou fundo ao enfrentar a assustadora  
tarefa de
+          gerenciar o uso de memória.  Alocar memória suficiente para o  
uso,
+          manter controle dessas alocações, liberar a memória quando
+          você não precisa mais dela—estas tarefas podem ser bastante
+          complexas.  E certamente, falhar ao fazer essas coisas  
adequadamente
+          pode resultar em um programa que trava sozinho, ou pior ainda,
+          trava todo o computador.</para>

-        <para>Higher-level languages, on the other hand, take the job of
-          memory management away from the developer completely.
+        <para>Em linguagens de alto nível, por outro lado, deixam o  
trabalho de
+          gerenciamento de memória completamente distante do desenvolvedor.
            <footnote>
-            <para>Or at least make it something you only toy with when
-              doing extremely tight program optimization.</para>
+            <para>Ou pelo menos torná-lo algo que você somente diverte-se  
ao
+              fazer uma otimização extremamente rígida do programa.</para>
            </footnote>
-          Languages like Java and Python use <firstterm>garbage
-          collection</firstterm>, allocating memory for
-          objects when needed, and automatically freeing that memory
-          when the object is no longer in use.</para>
-
-        <para>APR provides a middle-ground approach called pool-based
-          memory management.  It allows the developer to control
-          memory usage at a lower resolution—per chunk (or
-          <quote>pool</quote>) of memory, instead of per allocated
-          object.  Rather than using <function>malloc()</function> and
-          friends to allocate enough memory for a given object, you
-          ask APR to allocate the memory from a memory pool.  When
-          you're finished using the objects you've created in the
-          pool, you destroy the entire pool, effectively de-allocating the
-          memory consumed by <emphasis>all</emphasis> the objects you  
allocated from it.
-          Thus, rather than keeping track of individual objects which need
-          to be de-allocated, your program simply considers the
-          general lifetimes of those objects, and allocates the
-          objects in a pool whose lifetime (the time between the
-          pool's creation and its deletion) matches the object's
-          needs.</para>
+          Linguagens como Java e Python usam um <firstterm>coletor
+          de lixo</firstterm>, alocando memória para os
+          objetos quando necessário, e automaticamente liberando esta  
memória
+          quando o objeto não está mais em uso.</para>
+
+        <para>A APR fornece uma abordagem de meio-termo chamada  
gerenciamento
+          de memória baseada em recipientes.  Isto permite ao  
desenvolvedor controlar
+          o uso de memória em uma resolução mais baixa—por pedaços  
(ou
+          <quote>recipientes</quote>) de memória, em vez de por objeto
+          alocado.  Ao invés de usar <function>malloc()</function> e
+          similares para alocar memória suficiente para um dado objeto,  
você
+          pede que a APR aloque a memória de um recipiente de memória.   
Quando
+          você estiver finalizado o uso dos objetos criados naquele
+          recipiente, você destrói todo o recipiente, efetivamente  
desalocando a
+          memória consumida por <emphasis>todos</emphasis> os objetos que  
você alocou nele.
+          Dessa forma, em vez de manter o controle individual de objetos  
que precisam
+          ser desalocados, seu programa simplesmente considera o
+          tempo de vida total desses objetos, e aloca os
+          objetos em um recipiente cujo tempo de vida (o tempo entre a
+          criação do recipiente e sua exclusão) coincide a necessidade do
+          objeto.</para>

        </sidebar>
      </sect2>


More information about the svn-pt_br mailing list