--- a/.gitignore
+++ b/.gitignore
@@ -24,3 +24,4 @@ package-cache
 _LaTeX_DOC
 _REGEX_DOC.txt
 test.*
+.DS_Store

--- a/PortugueseBook/BasicClasses/BasicClasses.tex
+++ b/PortugueseBook/BasicClasses/BasicClasses.tex
@@ -30,7 +30,7 @@
 \chapter{Classes Básicas}
 \label{cha:basic}
 
-Muito da mágica do \st não está na linguagem, mas nas bibliotecas de classes. Para programar efetivamente com \st, você precisa aprender como as bibliotecas de classes suportam a linguagem e o ambiente. Essas bibliotecas são inteiramente escritas em \st e podem ser facilmente estendidas á que um pacote qualquer pode adicionar funcionalidade a uma classe mesmo que esta classe não tenha sido definida no próprio pacote.
+Muito da mágica do \st não está na linguagem, mas nas bibliotecas de classes. Para programar efetivamente com \st, você precisa aprender como as bibliotecas de classes suportam a linguagem e o ambiente. Essas bibliotecas são inteiramente escritas em \st e podem ser facilmente estendidas desde que um pacote qualquer possa adicionar funcionalidade a uma classe mesmo que esta classe não tenha sido definida no próprio pacote.
 
 O nosso alvo aqui não é apresentar, em detalhes tediosos, a totalidade da biblioteca de classes do \sq, mas apontar par algumas classes chaves e métodos que você precisará usar ou sobrepor para programar efetivamente. Neste capítulo, cobriremos as classes básicas que você precisará para praticamente qualquer aplicação: \ct{Object}, \ct{Number} e suas sub-classes, \ct{Character}, \ct{String}, \ct{Symbol} e \ct{Boolean}.
 
@@ -47,7 +47,7 @@ O nosso alvo aqui não é apresentar, em detalhes tediosos, a totalidade da bibl
 Para todos os intentos e propósitos, \clsindmain{Object} é a raiz da hierarquia de classes do \sq. Na verdade, em \sq, a verdadeira classe base é \clsind{ProtoObject}, mas como ela é usada mais para definir entidade mínimas que mascaram como objetos. De qualquer forma, você pode ignorar essa classe no momento.
 % (more on this later in the chapter on reflection).
 
-A classe \ct{Object} pode ser encontrada na categoria \scatind{Kernel-Objects}. Surpreendentemente, há 400 métodos na classe (incluindo extensões). Em outras palavras, cada classe que você define automaticamente terá esses 400 métodos, quer você saiba o que eles fazem, quer não. Note que alguns deses métodos precisam ser removidos e novas versões do \sq podem fazer exatamente isso.
+A classe \ct{Object} pode ser encontrada na categoria \scatind{Kernel-Objects}. Surpreendentemente, há 400 métodos na classe (incluindo extensões). Em outras palavras, cada classe que você define automaticamente terá esses 400 métodos, quer você saiba o que eles fazem, quer não. Note que alguns desses métodos precisam ser removidos e novas versões do \sq podem fazer exatamente isso.
 
 \sd{Eu não gosto de citar algo que pode mudar e que pessoas podem encontrar simplesmente usando a imagem mas vamos deixar por agora.}
 O comentário de classe para \ct{Object} declara (traduzido):
@@ -55,7 +55,7 @@ O comentário de classe para \ct{Object} declara (traduzido):
 \needlines{4}
 \begin{quote}
 \textit{\ct{Object} é a classe base de quase todas as outras classes na hierarquia. As exceções são \ct{ProtoObject} (a superclasse de  \ct{Object}) e suas sub-classes.
-A classe \ct{Object} provê comportamente padrão comum a todos os objetos normais, como acesso, cópia, comparação, tratamento de erros, envio de mensagens e \ind{reflexão}. Da mesma forma, mensagens utilitárias que todos objetos devem responder estão definidas aqui.
+A classe \ct{Object} provê comportamento padrão comum a todos os objetos normais, como acesso, cópia, comparação, tratamento de erros, envio de mensagens e \ind{reflexão}. Da mesma forma, mensagens utilitárias que todos objetos devem responder estão definidas aqui.
 \ct{Object} não tem variáveis de instância e nenhuma deve ser adicionada. Isto se deve ao fato que que várias classes que herdam de \ct{Object} possuem implementações especiais (\ct{SmallInteger} e \ct{UndefinedObject}, por exemplo) e de que a VM conhece e depende da estrutura e \foreign{layout} de certas classes padrão.}
 \end{quote}
 
@@ -64,7 +64,7 @@ Se começarmos a navegar pelas categorias de métodos que o lado da instância d
 %-----------------------------------------------------------------
 \subsection{Impressão}
 %TODO Pensar em como traduzir método de template
-Todo objeto em \st pode retornar uma forma impressa de si próprio. Você pode selecionar qualquer expressão no \foreign{workspace} e selecionar o \foreign{menu} \menu{print it}: isto executa a expressão e pede ao objeto retornado que se imprima. Se fato, isto envia a mensagem \ct{printString} ao objeto retornado. O método \mthind{Object}{printString}, que é um \ind{método de template}, na verdade envia a mensagem \mthind{Object}{printOn:} para seu receptor. Essa mensagem é um \foreign{hook} que pode ser especializado. 
+Todo objeto em \st pode retornar uma forma impressa de si próprio. Você pode selecionar qualquer expressão no \foreign{workspace} e selecionar o \foreign{menu} \menu{print it}: isto executa a expressão e pede ao objeto retornado que se imprima. De fato, isto envia a mensagem \ct{printString} ao objeto retornado. O método \mthind{Object}{printString}, que é um \ind{método de template}, na verdade envia a mensagem \mthind{Object}{printOn:} para seu receptor. Essa mensagem é um \foreign{hook} que pode ser especializado. 
 
 \ct{Object>>>printOn:} é provavelmente o método que você irá sobrepor com maior freqüência. Este método recebe como argumento uma \clsind{Stream} no qual uma representação textual (ou seja, uma instância da classe \clsind{String}) será escrita. A implementação padrão simplesmente escreve o nome da classe precedido por um ``\ct{a}'' ou ``\ct{an}''. \ct{Object>>>printString} retorna então a \ct{String} que foi escrita.
 
@@ -92,7 +92,7 @@ TTCFont allInstances anyOne printString --> 'TTCFont(BitstreamVeraSans 6 Bold)'
 Note que a mensagem \ct{printOn:} não é a mesma que \mthind{Object}{storeOn:}. A mensagem \ct{storeOn:} coloca na \foreign{stream} passado como argumento uma expressão que pode ser usada para recriar o receptor da mensagem. A expressão é executada quando a \foreign{stream} é lida usando a mensagem \ct{readFrom:}. \ct{printOn:} simplesmente retorna uma versão textual do receptor. É claro que pode acontecer que a representação textual seja a mesma representação que é usada para recriar a instância.
 
 \paragraph{Um aviso sobre representações e representações auto-executáveis.}
-Em programação funcional, expressões retornam valores quando executadas. Em \st, mesnagens (expressões) retornam objetos (valores). Alguns objetos possuem propriedades cujos valores são os próprios. Por exemplo, o valor do objeto \ct{true} é ele mesmo \ie o objeto \ct{true}. Nós denominamos esses objetos de \emphind{objetos auto-executáveis}. Você pode ver a versão impressa do valor de um objeto quando você o imprime em um \foreign{workspace}. Abaixo estão alguns exemplos de objetos auto-executáveis:
+Em programação funcional, expressões retornam valores quando executadas. Em \st, mensagens (expressões) retornam objetos (valores). Alguns objetos possuem propriedades cujos valores são os próprios. Por exemplo, o valor do objeto \ct{true} é ele mesmo \ie o objeto \ct{true}. Nós denominamos esses objetos de \emphind{objetos auto-executáveis}. Você pode ver a versão impressa do valor de um objeto quando você o imprime em um \foreign{workspace}. Abaixo estão alguns exemplos de objetos auto-executáveis:
 
 \begin{code}{@TEST}
 true       --> true
@@ -101,7 +101,7 @@ $a         --> $a
 #(1 2 3) --> #(1 2 3)
 \end{code}
 
-Note que alguns objetos, como \ct{arrays}, são auto-executáveis ou não dependendo dos objetos que contém. Por exemplo, um \ct{array} de \ct{booleanos} é auto-executável enquanto um \ct{array} de pessoas não é. Em \sq 3.9, um mecanismo foi introduzido (atráves da mensagem \mthind{Object}{isSelfEvaluating}) para imprimir coleções sem suas formas auto-executáveis tanto quanto possível e isso é especialmente verdaeiro para \ct{arrays} definidos por chaves. Os exemplos abaixo mostram que um \ct{array} \subind{Array}{dinâmico} é auto-executável somente se seus objetos também o são:
+Note que alguns objetos, como \ct{arrays}, são auto-executáveis ou não dependendo dos objetos que contém. Por exemplo, um \ct{array} de \ct{booleanos} é auto-executável enquanto um \ct{array} de pessoas não é. Em \sq 3.9, um mecanismo foi introduzido (atráves da mensagem \mthind{Object}{isSelfEvaluating}) para imprimir coleções sem suas formas auto-executáveis tanto quanto possível e isso é especialmente verdadeiro para \ct{arrays} definidos por chaves. Os exemplos abaixo mostram que um \ct{array} \subind{Array}{dinâmico} é auto-executável somente se seus objetos também o são:
 \begin{code}{@TEST}
 {10@10 . 100@100}          --> {10@10 . 100@100}
 {Browser new . 100@100} --> an Array(a Browser 100@100)
@@ -172,7 +172,7 @@ Complex>>>= anObject
         ifFalse: [^ anObject adaptToComplex: self andSend: #=]
 \end{method}
 
-A implementação padrão de \ct{Object>>>~=} (desigualdade) simplesmente nega \ct{Object>>>=} e normalmente não precisa se mudada..
+A implementação padrão de \ct{Object>>>~=} (desigualdade) simplesmente nega \ct{Object>>>=} e normalmente não precisa ser mudada.
 %\cmindex{Object}{\~=}
 \index{Object!~=@\ct{~=}} % needs special treatment due to ~
 
@@ -188,7 +188,7 @@ Complex>>>hash
     ^ real hash bitXor: imaginary hash.
 \end{method}
 
-Embora você precise sobrepor \ct{=} e \ct{hash} em conjunto, você nunca deve sobrepor \ct{==}. A semântica de identidade é a mesma paa todas as classes. Inclusive, \ct{==} é um método primitivo de \clsind{ProtoObject}.
+Embora você precise sobrepor \ct{=} e \ct{hash} em conjunto, você nunca deve sobrepor \ct{==}. A semântica de identidade é a mesma para todas as classes. Inclusive, \ct{==} é um método primitivo de \clsind{ProtoObject}.
 
 Note que \sq possui um comportamento estranho comparado a outras versões de \st: um símbolo e uma \foreign{string} são considerados iguais. Nós consideramos isso um defeito e não uma característica.
 
@@ -207,7 +207,7 @@ Vários métodos permitem que você verifique a classe de um objeto.
 1 class --> SmallInteger
 \end{code}
 
-Em converso, voc6e pode perguntar se um objeto é uma instância de uma classe específica:
+Inversamente, você pode perguntar se um objeto é uma instância de uma classe específica:
 \cmindex{Object}{isMemberOf:}
 \begin{code}{@TEST}
 1 isMemberOf: SmallInteger --> true    "deve ser precisamente desta classe"
@@ -235,7 +235,7 @@ Já que \st é escrita em si mesma, você pode realmente navegar pela estrutura
 \ct{1/3} que é uma \clsind{Fraction} é uma espécie de  \clsind{Number}, já que a classe \ct{Number} é uma superclasse da classe \ct{Fraction}, mas \ct{1/3} não é um \ct{Integer}.
 
 \paragraph{\ct{respondsTo:}}
-\cmind{Object}{respondsTo:} responde se o receptor entende uma dado seletor de mensagem passado como argumento.
+\cmind{Object}{respondsTo:} responde se o receptor entende um dado seletor de mensagem passado como argumento.
 
 \begin{code}{@TEST}
 1 respondsTo: #, --> false
@@ -296,7 +296,7 @@ a1 deepCopy --> !\emph{... continua infinitamente!}!
 \end{code}
 % NB: Not a test!
 
-Embora seja possível sobrepor ct{deepCopy} para fazer a coisa certa certa, \cmind{Object}{copy} geralmente oferece a melhor solução:
+Embora seja possível sobrepor ct{deepCopy} para fazer a coisa certa, \cmind{Object}{copy} geralmente oferece a melhor solução:
 
 \begin{method}{Copiando objeto de maneira segura}
 Object>>>copy
@@ -318,7 +318,7 @@ O mais importante método aqui é \mthind{Object}{halt}. Para criar um \foreign{
 \sd{em outro capítulo haltIf:, haltOnce, inspectOnce, flagging: isThisEverCalled, }
 
 %TODO: Tradução de design by contract
-A próxima mensagem importante é \mthind{Object}{assert:}, que recebe um bloco como argumento. Se o bloco retornar \ct{true}, a execução continua. Caso contrário, uma exceção será criada. Se a exceção não é tratada em nenhum lugar, o \foreign{debugger} será aberto naquele ponto de execução. O método \ct{assert:} é especialmente útil para suportar \emphind{design by contract}. O uso mais típico é verificar pré-condições não-triviais para métodos públicas de uma classe. \cmind{Stack}{pop}, por exemplo, poderia ser implementado como o seguinte:
+A próxima mensagem importante é \mthind{Object}{assert:}, que recebe um bloco como argumento. Se o bloco retornar \ct{true}, a execução continua. Caso contrário, uma exceção será criada. Se a exceção não é tratada em nenhum lugar, o \foreign{debugger} será aberto naquele ponto de execução. O método \ct{assert:} é especialmente útil para suportar \emphind{design by contract}. O uso mais típico é verificar pré-condições não-triviais para métodos públicos de uma classe. \cmind{Stack}{pop}, por exemplo, poderia ser implementado como o seguinte:
 
 \begin{method}{Verificando uma pré-condição}
 Stack>>>pop
@@ -327,7 +327,7 @@ Stack>>>pop
     ^self linkedList removeFirst element
 \end{method}
 
-Não confunda\ct{Object>>>assert:} com \cmind{TestCase}{assert:}, que ocorre dentro do \foreign{framework} TDD SUnit (veja \charef{SUnit}). Enquanto o primeiro espera um bloco como seu argumento\footnote{Na verdade, ele aceita qualquer argumento que entende \ct{value}, incluindo \ct{Boolean}.}, o segundo espera um valor \ct{booleano}. Embora ambos seja úteis para a depuração, cada um dele serve um propósito bem diferente.
+Não confunda \ct{Object>>>assert:} com \cmind{TestCase}{assert:}, que ocorre dentro do \foreign{framework} TDD SUnit (veja \charef{SUnit}). Enquanto o primeiro espera um bloco como seu argumento\footnote{Na verdade, ele aceita qualquer argumento que entende \ct{value}, incluindo \ct{Boolean}.}, o segundo espera um valor \ct{booleano}. Embora ambos seja úteis para a depuração, cada um dele serve um propósito bem diferente.
 
 %-----------------------------------------------------------------
 \subsection{Tratamento de erros}
@@ -412,7 +412,7 @@ Isso significa que simplesmente por sobrepor o método \ct{initialize} de uma cl
 %=================================================================
 \section{Number}
 \label{sec:Number}
-Surpreendentemente, números em \st não são tipos primitivo mas objetos reais. É claro que são implementados eficientemente na máquina virtua, mas a hierarquia da classe \clsindmain{Number} é perfeitamente acessível e extensível como qualquer outra porção da biblioteca de classes do \st. hierarchy.
+Surpreendentemente, números em \st não são tipos primitivo mas objetos reais. É claro que são implementados eficientemente na máquina virtual, mas a hierarquia da classe \clsindmain{Number} é perfeitamente acessível e extensível como qualquer outra porção da biblioteca de classes do \st. hierarchy.
 
 \begin{figure}[ht]
 \centerline {\includegraphics[width=8cm]{NumberHierarchy}}
@@ -530,9 +530,9 @@ Quando um \ct{SmallInteger} ultrapassa sua faixa de representação, ele é auto
 (SmallInteger minVal - 1) class  --> LargeNegativeInteger
 \end{code}
 
-Inteiros grandes similarmente retornam a um \ct{SmallInteger} se necessário.
+Inteiros grandes similarmente retornam um \ct{SmallInteger} se necessário.
 
-Como em várias linguagens de programação, inteiros podem ser úteis para definir comportamento iterativa. Há um método dedicado chamado \mthind{Integer}{timesRepeat:} para executar um bloco repetidamente:
+Como em várias linguagens de programação, inteiros podem ser úteis para definir comportamento iterativo. Há um método dedicado chamado \mthind{Integer}{timesRepeat:} para executar um bloco repetidamente:
 Nós já vimos um exemplo similar em \charef{syntax}:
 \begin{code}{@TEST | n |}
 n := 2.
@@ -554,7 +554,7 @@ Caracteres que não podem ser impressos pode ser gerados por vários métodos de
 Character space = (Character value: Character space asciiValue) --> true
 \end{code}
 
-O método \mthind{Character}{printOn:} é inteligente o abstante para saber quais dos três métodos para gerar caracteres fornece a representacão mais apropriada:
+O método \mthind{Character}{printOn:} é inteligente o bastante para saber quais dos três métodos para gerar caracteres fornece a representacão mais apropriada:
 
 \begin{code}{@TEST}
 Character value: 1   --> Character value: 1
@@ -640,7 +640,7 @@ Se você precisar de um suporte mais avançado para expressões regulares, há u
 \index{Bykov, Vassili}
 \index{pacote de expressões regulares}
 
-A classe \ct{String} suporta um número bem grande de métodos de covnersão. Muitos destes são métodos usados para construir outras classes como  \mthind{String}{asDate}, \mthind{String}{asFileName} e assim por diante. Há também um número de métodos úteis para converter texto em outros tipos de texto como \mthind{String}{capitalized} e \mthind{String}{translateToLowercase}.
+A classe \ct{String} suporta um número bem grande de métodos de conversão. Muitos destes são métodos usados para construir outras classes como  \mthind{String}{asDate}, \mthind{String}{asFileName} e assim por diante. Há também um número de métodos úteis para converter texto em outros tipos de texto como \mthind{String}{capitalized} e \mthind{String}{translateToLowercase}.
 
 Para mais informações sobre isto e coleções, veja \charef{collections}.
 

--- a/PortugueseBook/Metaclasses/Metaclasses.tex
+++ b/PortugueseBook/Metaclasses/Metaclasses.tex
@@ -32,9 +32,9 @@
 
 \on{A seção sobre as responsabilidades de Class, Behavior e Metaclass estão bem fracas e precisam ser melhoradas com exemplo mais convincentes. Marcus, você pode ajudar?}
 
-Como vimos em \charef{model}, em \st, tudo é um objeto, e cada objeto é uma instância de uma classe. As próprias classes não são exceções: classes são objetos, e objetos de classe são instâncias de outras classes.
+Como vimos no \charef{model}, em \st, tudo é um objeto, e cada objeto é uma instância de uma classe. As próprias classes não são exceções: classes são objetos, e objetos de classe são instâncias de outras classes.
 Este modelo de objetos captura a essência da programação orientada a objetos: é compacto, elegante e uniforme.
-Entretanto, as implicações desta uniformidade pode confundir iniciantes. O objeto deste capítulo é mostrar que não há nada de complexo, ``mágico'' ou especial aqui: apenas regras simples aplicadas uniformemente.
+Entretanto, as implicações desta uniformidade pode confundir iniciantes. O objetivo deste capítulo é mostrar que não há nada de complexo, ``mágico'' ou especial aqui: apenas regras simples aplicadas uniformemente.
 Seguindo essas regras simples, você sempre será capaz de entender porque a situação é da forma como é.
 
 %=================================================================
@@ -68,11 +68,11 @@ Como mencionamos no início deste capítulo, uma conseqüência da regra de que
 A classe de uma classe é chamada de \emph{metaclasse}.
 \label{sec:metaclassIntro}
 Uma \indmain{metaclasse} é criada automaticamente para você toda vez que você cria uma classe.
-E na maior parte do tempo, você na precisa se preocupar com metaclasses.
+E na maior parte do tempo, você não precisa se preocupar com metaclasses.
 Entrentanto, toda vez que você usa o \foreign{system browser} para olhar o ``\subind{system browser}{lado da classe}'' de uma classe, é bom ter em mente que você está na verdade navegando por uma classe inteiramente diferente.
-Uma classe e sua metaclasse são clases diferentes, mesmo que a primeira seja uma instância da segunda.
+Uma classe e sua metaclasse são classes diferentes, mesmo que a primeira seja uma instância da segunda.
 
-Para explicar apropriadamente classes e metaclasses, precisamos estender as regras vistas em \charef{model} com as seguintes regras adicionai:
+Para explicar apropriadamente classes e metaclasses, precisamos estender as regras vistas em \charef{model} com as seguintes regras adicionais:
 
 \begin{enumerate}[label={\textbf{Rule \arabic{*}}.}, ref={Rule \arabic{*}}, leftmargin=*, widest=10]
 \setcounter{enumi}{5}
@@ -146,7 +146,7 @@ Color superclass                   --> Object
 Tudo acontece por \ind{envios de mensagens} (\ref{rule:message}); portanto, podemos deduzir que mthind{Color class}{blue} é uma mensagem para \ct{Color}; \mthind{Object}{class} e \mthind{Color}{alpha:} são mensagens para a cor azul; \mthind{Morph}{openInWorld} é uma mensagem para a elipse; e mthind{Behavior}{superclass} é uma mensagem para \ct{TranslucentColor} e \ct{Color}.
 O receptor em cada classe é um objeto, já que tudo é um objeto, mas alguns desses objetos também são classes.
 
-A busca de métodos segue a cadeia de herança (\ref{rule:lookup}); sendo assim, quando enviamos a mensagem \ct{class} para o resultado de \ct{Color blue alpha: 0.4}, a mensagem é realmente tratada pelo método correspondente encontrado em  \ct{Object}, como mostrando na \figref{classmessage}.
+A busca de métodos segue a cadeia de herança (\ref{rule:lookup}); sendo assim, quando enviamos a mensagem \ct{class} para o resultado de \ct{Color blue alpha: 0.4}, a mensagem é realmente tratada pelo método correspondente encontrado em  \ct{Object}, como mostrado na \figref{classmessage}.
 
 \begin{center}
 \begin{figure}[!ht]
@@ -175,11 +175,11 @@ translucentBlue isKindOf: Object                  --> true
 Como mencionamos em \secref{metaclassIntro}, classes cujas instâncias são classes são chamadas de metaclasses.
 
 \paragraph{Metaclasses são implícitas.}
-Metaclasses são automaticamente criadas quando você define uma classes. Você pode dizer que elas são \emph{implícitas} já que com um programador você nunca terá que se preocupar com elas. Uma metaclasse \subind{metaclasse}{implícita} é criada para cada classe que você define, de modo que cada metaclasse possui uma única instância.
+Metaclasses são automaticamente criadas quando você define uma classes. Você pode dizer que elas são \emph{implícitas} já que como um programador você nunca terá que se preocupar com elas. Uma metaclasse \subind{metaclasse}{implícita} é criada para cada classe que você define, de modo que cada metaclasse possui uma única instância.
 % At a more advanced level, this implies that sharing between metaclasses is difficult except by subclassing. 
 
-Enquanto classe normais são nomeadas por variáveis globais, metaclasse são anônimas.
-Mesmo assim você pode sempre obter uma referência às mesmas atráves da classes que são suas instâncias.
+Enquanto classes normais são nomeadas por variáveis globais, metaclasses são anônimas.
+Mesmo assim você pode sempre obter uma referência às mesmas atráves das classes que são suas instâncias.
 A classe de \clsind{Color}, por exemplo, é \clsind{Color class}, e a classe de \ct{Object} é \clsind{Object class}:
 \begin{code}{@TEST}
 Color class   --> Color class
@@ -264,7 +264,7 @@ Note que o resultado é uma instância normal de \ct{Color blue} e não uma cor
 \end{figure}
 \end{center}
 
-Podemos perceber então que á uma única forma de \subind{méetodos}{busca} de métodos em \st. Classes são objetos, e se comportam como quaisquer outros objetos.
+Podemos perceber então que há uma única forma de \subind{méetodos}{busca} de métodos em \st. Classes são objetos, e se comportam como quaisquer outros objetos.
 Classes tem o poder de criar novas instâncias somente porque respondem à mensagem \ct{new} e porque este método sabe como criar novas instâncias. Normalmente, objetos normais não entendem essa mensagem, mas se você tiver uma boa razão para fazer isso, não há nada que lhe impeça de adicionar o método \ct{new} a um objeto qualquer que não seja uma metaclasse.
 
 E já que classes são objetos, podemos inspecioná-las normalmente:
@@ -273,7 +273,7 @@ E já que classes são objetos, podemos inspecioná-las normalmente:
 \dothis{Use o \foreign{inspector} para visualizar \ct{Color blue} e \ct{Color}.}
 
 \noindent
-Note que em uma caso, você está inspecionando uma instância de \ct{Color} e na outra a própria classe \ct{Color}.
+Note que em um caso, você está inspecionando uma instância de \ct{Color} e na outra a própria classe \ct{Color}.
 Isso pode ser um pouco confuso, porque o título do \foreign{inspector} mostra a \emph{classe} do objeto sendo visualizado.
 
 O \foreign{inspector} em \ct{Color} permite que você veja a superclasse, as variáveis de instâncias, o \subind{método}{dicionário} de métodos, e assim por diante, da classe \ct{Color}, como vista na \figref{inspectingColor}.
@@ -335,7 +335,7 @@ Ao invés disso, você deve procurá-lo em \ct{Array class} e suas superclasses,
 \paragraph{Responsabilidades de \lct{Behavior}, \lct{ClassDescription} e \lct{Class}.}
 \clsind{Behavior} é responsável pelo estado mínimo de objetos que possuem instâncias: isto incluem um elo para a superclasse, um dicionário de métodos e uma descrição das instâncias (\ie representação e número).
 \on{eu não sei se entendo o último ponto}
-\ct{Behavior} herda\ct{Object}, de modo que ela e todas suas subclasses se comportam com um objetos normais.
+\ct{Behavior} herda de \ct{Object}, de modo que ela e todas suas subclasses se comportam como  objetos normais.
 
 \ct{Behavior} também é a interface básica para o compilador.
 Essa classe possui métodos para criar um dicionário de métodos, compilar métodos, 
@@ -354,10 +354,10 @@ a manutenção de conjuntos de mudanças e a transcrição das mesmas,
 a maior parte dos mecanismos necessários para gravar mudanças.
 
 \clsind{Class} representa o comportamente comum de todas as classes.
-Ela provê um nome de classes, compilação de métodos, armazenamento de métodos, e variáveis de instância.
+Ela provê um nome de classe, compilação de métodos, armazenamento de métodos, e variáveis de instância.
 %FIXME tradução de pool variables
-Também fornece uma representam concreta de nomes de variáveis de classes e variáveis compartilhadas (\mthind{Class}{addClassVarName:}, \mthind{Class}{addSharedPool:}, \mthind{Class}{initialize}).
-\ct{Class} sabe como criar instâncias de modo que todas metaclasses deve herdar de \ct{Class} em última instância.
+Também fornece uma representação concreta de nomes de variáveis de classes e variáveis compartilhadas (\mthind{Class}{addClassVarName:}, \mthind{Class}{addSharedPool:}, \mthind{Class}{initialize}).
+\ct{Class} sabe como criar instâncias de modo que todas metaclasses devem herdar de \ct{Class} em última instância.
 
 %=================================================================
 \section{Toda metaclasse é uma instância de \lct{Metaclass}}
@@ -386,7 +386,7 @@ e informações de classe (ligações de herança, variáveis de instância, \et
 \section{A metaclasse de \lct{Metaclass} é uma instância de \lct{Metaclass}}
 % \ruleref{metaclassmetaclass}
 
-A questão final é: qua é classe de \clsind{Metaclass class}?
+A questão final é: qual a é classe de \clsind{Metaclass class}?
 
 A resposta é simples: é uma metaclasse, portanto, é uma instância de \ct{Metaclass}, como todas outras metaclasses no sistema (veja a \figref{metaclassclassclass}).
 
@@ -399,9 +399,9 @@ A resposta é simples: é uma metaclasse, portanto, é uma instância de \ct{Met
 \end{figure}
 \end{center}
 
-A figura mostra que todas metaclasses são instâncias de \ct{Metaclass}, incluindo a metaclasse da própria \ct{Metaclass}. Se você comprar as  \ref{fig:metaclassclass} e \ref{fig:metaclassclassclass}, você verá como a \subind{metaclasse}{hierarquia} de metaclasses espelha perfeitament a hieraquia de classes, até o topo em \ct{Object class}.
+A figura mostra que todas metaclasses são instâncias de \ct{Metaclass}, incluindo a metaclasse da própria \ct{Metaclass}. Se você comparar as  \ref{fig:metaclassclass} e \ref{fig:metaclassclassclass}, você verá como a \subind{metaclasse}{hierarquia} de metaclasses espelha perfeitamente a hieraquia de classes, até o topo em \ct{Object class}.
 
-O exemplo seguinte nos mostra como podemos verificar a hierarquia de classes para demonstrar que a \figref{metaclassclassclass} está correta. (Na verdade, você verá que isso é uma mentirinha\,---\,\ct{Object class superclass -->} {\clsind{ProtoObject class}, não \ct{Class}). Em \sq, precisamos subir mais uma superclasses até chegar em \ct{Class}.)
+O exemplo seguinte nos mostra como podemos verificar a hierarquia de classes para demonstrar que a \figref{metaclassclassclass} está correta. (Na verdade, você verá que isso é uma mentirinha\,---\,\ct{Object class superclass -->} {\clsind{ProtoObject class}, não \ct{Class}). Em \sq, precisamos subir mais umas superclasses até chegar em \ct{Class}.)
 
 \begin{example}{A hierarquia de classes}{@TEST}
 TranslucentColor superclass --> Color
@@ -443,7 +443,7 @@ Se o método não foi encontrada na classe de um receptor, ele está na supercla
 
 \item Cada metaclasse herda de \ct{Class} e \ct{Behavior}.
   Cada classe \emph{é uma} \ct{Class}. Já que metaclasses também são classes, elas tem que herdar de \ct{Class}.
-  \ct{Behavior} provê o comportamente comum a todas entidades que possuem instâncias.
+  \ct{Behavior} provê o comportamento comum a todas entidades que possuem instâncias.
 
 \item Toda metaclasse é uma instância de \ct{Metaclass}.
   \ct{ClassDescription} provê tudo o que você precisa que é comum a \ct{Class} e \ct{Metaclass}.

--- a/PortugueseBook/Preface/Preface.tex
+++ b/PortugueseBook/Preface/Preface.tex
@@ -44,7 +44,7 @@ Este livro apresenta os vários aspectos do \sq, começando com o básico e avan
 
 Este livro não lhe ensinará a programar --- o leitor já deverá ter alguma familiaridade com linguagens de programação. Da mesma forma, alguma experiência com programação orientada a objetos será útil.
 
-O livro introduzirá o ambiente de programação do \sq, e também a linguagem e ferramentas associadas. Você terá alguma exposição a idiomas e práticas comuns, mas o foco será na tecnologia e não em \foreign{design} orientado a objetos. Quanto possível, nós lhe mostraremos muitos exemplos. (Nossa inspiração foi o excelente livro de Alec Sharp sobre Smalltalk\cite{Shar97a}.)
+O livro introduzirá o ambiente de programação do \sq, e também a linguagem e ferramentas associadas. Você terá alguma exposição a idiomas e práticas comuns, mas o foco será na tecnologia e não em \foreign{design} orientado a objetos. Quando possível, nós lhe mostraremos muitos exemplos. (Nossa inspiração foi o excelente livro de Alec Sharp sobre Smalltalk\cite{Shar97a}.)
 
 Há vários outros livros sobre \st disponíveis gratuitamente na Web, mas nenhum deles tem seu foco específico em \sq. Veja, por exemplo:
 \url{stephane.ducasse.free.fr/FreeBooks.html}
@@ -60,7 +60,7 @@ Você não tem que saber tudo!
 Alan Knight expressa este princípio da seguinte forma\footnote{\url{www.surfscranton.com/architecture/KnightsPrinciples.htm}}:
 \index{Knight, Alan}
 \important{{\bf Tente não se importar.}
-Programadores que estão começando com \st geralmente se vêem em problemas porque pensam que precisam entender todos os detalhes de como uam coisa funciona antes que possam usá-la. Isso sigfica que leva um bom tempo para que eles dominem \ct{Transcript show: 'Hello World'}.. Um dos grandes saltos em OO é poder responder a questão ``Como isto funciona?'' com ``Não me importo em absoluto''.}
+Programadores que estão começando com \st geralmente se vêem em problemas porque pensam que precisam entender todos os detalhes de como uma coisa funciona antes que possam usá-la. Isso sigfica que leva um bom tempo para que eles dominem \ct{Transcript show: 'Hello World'}.. Um dos grandes saltos em OO é poder responder a questão ``Como isto funciona?'' com ``Não me importo em absoluto''.}
 
 %=================================================================
 \section*{Um livro aberto}
@@ -93,7 +93,7 @@ Abaixo está uma lista pequena de recursos que talvez sejam úteis:
 
 \item \url{www.squeaksource.com} é o equivalente do SourceForge para projetos \sq.
 
-\item \url{wiki.squeak.org/squeak} é um \foreign{wiki} co informações atualizadas sobre o \sq.
+\item \url{wiki.squeak.org/squeak} é um \foreign{wiki} com informações atualizadas sobre o \sq.
 \end{itemize}
 
 \paragraph{Sobre as listas de discussão.} Existem várias listas de discussão sobre o \sq e algumas delas podem ser excessivamente ativas. Se você não quer ser inundado por \foreign{e-mails} mas ainda assim gostaria de participar sugerimos que você use \url{news.gmane.org} ou \url{www.nabble.com/Squeak-f14152.html} para navegar pelos arquivos das listas.
@@ -125,18 +125,18 @@ Aqui estão alguns deles:
 %=================================================================
 \section*{Exemplos e exercícios}
 
-Nós faemos uso de duas convenções especiais neste livro.
+Nós faremos uso de duas convenções especiais neste livro.
 
 Nós tentamos dar tantos exemplos quanto possível.
-Em particulr, há muitos exemplos que mostram um fragmento de código que pode ser executado. Nós usamos o símbolo \ct{-->} para indicar o resultado que você obtém quando seleciona uma expressão e \menu{a imprime}:
+Em particular, há muitos exemplos que mostram um fragmento de código que pode ser executado. Nós usamos o símbolo \ct{-->} para indicar o resultado que você obtém quando seleciona uma expressão e \menu{a imprime}:
 
 \begin{code}{@TEST}
 3 + 4 --> 7    "selecionando 3 + 4 e usado o comando 'print it', imprime-se 7"
 \end{code}
 
-Caso você queria usar o \sq para executar esse comandos, você pode baixar um arquivo de texto com todo o código do livro do site do mesmo: \sbe.
+Caso você queria usar o \sq para executar esses comandos, você pode baixar um arquivo de texto com todo o código do livro do site do mesmo: \sbe.
 
-A segunda conversão é mostrar o ícone \dothisicon{} para indicar algo que você precisa fazer:
+A segunda convenção é mostrar o ícone \dothisicon{} para indicar algo que você precisa fazer:
 
 \dothis{Leia o segundo capítulo!}
 
@@ -147,11 +147,11 @@ Gostaríamos também de agradecer a Tim Rowledge pelo uso do \foreign{logo} do \
 
 Somos especialmente gratos a Lukas Renggli e Orla Greevy pelos seus comentários durante os rascunhos da primeira versão.
 
-Agradecemos também à Universde de Bern, Suíça, por suportar esse projeto de código livre e por hospedar o site do livro.
+Agradecemos também à Universidade de Bern, Suíça, por suportar esse projeto de código livre e por hospedar o site do livro.
 
 Agradecemos ainda à comunidade \sq pelo seu entusiástico suporte ao projeto e pelas informações sobre erros encontrados na primeira edição do livro.
 
-Finalmente agradecemos ao desenvolvedores do \sq por nos darem esse incrível ambiente.
+Finalmente agradecemos aos desenvolvedores do \sq por nos darem esse incrível ambiente.
 
 %=============================================================
 \ifx\wholebook\relax\else