From a19a7e8dd8c538d92c2729840b7a444fa8a3a111 Mon Sep 17 00:00:00 2001 From: Eduardo Braga Date: Sat, 14 May 2016 15:02:37 -0300 Subject: [PATCH 1/8] =?UTF-8?q?[Eduardo]=20adicionado=20par=C3=A1grafos=20?= =?UTF-8?q?sobre=20tokenizing/lexing=20e=20parsing=20no=20cap=C3=ADtulo=20?= =?UTF-8?q?1.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- WORDREFERENCE.md | 5 ++++- scope & closures/ch1.md | 8 ++++---- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/WORDREFERENCE.md b/WORDREFERENCE.md index cdef5686..06e775a4 100644 --- a/WORDREFERENCE.md +++ b/WORDREFERENCE.md @@ -64,7 +64,7 @@ #### B * Browser: Navegador -* Build (no sentido de processo de unificação): Build +* Build (no sentido de processo de unificação): Build #### C @@ -115,6 +115,7 @@ #### L +* Lexing: Lexing * Linter: Linter @@ -162,6 +163,8 @@ #### T +* Token: Token +* Tokenizing: Tokenizing * Transpiling: Transpiling * Transpiled: *Transpilada* (em *itálico*) * Types: Tipos diff --git a/scope & closures/ch1.md b/scope & closures/ch1.md index 73148c75..f8392483 100644 --- a/scope & closures/ch1.md +++ b/scope & closures/ch1.md @@ -19,13 +19,13 @@ Mas, mesmo assim, o mecanismo do Javascript realiza muitos passos semelhantes, e Em um processo tradicional de uma linguagem compilada, um pedaço de código fonte, seu programa, vai tipicamente passar por três passos *antes* de ser executado, grosseiramente chamado "compilação": -1. **Tokenizing/Lexing:** breaking up a string of characters into meaningful (to the language) chunks, called tokens. For instance, consider the program: `var a = 2;`. This program would likely be broken up into the following tokens: `var`, `a`, `=`, `2`, and `;`. Whitespace may or may not be persisted as a token, depending on whether it's meaningful or not. +1. **Tokenizing/Lexing:** quebrar uma string de caracteres em pedaços com algum significado (para a linguagem), chamados tokens. Por exemplo, considere o programa: `var a = 2;`. Esse programa provavelmente seria ser quebrado nos seguintes tokens: `var`, `a`, `=`, `2`, e `;`. Espaço em branco pode ou não ser mantido como um token, dependendo se tem ou não algum significado. - **Note:** The difference between tokenizing and lexing is subtle and academic, but it centers on whether or not these tokens are identified in a *stateless* or *stateful* way. Put simply, if the tokenizer were to invoke stateful parsing rules to figure out whether `a` should be considered a distinct token or just part of another token, *that* would be **lexing**. + **Nota:** A diferença entre tokenizing e lexing é sutil e teórica, mas centraliza-se no fato desses tokens serem ou não identificados de uma maneira *stateless* ou *stateful*. Colocando de maneira simples, se o tokenizer fosse invocar regras de análise stateful para saber se `a` deve ser considerado um token distinto ou apenas parte de outro token, *isso* seria **lexing**. -2. **Parsing:** taking a stream (array) of tokens and turning it into a tree of nested elements, which collectively represent the grammatical structure of the program. This tree is called an "AST" (Abstract Syntax Tree). +2. **Parsing:** pegar um conjunto (array) de tokens e transformar isso numa árvore de elementos aninhados, que juntos representam a estrutura gramática do programa. Essa árvore é conhecida como "AST" (Arvore Sintática Abstrata). - The tree for `var a = 2;` might start with a top-level node called `VariableDeclaration`, with a child node called `Identifier` (whose value is `a`), and another child called `AssignmentExpression` which itself has a child called `NumericLiteral` (whose value is `2`). + A árvore para `var a = 2;` pode começar com um nó de nível superior chamado `VariableDeclaration`, que tem um nó filho chamado `Identifier` (cujo valor é `a`), e outro nó filho chamado `AssignmentExpression` que por sua vez tem um filho chamado `NumericLiteral` (cujo valor é `2`). 3. **Code-Generation:** the process of taking an AST and turning it into executable code. This part varies greatly depending on the language, the platform it's targeting, etc. From 3179159fb3b304c035a43e09c7504bfc6d17e60b Mon Sep 17 00:00:00 2001 From: Eduardo Braga Date: Sat, 14 May 2016 18:56:47 -0300 Subject: [PATCH 2/8] =?UTF-8?q?[Eduardo]=20adicionado=20mais=20uns=20par?= =?UTF-8?q?=C3=A1grafos=20sobre=20etapas=20de=20compila=C3=A7=C3=A3o=20JS.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- scope & closures/ch1.md | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/scope & closures/ch1.md b/scope & closures/ch1.md index f8392483..52b53b2c 100644 --- a/scope & closures/ch1.md +++ b/scope & closures/ch1.md @@ -27,21 +27,21 @@ Em um processo tradicional de uma linguagem compilada, um pedaço de código fon A árvore para `var a = 2;` pode começar com um nó de nível superior chamado `VariableDeclaration`, que tem um nó filho chamado `Identifier` (cujo valor é `a`), e outro nó filho chamado `AssignmentExpression` que por sua vez tem um filho chamado `NumericLiteral` (cujo valor é `2`). -3. **Code-Generation:** the process of taking an AST and turning it into executable code. This part varies greatly depending on the language, the platform it's targeting, etc. +3. **Geração de código:** o processo de obter uma AST e transformar isso em código executável. Esta parte varia muito dependendo da linguagem, da plataforma-alvo, etc. - So, rather than get mired in details, we'll just handwave and say that there's a way to take our above described AST for `var a = 2;` and turn it into a set of machine instructions to actually *create* a variable called `a` (including reserving memory, etc.), and then store a value into `a`. + Então, em vez de focar em detalhes, nós vamos apenas olhar superficialmente e dizer que existe uma forma de obter nossa AST descrita acima para `var a = 2;` e transformá-la em instruções de máquina para de fato *criar* uma variável chamada `a` (incluindo a reserva de memória, etc), e então armazenar um valor em `a`. - **Note:** The details of how the engine manages system resources are deeper than we will dig, so we'll just take it for granted that the engine is able to create and store variables as needed. + **Note:** Os detalhes de como o mecanismo administra recursos do sistema estão além do que iremos cobrir, então nós vamos apenas considerar que esse mecanismo é capaz de criar e armazenar variáveis conforme necessário. -The JavaScript engine is vastly more complex than *just* those three steps, as are most other language compilers. For instance, in the process of parsing and code-generation, there are certainly steps to optimize the performance of the execution, including collapsing redundant elements, etc. +O mecanismo de Javascript é vastamente mais complexo do que *apenas* aqueles três passos, da mesma maneira do que os outros compiladores. Por exemplo, no processo de análise e geração de código, há com certeza passos para otimizar o desempenho da execução, incluindo tratar elementos redundantes, etc. -So, I'm painting only with broad strokes here. But I think you'll see shortly why *these* details we *do* cover, even at a high level, are relevant. +Então, eu estou mostrando de forma bem grosseira aqui. Mas eu acho que vocês verão rapidamente porque *esses* detalhes que nós *cobrimos*, mesmo que superficialmente, são relevantes. -For one thing, JavaScript engines don't get the luxury (like other language compilers) of having plenty of time to optimize, because JavaScript compilation doesn't happen in a build step ahead of time, as with other languages. +Por um lado, o mecanismo de Javascript não tem o luxo (como compiladores de outras linguagens) de ter uma grande disponibilidade de tempo para otimização, porque a compilação de Javascript não acontece numa etapa de preparação anterior, como em outras linguagens. -For JavaScript, the compilation that occurs happens, in many cases, mere microseconds (or less!) before the code is executed. To ensure the fastest performance, JS engines use all kinds of tricks (like JITs, which lazy compile and even hot re-compile, etc.) which are well beyond the "scope" of our discussion here. +Para Javascript, a compilação que ocorre acontece, em muitos casos, somente alguns microsegundos (ou menos!) antes do código ser executado. Para garantir o mais alto desempenho, o mecanismo JS utiliza todos os tipos de truques (como JITs, que compilam de maneira preguiçosa e até mesmo recompilam rapidamente, etc.) que são além do escopo da nossa discussão aqui. -Let's just say, for simplicity's sake, that any snippet of JavaScript has to be compiled before (usually *right* before!) it's executed. So, the JS compiler will take the program `var a = 2;` and compile it *first*, and then be ready to execute it, usually right away. +Vamos apenas dizer, para fins de simplicidade, que qualquer pedaço de Javascript tem que ser compilado antes (geralmente *exatamente* como dito antes!) de ser executado. Então, o compilador JS vai obter o programa `var a = 2;` e compilá-lo *antes*, e então estará pronto para executá-lo, de imediato. ## Understanding Scope From f16bb00a3ba4566593d324656befe237460a9a7a Mon Sep 17 00:00:00 2001 From: Eduardo Braga Date: Sun, 15 May 2016 17:11:13 -0300 Subject: [PATCH 3/8] =?UTF-8?q?[Eduardo]=20adicionado=20mais=20um=20par?= =?UTF-8?q?=C3=A1grafo=20sobre=20os=20participantes=20do=20processo=20de?= =?UTF-8?q?=20compila=C3=A7=C3=A3o.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- scope & closures/ch1.md | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/scope & closures/ch1.md b/scope & closures/ch1.md index 52b53b2c..8e41cbf7 100644 --- a/scope & closures/ch1.md +++ b/scope & closures/ch1.md @@ -43,21 +43,21 @@ Para Javascript, a compilação que ocorre acontece, em muitos casos, somente al Vamos apenas dizer, para fins de simplicidade, que qualquer pedaço de Javascript tem que ser compilado antes (geralmente *exatamente* como dito antes!) de ser executado. Então, o compilador JS vai obter o programa `var a = 2;` e compilá-lo *antes*, e então estará pronto para executá-lo, de imediato. -## Understanding Scope +## Entendendo Escopo -The way we will approach learning about scope is to think of the process in terms of a conversation. But, *who* is having the conversation? +A forma como nós vamos abordar o aprendizado sobre escopo é imaginar o processo como uma conversa. Mas, *quem* está tendo essa conversa? -### The Cast +### O Elenco -Let's meet the cast of characters that interact to process the program `var a = 2;`, so we understand their conversations that we'll listen in on shortly: +Vamos conhecer o elenco dos personagens que interagem para processar o programa `var a = 2;`, assim entenderemos a conversa que vamos ouvir em breve: -1. *Engine*: responsible for start-to-finish compilation and execution of our JavaScript program. +1. *Mecanismo*: responsável pela compilação do começo ao fim e pela execução do nosso programa Javascript. -2. *Compiler*: one of *Engine*'s friends; handles all the dirty work of parsing and code-generation (see previous section). +2. *Compilador*: um dos amigos do *Mecanismo*; gerencia todo o trabalho sujo da análise e da geração de código (veja a seção anterior). -3. *Scope*: another friend of *Engine*; collects and maintains a look-up list of all the declared identifiers (variables), and enforces a strict set of rules as to how these are accessible to currently executing code. +3. *Escopo*: outro amigo do *Mecanismo*; coleta e mantém uma lista de consultas a todos os identificadores declarados (variáveis), e impõe um rigoroso conjunto de regras sobre a maneira como estes identificadores são acessíveis pelo código que está em execução. -For you to *fully understand* how JavaScript works, you need to begin to *think* like *Engine* (and friends) think, ask the questions they ask, and answer those questions the same. +Para o seu *completo entendimento* sobre como Javascript funciona, você precisa começar a *pensar* como o *Mecanismo* (e amigos) pensa, fazer as perguntas que eles fazem, e responder essas perguntas. ### Back & Forth From 4ead6a869207603953737a3d907f0ae9f0640b6c Mon Sep 17 00:00:00 2001 From: Eduardo Braga Date: Sat, 14 May 2016 15:02:37 -0300 Subject: [PATCH 4/8] =?UTF-8?q?[Eduardo]=20adicionado=20par=C3=A1grafos=20?= =?UTF-8?q?sobre=20tokenizing/lexing=20e=20parsing=20no=20cap=C3=ADtulo=20?= =?UTF-8?q?1.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- WORDREFERENCE.md | 5 ++++- scope & closures/ch1.md | 8 ++++---- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/WORDREFERENCE.md b/WORDREFERENCE.md index cdef5686..06e775a4 100644 --- a/WORDREFERENCE.md +++ b/WORDREFERENCE.md @@ -64,7 +64,7 @@ #### B * Browser: Navegador -* Build (no sentido de processo de unificação): Build +* Build (no sentido de processo de unificação): Build #### C @@ -115,6 +115,7 @@ #### L +* Lexing: Lexing * Linter: Linter @@ -162,6 +163,8 @@ #### T +* Token: Token +* Tokenizing: Tokenizing * Transpiling: Transpiling * Transpiled: *Transpilada* (em *itálico*) * Types: Tipos diff --git a/scope & closures/ch1.md b/scope & closures/ch1.md index 73148c75..f8392483 100644 --- a/scope & closures/ch1.md +++ b/scope & closures/ch1.md @@ -19,13 +19,13 @@ Mas, mesmo assim, o mecanismo do Javascript realiza muitos passos semelhantes, e Em um processo tradicional de uma linguagem compilada, um pedaço de código fonte, seu programa, vai tipicamente passar por três passos *antes* de ser executado, grosseiramente chamado "compilação": -1. **Tokenizing/Lexing:** breaking up a string of characters into meaningful (to the language) chunks, called tokens. For instance, consider the program: `var a = 2;`. This program would likely be broken up into the following tokens: `var`, `a`, `=`, `2`, and `;`. Whitespace may or may not be persisted as a token, depending on whether it's meaningful or not. +1. **Tokenizing/Lexing:** quebrar uma string de caracteres em pedaços com algum significado (para a linguagem), chamados tokens. Por exemplo, considere o programa: `var a = 2;`. Esse programa provavelmente seria ser quebrado nos seguintes tokens: `var`, `a`, `=`, `2`, e `;`. Espaço em branco pode ou não ser mantido como um token, dependendo se tem ou não algum significado. - **Note:** The difference between tokenizing and lexing is subtle and academic, but it centers on whether or not these tokens are identified in a *stateless* or *stateful* way. Put simply, if the tokenizer were to invoke stateful parsing rules to figure out whether `a` should be considered a distinct token or just part of another token, *that* would be **lexing**. + **Nota:** A diferença entre tokenizing e lexing é sutil e teórica, mas centraliza-se no fato desses tokens serem ou não identificados de uma maneira *stateless* ou *stateful*. Colocando de maneira simples, se o tokenizer fosse invocar regras de análise stateful para saber se `a` deve ser considerado um token distinto ou apenas parte de outro token, *isso* seria **lexing**. -2. **Parsing:** taking a stream (array) of tokens and turning it into a tree of nested elements, which collectively represent the grammatical structure of the program. This tree is called an "AST" (Abstract Syntax Tree). +2. **Parsing:** pegar um conjunto (array) de tokens e transformar isso numa árvore de elementos aninhados, que juntos representam a estrutura gramática do programa. Essa árvore é conhecida como "AST" (Arvore Sintática Abstrata). - The tree for `var a = 2;` might start with a top-level node called `VariableDeclaration`, with a child node called `Identifier` (whose value is `a`), and another child called `AssignmentExpression` which itself has a child called `NumericLiteral` (whose value is `2`). + A árvore para `var a = 2;` pode começar com um nó de nível superior chamado `VariableDeclaration`, que tem um nó filho chamado `Identifier` (cujo valor é `a`), e outro nó filho chamado `AssignmentExpression` que por sua vez tem um filho chamado `NumericLiteral` (cujo valor é `2`). 3. **Code-Generation:** the process of taking an AST and turning it into executable code. This part varies greatly depending on the language, the platform it's targeting, etc. From e8c18c62b279037ee618c356e3d20be2b93e47b5 Mon Sep 17 00:00:00 2001 From: Eduardo Braga Date: Sat, 14 May 2016 18:56:47 -0300 Subject: [PATCH 5/8] =?UTF-8?q?[Eduardo]=20adicionado=20mais=20uns=20par?= =?UTF-8?q?=C3=A1grafos=20sobre=20etapas=20de=20compila=C3=A7=C3=A3o=20JS.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- scope & closures/ch1.md | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/scope & closures/ch1.md b/scope & closures/ch1.md index f8392483..52b53b2c 100644 --- a/scope & closures/ch1.md +++ b/scope & closures/ch1.md @@ -27,21 +27,21 @@ Em um processo tradicional de uma linguagem compilada, um pedaço de código fon A árvore para `var a = 2;` pode começar com um nó de nível superior chamado `VariableDeclaration`, que tem um nó filho chamado `Identifier` (cujo valor é `a`), e outro nó filho chamado `AssignmentExpression` que por sua vez tem um filho chamado `NumericLiteral` (cujo valor é `2`). -3. **Code-Generation:** the process of taking an AST and turning it into executable code. This part varies greatly depending on the language, the platform it's targeting, etc. +3. **Geração de código:** o processo de obter uma AST e transformar isso em código executável. Esta parte varia muito dependendo da linguagem, da plataforma-alvo, etc. - So, rather than get mired in details, we'll just handwave and say that there's a way to take our above described AST for `var a = 2;` and turn it into a set of machine instructions to actually *create* a variable called `a` (including reserving memory, etc.), and then store a value into `a`. + Então, em vez de focar em detalhes, nós vamos apenas olhar superficialmente e dizer que existe uma forma de obter nossa AST descrita acima para `var a = 2;` e transformá-la em instruções de máquina para de fato *criar* uma variável chamada `a` (incluindo a reserva de memória, etc), e então armazenar um valor em `a`. - **Note:** The details of how the engine manages system resources are deeper than we will dig, so we'll just take it for granted that the engine is able to create and store variables as needed. + **Note:** Os detalhes de como o mecanismo administra recursos do sistema estão além do que iremos cobrir, então nós vamos apenas considerar que esse mecanismo é capaz de criar e armazenar variáveis conforme necessário. -The JavaScript engine is vastly more complex than *just* those three steps, as are most other language compilers. For instance, in the process of parsing and code-generation, there are certainly steps to optimize the performance of the execution, including collapsing redundant elements, etc. +O mecanismo de Javascript é vastamente mais complexo do que *apenas* aqueles três passos, da mesma maneira do que os outros compiladores. Por exemplo, no processo de análise e geração de código, há com certeza passos para otimizar o desempenho da execução, incluindo tratar elementos redundantes, etc. -So, I'm painting only with broad strokes here. But I think you'll see shortly why *these* details we *do* cover, even at a high level, are relevant. +Então, eu estou mostrando de forma bem grosseira aqui. Mas eu acho que vocês verão rapidamente porque *esses* detalhes que nós *cobrimos*, mesmo que superficialmente, são relevantes. -For one thing, JavaScript engines don't get the luxury (like other language compilers) of having plenty of time to optimize, because JavaScript compilation doesn't happen in a build step ahead of time, as with other languages. +Por um lado, o mecanismo de Javascript não tem o luxo (como compiladores de outras linguagens) de ter uma grande disponibilidade de tempo para otimização, porque a compilação de Javascript não acontece numa etapa de preparação anterior, como em outras linguagens. -For JavaScript, the compilation that occurs happens, in many cases, mere microseconds (or less!) before the code is executed. To ensure the fastest performance, JS engines use all kinds of tricks (like JITs, which lazy compile and even hot re-compile, etc.) which are well beyond the "scope" of our discussion here. +Para Javascript, a compilação que ocorre acontece, em muitos casos, somente alguns microsegundos (ou menos!) antes do código ser executado. Para garantir o mais alto desempenho, o mecanismo JS utiliza todos os tipos de truques (como JITs, que compilam de maneira preguiçosa e até mesmo recompilam rapidamente, etc.) que são além do escopo da nossa discussão aqui. -Let's just say, for simplicity's sake, that any snippet of JavaScript has to be compiled before (usually *right* before!) it's executed. So, the JS compiler will take the program `var a = 2;` and compile it *first*, and then be ready to execute it, usually right away. +Vamos apenas dizer, para fins de simplicidade, que qualquer pedaço de Javascript tem que ser compilado antes (geralmente *exatamente* como dito antes!) de ser executado. Então, o compilador JS vai obter o programa `var a = 2;` e compilá-lo *antes*, e então estará pronto para executá-lo, de imediato. ## Understanding Scope From d409835bec31b00c23833e6290d81533c1cb9a85 Mon Sep 17 00:00:00 2001 From: Eduardo Braga Date: Sun, 15 May 2016 17:11:13 -0300 Subject: [PATCH 6/8] =?UTF-8?q?[Eduardo]=20adicionado=20mais=20um=20par?= =?UTF-8?q?=C3=A1grafo=20sobre=20os=20participantes=20do=20processo=20de?= =?UTF-8?q?=20compila=C3=A7=C3=A3o.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- scope & closures/ch1.md | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/scope & closures/ch1.md b/scope & closures/ch1.md index 52b53b2c..8e41cbf7 100644 --- a/scope & closures/ch1.md +++ b/scope & closures/ch1.md @@ -43,21 +43,21 @@ Para Javascript, a compilação que ocorre acontece, em muitos casos, somente al Vamos apenas dizer, para fins de simplicidade, que qualquer pedaço de Javascript tem que ser compilado antes (geralmente *exatamente* como dito antes!) de ser executado. Então, o compilador JS vai obter o programa `var a = 2;` e compilá-lo *antes*, e então estará pronto para executá-lo, de imediato. -## Understanding Scope +## Entendendo Escopo -The way we will approach learning about scope is to think of the process in terms of a conversation. But, *who* is having the conversation? +A forma como nós vamos abordar o aprendizado sobre escopo é imaginar o processo como uma conversa. Mas, *quem* está tendo essa conversa? -### The Cast +### O Elenco -Let's meet the cast of characters that interact to process the program `var a = 2;`, so we understand their conversations that we'll listen in on shortly: +Vamos conhecer o elenco dos personagens que interagem para processar o programa `var a = 2;`, assim entenderemos a conversa que vamos ouvir em breve: -1. *Engine*: responsible for start-to-finish compilation and execution of our JavaScript program. +1. *Mecanismo*: responsável pela compilação do começo ao fim e pela execução do nosso programa Javascript. -2. *Compiler*: one of *Engine*'s friends; handles all the dirty work of parsing and code-generation (see previous section). +2. *Compilador*: um dos amigos do *Mecanismo*; gerencia todo o trabalho sujo da análise e da geração de código (veja a seção anterior). -3. *Scope*: another friend of *Engine*; collects and maintains a look-up list of all the declared identifiers (variables), and enforces a strict set of rules as to how these are accessible to currently executing code. +3. *Escopo*: outro amigo do *Mecanismo*; coleta e mantém uma lista de consultas a todos os identificadores declarados (variáveis), e impõe um rigoroso conjunto de regras sobre a maneira como estes identificadores são acessíveis pelo código que está em execução. -For you to *fully understand* how JavaScript works, you need to begin to *think* like *Engine* (and friends) think, ask the questions they ask, and answer those questions the same. +Para o seu *completo entendimento* sobre como Javascript funciona, você precisa começar a *pensar* como o *Mecanismo* (e amigos) pensa, fazer as perguntas que eles fazem, e responder essas perguntas. ### Back & Forth From 50df0ccbe3004ae6c8d366ce14987093aea1dac1 Mon Sep 17 00:00:00 2001 From: Eduardo Braga Date: Sun, 15 May 2016 19:33:51 -0300 Subject: [PATCH 7/8] [Eduardo] fix typo. --- scope & closures/ch1.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scope & closures/ch1.md b/scope & closures/ch1.md index 8e41cbf7..edf8122d 100644 --- a/scope & closures/ch1.md +++ b/scope & closures/ch1.md @@ -3,7 +3,7 @@ Um dos paradigmas mais fundamentais de quase todas as linguagens de programação é a capacidade de armazenar valores em variáveis e, posteriormente, obter ou modificar esses valores. Na verdade, a habilidade de armazenar e pegar valores de variáveis é o que fornece *estado* a um programa. -Sem esse conceito, um progrma pode realizar algumas tarefas, mas elas seriam extremamente limitadas e extremamente desinteressantes. +Sem esse conceito, um programa pode realizar algumas tarefas, mas elas seriam extremamente limitadas e extremamente desinteressantes. Mas a inclusão de variáveis em nossos programas gera perguntas mais interessantes como: onde essas variáveis *vivem*? Em outras palavras, onde elas são armazenadas? E, mais importante, como nossos programas as encontram quando eles precisam delas? From 9a9d2eed9d4bb8fd07cbc1ef47315f4d927499c6 Mon Sep 17 00:00:00 2001 From: Eduardo Braga Date: Mon, 16 May 2016 20:27:06 -0300 Subject: [PATCH 8/8] =?UTF-8?q?[Eduardo]=20aplicadas=20corre=C3=A7=C3=B5es?= =?UTF-8?q?=20sugeridas=20por=20Cezar.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- scope & closures/ch1.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/scope & closures/ch1.md b/scope & closures/ch1.md index edf8122d..6e751abe 100644 --- a/scope & closures/ch1.md +++ b/scope & closures/ch1.md @@ -23,7 +23,7 @@ Em um processo tradicional de uma linguagem compilada, um pedaço de código fon **Nota:** A diferença entre tokenizing e lexing é sutil e teórica, mas centraliza-se no fato desses tokens serem ou não identificados de uma maneira *stateless* ou *stateful*. Colocando de maneira simples, se o tokenizer fosse invocar regras de análise stateful para saber se `a` deve ser considerado um token distinto ou apenas parte de outro token, *isso* seria **lexing**. -2. **Parsing:** pegar um conjunto (array) de tokens e transformar isso numa árvore de elementos aninhados, que juntos representam a estrutura gramática do programa. Essa árvore é conhecida como "AST" (Arvore Sintática Abstrata). +2. **Parsing:** pegar um conjunto (array) de tokens e transformar isso numa árvore de elementos aninhados, que juntos representam a estrutura gramática do programa. Essa árvore é conhecida como "AST" (Abstract Syntax Tree, que, em tradução livre, significa: Árvore Sintática Abstrata). A árvore para `var a = 2;` pode começar com um nó de nível superior chamado `VariableDeclaration`, que tem um nó filho chamado `Identifier` (cujo valor é `a`), e outro nó filho chamado `AssignmentExpression` que por sua vez tem um filho chamado `NumericLiteral` (cujo valor é `2`). @@ -31,17 +31,17 @@ Em um processo tradicional de uma linguagem compilada, um pedaço de código fon Então, em vez de focar em detalhes, nós vamos apenas olhar superficialmente e dizer que existe uma forma de obter nossa AST descrita acima para `var a = 2;` e transformá-la em instruções de máquina para de fato *criar* uma variável chamada `a` (incluindo a reserva de memória, etc), e então armazenar um valor em `a`. - **Note:** Os detalhes de como o mecanismo administra recursos do sistema estão além do que iremos cobrir, então nós vamos apenas considerar que esse mecanismo é capaz de criar e armazenar variáveis conforme necessário. + **Nota:** Os detalhes de como o mecanismo administra recursos do sistema estão além do que iremos cobrir, então nós vamos apenas considerar que esse mecanismo é capaz de criar e armazenar variáveis conforme necessário. -O mecanismo de Javascript é vastamente mais complexo do que *apenas* aqueles três passos, da mesma maneira do que os outros compiladores. Por exemplo, no processo de análise e geração de código, há com certeza passos para otimizar o desempenho da execução, incluindo tratar elementos redundantes, etc. +O mecanismo de Javascript é vastamente mais complexo do que *apenas* aqueles três passos, da mesma maneira do que outros compiladores de linguagem. Por exemplo, no processo de análise e geração de código, há com certeza passos para otimizar o desempenho da execução, incluindo tratar elementos redundantes, etc. -Então, eu estou mostrando de forma bem grosseira aqui. Mas eu acho que vocês verão rapidamente porque *esses* detalhes que nós *cobrimos*, mesmo que superficialmente, são relevantes. +Sendo assim, eu estou mostrando de forma bem grosseira aqui. Mas eu acho que vocês verão rapidamente porque *esses* detalhes que nós *cobrimos*, mesmo que superficialmente, são relevantes. Por um lado, o mecanismo de Javascript não tem o luxo (como compiladores de outras linguagens) de ter uma grande disponibilidade de tempo para otimização, porque a compilação de Javascript não acontece numa etapa de preparação anterior, como em outras linguagens. Para Javascript, a compilação que ocorre acontece, em muitos casos, somente alguns microsegundos (ou menos!) antes do código ser executado. Para garantir o mais alto desempenho, o mecanismo JS utiliza todos os tipos de truques (como JITs, que compilam de maneira preguiçosa e até mesmo recompilam rapidamente, etc.) que são além do escopo da nossa discussão aqui. -Vamos apenas dizer, para fins de simplicidade, que qualquer pedaço de Javascript tem que ser compilado antes (geralmente *exatamente* como dito antes!) de ser executado. Então, o compilador JS vai obter o programa `var a = 2;` e compilá-lo *antes*, e então estará pronto para executá-lo, de imediato. +Vamos apenas dizer, para fins de simplicidade, que qualquer pedaço de Javascript tem que ser compilado antes (geralmente *logo antes* como dito anteriormente!) de ser executado. Sendo assim, o compilador JS vai obter o programa `var a = 2;` e compilá-lo *antes*, e então estará pronto para executá-lo, geralmente de imediato. ## Entendendo Escopo @@ -57,7 +57,7 @@ Vamos conhecer o elenco dos personagens que interagem para processar o programa 3. *Escopo*: outro amigo do *Mecanismo*; coleta e mantém uma lista de consultas a todos os identificadores declarados (variáveis), e impõe um rigoroso conjunto de regras sobre a maneira como estes identificadores são acessíveis pelo código que está em execução. -Para o seu *completo entendimento* sobre como Javascript funciona, você precisa começar a *pensar* como o *Mecanismo* (e amigos) pensa, fazer as perguntas que eles fazem, e responder essas perguntas. +Para o seu *completo entendimento* sobre como Javascript funciona, você precisa começar a *pensar* como o *Mecanismo* (e seus amigos) pensa, fazer as perguntas que eles fazem, e responder essas perguntas. ### Back & Forth