fix: resolve merge conflicts and standardize language across multiple articles

Author: gabifs

1-js/03-code-quality/01-debugging-chrome/article.md

@@ -38,11 +38,7 @@ Se pressionarmos `key:Esc`, um terminal (*Console*) se abrirá abaixo. Assim per
 
 Depois de uma instrução ser executada, o resultado será mostrado logo a seguir.
 
-<<<<<<< HEAD
 Por exemplo, a instrução `1+2` resultará em `3`, enquanto a chamada de função `hello("debugger")` não retornará nada, assim tendo como resultado `undefined`:
-=======
-For example, here `1+2` results in `3`, while the function call `hello("debugger")` returns nothing, so the result is `undefined`:
->>>>>>> d78b01e9833009fab534462e05c03cffc51bf0e3
 
 ![](chrome-sources-console.svg)
 
@@ -66,22 +62,13 @@ Uma lista de *breakpoints* sempre estará disponível no painel à direita. Muit
 - Remover o breakpoint, clicando com o botão direito do mouse e selecionando *Remove*.
 - ...E assim por diante.
 
-<<<<<<< HEAD
 ```smart header="*Breakpoints* condicionais"
 *Clicar com o botão direito do mouse* sobre um número de linha permite a criação de um *breakpoint condicional* o qual será ativado apenas quando a expressão inserida for verdadeira.
-=======
-```smart header="Conditional breakpoints"
-*Right click* on the line number allows to create a *conditional* breakpoint. It only triggers when the given expression, that you should provide when you create it, is truthy.
->>>>>>> d78b01e9833009fab534462e05c03cffc51bf0e3
 
 É prático quando precisamos de suspender a execução apenas para valores determinados de certa variável ou para parâmetros específicos numa função.
 ```
 
-<<<<<<< HEAD
-## O comando *debugger*
-=======
-## The command "debugger"
->>>>>>> d78b01e9833009fab534462e05c03cffc51bf0e3
+## O comando "debugger"
 
 Podemos também suspender o código utilizando o comando `debugger`, desta forma:
 
@@ -97,13 +84,9 @@ function hello(name) {
 }
 ```
 
-<<<<<<< HEAD
 Este comando só irá funcionar quando a interface de ferramentas de desenvolvedor do navegador estiver aberta, caso contrário, será ignorado.
 
 ## Pause e dê uma olhada
-=======
-Such command works only when the development tools are open, otherwise the browser ignores it.
->>>>>>> d78b01e9833009fab534462e05c03cffc51bf0e3
 
 No nosso exemplo, a função `hello()` é chamada durante o carregamento da página, assim a forma mais fácil para ativar o *debugger* (depois de termos colocado os *breakpoints*) seria recarregar a página. Desta forma, vamos pressionar `key:F5` (Windows, Linux) ou `key:Cmd+R` (Mac).
 
@@ -115,11 +98,7 @@ Por favor, abra as secções de *dropdown* informacionais à direita (apontadas
 
 1. **`Watch` -- mostra valores atuais das expressões.**
 
-<<<<<<< HEAD
     É possível clicar no `+` e inserir uma expressão. O *debugger* mostrará o valor da expressão e continuará recalculando-a ao longo do processo de execução.
-=======
-    You can click the plus `+` and input an expression. The debugger will show its value, automatically recalculating it in the process of execution.
->>>>>>> d78b01e9833009fab534462e05c03cffc51bf0e3
 
 2. **`Call Stack` -- mostra a sequência de chamadas de funções aninhadas.**
 
@@ -154,21 +133,12 @@ Existem botões para isso no topo do painel direito. Vamos interagir com eles.
 
     Continuando a clicar nele, passará por todas as instruções do programa, uma por uma.
 
-<<<<<<< HEAD
 <span class="devtools" style="background-position:-62px -192px"></span> -- "Step over": execute o próximo comando, *mas não vá para dentro de uma função*, atalho `key:F10`.
 : Similar ao comando "Step" anterior mas com um comportamento diferente se a próxima instrução for uma chamada de função. Isto é: não uma incorporada (*built-in*), como `alert`, mas uma função nossa.
 
     O comando "Step", vai para dentro dessa função e suspende a execução na sua primeira linha, ao contrário de "Step over" que executa essa chamada de função aninhada de forma invisível para nós, pulando todo seu funcionamento interno.
 
     É feita uma pausa na execução imediatamente depois dessa função.
-=======
-<span class="devtools" style="background-position:-62px -192px"></span> -- "Step over": run the next command, but *don't go into a function*, hotkey `key:F10`.
-: Similar to the previous "Step" command, but behaves differently if the next statement is a function call (not a built-in, like `alert`, but a function of our own).
-
-    If we compare them, the "Step" command goes into a nested function call and pauses the execution at its first line, while "Step over" executes the nested function call invisibly to us, skipping the function internals.
-
-    The execution is then paused immediately after that function call.
->>>>>>> d78b01e9833009fab534462e05c03cffc51bf0e3
 
     É util quando não se está interessado em ver o que acontece dentro da chamada de uma função.
 
@@ -183,13 +153,8 @@ Existem botões para isso no topo do painel direito. Vamos interagir com eles.
 <span class="devtools" style="background-position:-61px -74px"></span> -- ativar/desativar todos os *breakpoints*.
 : Esse botão não move a execução. Simplesmente ativa/desativa *breakpoints* em conjunto.
 
-<<<<<<< HEAD
 <span class="devtools" style="background-position:-90px -146px"></span> -- ativar/desativar a pausa automática em caso de erro.
 : Quando ativo e as ferramentas do desenvolvedor abertas, um erro no código automáticamente suspende a execução do código. Assim permitindo a análise de variáveis para entender o que ocorreu de errado. Desta forma, se o código falhar por um erro, é possível abrir o *debugger*, ativar esta opção e recarregar a página afim de se observar onde e em que contexto a falha ocorreu.
-=======
-<span class="devtools" style="background-position:-90px -146px"></span> -- enable/disable automatic pause in case of an error.
-: When enabled, if the developer tools is open, an error during the script execution automatically pauses it. Then we can analyze variables in the debugger to see what went wrong. So if our script dies with an error, we can open debugger, enable this option and reload the page to see where it dies and what's the context at that moment.
->>>>>>> d78b01e9833009fab534462e05c03cffc51bf0e3
 
 ```smart header="Continue até aqui"
 Ao clicar com o botão direito do mouse sobre uma linha de código, abre-se o menu de contexto com uma ótima opção chamada "Continue até aqui" (*Continue to here*).
@@ -221,11 +186,7 @@ Como podemos ver, existem três formas principais para pausar a execução de um
 2. As instruções `debugger`.
 3. Um erro (se as ferramentas do desenvolvedor [*dev tools*] estiverem abertas, e o botão <span class="devtools" style="background-position:-90px -146px"></span> estiver "ativo").
 
-<<<<<<< HEAD
 Enquanto suspenso, podemos depurar erros - examinar variáveis e rastear o código para ver que parte da execução ocorre com erros.
-=======
-When paused, we can debug: examine variables and trace the code to see where the execution goes wrong.
->>>>>>> d78b01e9833009fab534462e05c03cffc51bf0e3
 
 Existem muitas outras opções nas ferramentas do desenvolvedor além das já cobertas ao longo desta leitura. O manual completo está em <https://developers.google.com/web/tools/chrome-devtools>.
 

1-js/03-code-quality/05-testing-mocha/article.md

@@ -50,60 +50,17 @@ describe("pow", function() {
 
 Uma *spec* tem três principais blocos construtores, como pode ver acima:
 
-<<<<<<< HEAD
 `describe("título", function() { ... })`
 : Que funcionalidade estamos a descrever. No nosso caso, estamos a descrever a função `pow`. São usados para agrupar "executores" ("*workers*") -- os blocos `it`.
-=======
-`describe("title", function() { ... })`
-: What functionality we're describing? In our case we're describing the function `pow`. Used to group "workers" -- the `it` blocks.
->>>>>>> d78b01e9833009fab534462e05c03cffc51bf0e3
 
 `it("descrição do caso exemplo", function() { ... })`
 : No título de `it` nós, *de uma forma claramente legível*, descrevemos o caso exemplo em questão, e no segundo argumento está uma função que o testa.
 
 `assert.equal(valor1, valor2)`
 : O código dentro do bloco `it`, se a implementação estiver correta, não deverá mostrar erros.
 
-<<<<<<< HEAD
 ```text
 Funções `assert.*` são usadas para verificar se `pow` funciona como esperado. Aqui mesmo, estamos a usar uma delas -- `assert.equal`, que compara argumentos e dá como resultado um erro se eles não forem iguais. Aqui, ela verifica se o resultado de `pow(2, 3)` é `8`. Existem outros tipos de comparações e verificações, que adicionaremos mais adiante.
-=======
-    Functions `assert.*` are used to check whether `pow` works as expected. Right here we're using one of them -- `assert.equal`, it compares arguments and yields an error if they are not equal. Here it checks that the result of `pow(2, 3)` equals `8`. There are other types of comparisons and checks, that we'll add later.
-
-The specification can be executed, and it will run the test specified in `it` block. We'll see that later.
-
-## The development flow
-
-The flow of development usually looks like this:
-
-1. An initial spec is written, with tests for the most basic functionality.
-2. An initial implementation is created.
-3. To check whether it works, we run the testing framework [Mocha](https://mochajs.org/) (more details soon) that runs the spec. While the functionality is not complete, errors are displayed. We make corrections until everything works.
-4. Now we have a working initial implementation with tests.
-5. We add more use cases to the spec, probably not yet supported by the implementations. Tests start to fail.
-6. Go to 3, update the implementation till tests give no errors.
-7. Repeat steps 3-6 till the functionality is ready.
-
-So, the development is *iterative*. We write the spec, implement it, make sure tests pass, then write more tests, make sure they work etc. At the end we have both a working implementation and tests for it.
-
-Let's see this development flow in our practical case.
-
-The first step is already complete: we have an initial spec for `pow`. Now, before making the implementation, let's use a few JavaScript libraries to run the tests, just to see that they are working (they will all fail).
-
-## The spec in action
-
-Here in the tutorial we'll be using the following JavaScript libraries for tests:
-
-- [Mocha](https://mochajs.org/) -- the core framework: it provides common testing functions including `describe` and `it` and the main function that runs tests.
-- [Chai](https://www.chaijs.com/) -- the library with many assertions. It allows to use a lot of different assertions, for now we need only `assert.equal`.
-- [Sinon](https://sinonjs.org/) -- a library to spy over functions, emulate built-in functions and more, we'll need it much later.
-
-These libraries are suitable for both in-browser and server-side testing. Here we'll consider the browser variant.
-
-The full HTML page with these frameworks and `pow` spec:
-
-```html src="index.html"
->>>>>>> d78b01e9833009fab534462e05c03cffc51bf0e3
 ```
 
 A especificação pode ser executada, e irá correr o teste especificado no bloco `it`. O que veremos mais adiante.
@@ -385,7 +342,6 @@ Os testes agora adicionados falham, porque a nossa implementação não possui s
 
 ```smart header="Outras asserções"
 
-<<<<<<< HEAD
 Por favor, observe a asserção `assert.isNaN`: ela verifica por `NaN`.
 
 Existem ainda outras asserções em [Chai](http://chaijs.com), como por exemplo:
@@ -396,16 +352,6 @@ Existem ainda outras asserções em [Chai](http://chaijs.com), como por exemplo:
 - `assert.isTrue(valor)` -- verifica se `valor === true`
 - `assert.isFalse(valor)` -- verifica se `valor === false`
 - ...a lista completa está em [docs](http://chaijs.com/api/assert/)
-=======
-There are other assertions in [Chai](https://www.chaijs.com/) as well, for instance:
-
-- `assert.equal(value1, value2)` -- checks the equality  `value1 == value2`.
-- `assert.strictEqual(value1, value2)` -- checks the strict equality `value1 === value2`.
-- `assert.notEqual`, `assert.notStrictEqual` -- inverse checks to the ones above.
-- `assert.isTrue(value)` -- checks that `value === true`
-- `assert.isFalse(value)` -- checks that `value === false`
-- ...the full list is in the [docs](https://www.chaijs.com/api/assert/)
->>>>>>> d78b01e9833009fab534462e05c03cffc51bf0e3
 ```
 
 Assim, nós deveríamos adicionar algumas linhas a `pow`:

1-js/03-code-quality/06-polyfills/article.md

@@ -1,23 +1,13 @@
 
 # Polyfills e transpilers
 
-<<<<<<< HEAD
 A linguagem JavaScript evolui constantemente. Novas propostas para a linguagem aparecem regularmente, elas são analisadas e, se consideradas válidas, são anexadas à lista em <https://tc39.github.io/ecma262/> e depois progridem para a [especificação (en)](https://www.ecma-international.org/publications-and-standards/standards/ecma-262/).
-=======
-The JavaScript language steadily evolves. New proposals to the language appear regularly, they are analyzed and, if considered worthy, are appended to the list at <https://tc39.github.io/ecma262/> and then progress to the [specification](https://www.ecma-international.org/publications-and-standards/standards/ecma-262/).
->>>>>>> d78b01e9833009fab534462e05c03cffc51bf0e3
 
 Grupos por detrás dos interpretadores de JavaScript têm as suas próprias ideias sobre o que implementar primeiro. Eles podem decidir implementar propostas que estão em esboço e adiar coisas que já estão na spec, por serem menos interessantes ou apenas mais difíceis de fazer.
 
-<<<<<<< HEAD
 Assim, é muito comum que um interpretador implemente apenas parte de um padrão.
 
 Uma boa página para se ver o estágio atual de suporte de funcionalidades da linguagem é <https://compat-table.github.io/compat-table/es6/> (é extensa, nós ainda temos muito que estudar).
-=======
-So it's quite common for an engine to implement only part of the standard.
-
-A good page to see the current state of support for language features is <https://compat-table.github.io/compat-table/es6/> (it's big, we have a lot to study yet).
->>>>>>> d78b01e9833009fab534462e05c03cffc51bf0e3
 
 Como programadores, nós gostaríamos de usar as funcionalidades mais recentes. Quantas mais forem as coisas boas - melhor!
 
@@ -50,15 +40,9 @@ Agora, o código reescrito está adequado a interpretadores de JavaScript antigo
 
 Geralmente, um desenvolvedor executa o transpiler na sua própria máquina, e depois coloca o código transpilado no servidor.
 
-<<<<<<< HEAD
 Falando em nomes, o [Babel](https://babeljs.io) é um dos mais prominentes transpilers por aí.
 
 Sistemas para a construção de projetos modernos, tais como o [webpack](https://webpack.js.org/), fornecem meios para automaticamente correr o transpiler em cada alteração do código, e assim é muito fácil o integrar no processo de desenvolvimento.
-=======
-Speaking of names, [Babel](https://babeljs.io) is one of the most prominent transpilers out there.
-
-Modern project build systems, such as [webpack](https://webpack.js.org/), provide a means to run a transpiler automatically on every code change, so it's very easy to integrate into the development process.
->>>>>>> d78b01e9833009fab534462e05c03cffc51bf0e3
 
 ## Polyfills
 
@@ -85,40 +69,20 @@ if (!Math.trunc) { // se a função não existir
 }
 ```
 
-<<<<<<< HEAD
 O JavaScript é uma linguagem altamente dinâmica. Scripts podem adicionar/modificar quaisquer funções, incluindo até incorporadas.
 
-Duas interessantes bibliotecas de polyfills são:
-- [core js](https://github.com/zloirock/core-js) que suporta muitas funcionalidades, e permite apenas incluir aquelas necessárias.
-- [polyfill.io](http://polyfill.io) um serviço que fornece um script com polyfills, dependendo das funcionalidades e do navegador do utilizador.
+Uma biblioteca interessante de polyfill é [core js](https://github.com/zloirock/core-js) que suporta muitas funcionalidades, e permite apenas incluir aquelas necessárias.
 
 ## Resumo
-=======
-JavaScript is a highly dynamic language. Scripts may add/modify any function, even built-in ones.
-
-One interesting polyfill library is [core-js](https://github.com/zloirock/core-js), which supports a wide range of features and allows you to include only the ones you need.
->>>>>>> d78b01e9833009fab534462e05c03cffc51bf0e3
 
 Neste capítulo, gostaríamos de o motivar a estudar funcionalidades modernas ou até em esboço da linguagem, mesmo que elas ainda não tenham um bom suporte pelos interpretadores de JavaScript.
 
 Apenas não se esqueça de usar um transpiler (se empregar sintaxe ou operadores modernos) e polyfills (para adicionar funções que possam estar ausentes). E eles irão garantir que o código funcione.
 
-<<<<<<< HEAD
 Por exemplo, mais adiante quando estiver familiarizado com o JavaScript, você pode configurar um sistema para a construção de código com base no [webpack](https://webpack.js.org/) e com o plugin [babel-loader](https://github.com/babel/babel-loader).
 
 Bons recursos que mostram o estágio atual do suporte para várias funcionalidades:
 - <https://compat-table.github.io/compat-table/es6/> - para puro JavaScript.
 - <https://caniuse.com/> - para funções com relação ao navegador.
-=======
-Just don't forget to use a transpiler (if using modern syntax or operators) and polyfills (to add functions that may be missing). They'll ensure that the code works.
-
-For example, later when you're familiar with JavaScript, you can setup a code build system based on [webpack](https://webpack.js.org/) with the [babel-loader](https://github.com/babel/babel-loader) plugin.
-
-Good resources that show the current state of support for various features:
-- <https://compat-table.github.io/compat-table/es6/> - for pure JavaScript.
-- <https://caniuse.com/> - for browser-related functions.
-
-P.S. Google Chrome is usually the most up-to-date with language features, try it if a tutorial demo fails. Most tutorial demos work with any modern browser though.
->>>>>>> d78b01e9833009fab534462e05c03cffc51bf0e3
 
 P.S. O Google Chrome, geralmente é o mais atualizado relativamente a funcionalidades da linguagem, experimente-o se um exemplo no tutorial falhar. Contudo, a maioria dos exemplos no tutorial funcionam com qualquer navegador moderno.