text:
# Node.js - Aula 01 - Exercício

**user:** [victorvoid](https://github.com/VictorVoid)

**autor:** Victor Igor Gomes Martins

**date:** 1453957583405

## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.

###Sícrono
![](http://images.123gifs.net/20151111/waiting-in-lines-queue-switching-fail-funny-400x320.gif)

O processo sícrono no Node.js é muito simples de entender, e pode ser resumido em uma palavra: **fila**.
Isso mesmo, sabe aquela fila desgraçada do banco que você precisa esperar ? Isso acontece porque não tem
como atender todos de uma vez quando só se tem uma ou duas pessoa para atender. Quando uma função só é executada depois que anterior for finalizada, é um processo asícrono.

####Exemplo?
```js
function calango (){
  console.log("Olá calanguito");
}
function crocodilo(){
  console.log("vou te lamber calanguito");
}
calango();
crocodilo();
```

###Assícrono

Qualquer função por padrão do nodejs é assícrono! Mas o que é esse assícrono ?

![](http://www.gifbin.com/bin/4sw0swsw4sw2sw3.gif)

Nenhuma leitura ou escrita vai esperar terminar seu processo pra continuar fazendo o resto do script, que loucura não ?
Ele vai fazer várias coisas possível ao mesmo tempo. Pense em um salão de cabeleireiro, sabe quando a mulher vai pra lá e passa horas ? ali pode acontecer alguma coisa assícrono, paralelamente, por exemplo, fazendo escova no cabelo, outra pessoa fazendo a unha da mão e outra do pé, ou seja, ela não espera a pessoa secar seu cabelo para fazer as unhas, enquanto o cabelo termina de ser secado, ela já está fazendo as unhas. Isso acontece no Node.js através de callbacks, e enquanto estão sendo executados, o script seguinte também já estão.

####Como acontece ?

Uma das características dele é que trabalha com single thread, isso economiza muita memória por exemplo, isso é gerenciado
através do *Event Loop*, que é uma fila de processo infinita, sabe a fila de processo que quer ser executada ? cada um entra no event loop, e não faz a execução por completo, ele manda executar (lembra das callback ? isso mesmo), e assim não fica esperando nada, manda pra quem é responsável, e como o processo é assícrono não deixa o processo seguinte bloqueado.

####Exemplo ?

```js
'use strict';

var fs = require('fs');

fs.exists('./index.txt', (exist)=> {
    console.log(exist ? 'existe': 'não existe');
});
/*como acontece de forma assícrono, ele mandou verificar se o arquivo existe, enquanto isso ele
já executou o console abaixo:*/
console.log("ola");
```

Veja essa pequena demonstração do uso das duas e perceba a diferença de velocidade:

[Síncrono X assíncrono](https://www.youtube.com/watch?v=-43EEc3C3cA)

## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.

![](http://runtimejs.org/jsconf/img/runtimejs-arch.png)

## Qual a diferença entre um sistema single para um multi-thread?

Uma Thread é um caminho de execução através do programa, e com a single thread, há sempre um único caminho
de execução e a multi-thread existem dois ou mais encadeamentos.

`Single Thread`: Essa é a característica do Node.js, pois trabalha apenas com single thread, e assim economizando muito mais memória e CPU que o sistema multi-thread, pois por exemplo você não precisa ficar criando um processo novo para cada usuário
conectado. Quem gerencia essa bruxaria é o *Event Loop* de quem já falei sobre.

`Multi Thread` : Ele tem capacidade de executar vários processos(aplicações) ao mesmo tempo, o sistema operacional por exemplo que cuida disso. O que *Multi-Thread* permite é simultaneidade dentro de um aplicativo.

####Exemplo na programação:

*Single Thread*:

Faça X
Faça Y
Faça Z

*Multi-Thread*:

Faça X e Y
Faça Z

## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?

Sempre que ultrapassar ele ficará no Idle Thread esperando a libeção de alguma requisição para aí sim
ir para a Thread Pool.

## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?

Chefe, você quer fazer algo mais rápido com menos programadores e ainda sim ter uma aplicação 2 vezes mais rápida ?
Conhece a PaylPal não é ? Um simples sistema que roda no mundo todo (^___^), jogou todo seu sistema de java fora
e fizeram em Node.js mas depois deram dados de que ficou 2 vezes mais rápido e com menos pessoas trabalhando no projeto
que loucura não é ? E tem várias empresas por ae trocando pro Node.js, uma das últimas ae foi a Netflix que trocou tudo pra Node. O LinkedIn, Skype, Walmart, e muitas outras usam Node.

## Qual a versão do seu `node`?

> node -v

v5.4.1

## Qual a versão do seu `npm`?

> npm --version

3.3.12


text:
# Node.js - Aula 01 - Exercício
**user:** [vitorcapretz](https://github.com/vitorcapretz)

**autor:** Vitor Capretz
**date:** 1465753167158

## 1. Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.

No processo síncrono, há uma espera para que o processo seja finalizado antes que outros processamentos se iniciem.

```js
// Exemplo Síncrono
fs.writeFileSync('teste.txt', 'Teste de síncrono');
console.log('Função síncrona já foi executada e finalizada antes desse disparo');

```

No processo assíncrono não há uma espera para que o processo seja finalizado, o código é responsável por enviar uma requisição, por exemplo, e ficar aguardando um sinal de que o processo foi concluído. Durante este tempo de espera outros processos são executados em paralelo.

```js
// Exemplo assíncrono (Mongoose)
Model.findOne(query, function (err, retorno){
  console.log('Função executada e callback (retorno) disparado.');
});

```

## 2. Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.

O V8 funciona quase que como uma máquina virtual. Ele compila o código JavaScript em linguagem de máquina para ser executado de forma mais eficiente/rápida.

![exemplo_v8](https://qph.is.quoracdn.net/main-qimg-ab2a954b51c404efe66cdc7681da6b85)

## 3. Qual a diferença entre um sistema single para um multi-thread?

O sistema single-thread trabalha com uma tarefa por vez, as tarefas posteriores deverão esperar o término das anteriores para que sejam executadas.

Quanto ao sistema multi-thread, ele funciona dividindo as tarefas no processamento, de forma a executar mais delas simultaneamente.

Exemplo:

* Single Thread (todas as tarefas no mesmo processador)
```
Tarefa 1
Tarefa 2
Tarefa 3
Tarefa 4
Tarefa 5
Tarefa 6
```

* Multi Thread (tarefas divididas no processador)
```
Tarefa 1
Tarefa 2

Tarefa 3
Tarefa 4

Tarefa 5
Tarefa 6
```
## 4. Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?

No caso da requisição 5 e possíveis requisições subsequentes, estas ficariam na fila de Tasks (`Task Queue`) até que uma das outras tarefas em execução seja finalizada, liberando outro espaço na Thread Pool.

## 5. Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?

O Node.js já começa com a vantagem de que (muito provavelmente) o desenvolvedor já conhece Javascript, seja para validações de formulário, seja por meio da biblioteca jQuery ou por alguma outra framework front-end. Muitas aplicações hoje em dia já possuem uma API REST-ful e com isso, dados em formato de JSON sendo enviados/recebidos. Dessa forma, o desenvolvedor poderia usar Node para facilitar na "tradução" desse JSON, já que server e client-side entenderiam o mesmo tipo de objeto.

Como o Node funciona com a engine V8, que compila o código em linguagem de máquina, ele é muito rápido. E além de ser rápido, o processamento assíncrono para requisições I/O favorece a execução do código de forma mais eficaz.

O Node possui o `npm`, que é um gerenciador de pacotes com vários deles desenvolvidos pela comunidade para facilitar e disponibilizar muitos recursos para o desenvolvimento mais eficiente.

Para que a facilidade de comunicação se torne ainda melhor, há a possibilidade de usar Mongo, e com isso, você terá um sistema completo usando apenas uma linguagem de programação. Ajudando na economia de tempo e dinheiro.

## 6. Qual a versão do seu `node`?

```
vitor@vitor-ThinkPad-T440:~$ node -v
v6.2.0
```

## 7. Qual a versão do seu `npm`?

```
vitor@vitor-ThinkPad-T440:~$ npm -v
3.8.9
```

repo_language: JavaScript

mime_type: text/plain


text:
# Node.js - Aula 01 - Exercício
**user:** [ajoao88](https://github.com/ajoao88)
**autor:** João Paulo S de Araújo
**date:** 2016-02-07T09:40:00

##1. Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.

De forma geral um processamento síncrono é uma fila única de processos, ou seja, um novo processo só começa quando o atual termina.
Já no processamento assíncrono não existe essa fila única, após responder a requisição de um processo o mesmo se inicia e o próximo já é atendido e iniciada execução, trazendo ganhos enormes de desempenho e eficiência. Para que seja gerenciado o termino dos processos, que não vai ocorrer na mesma ordem que foram iniciados, cada processo possui um callback que ao terminar o dispara, seu término é tratado como se deve e é dada continuidade ao processos.

Abaixo exemplos de uma execução síncrona e uma assíncrona de leitura de arquivos.

**Síncrona:**

```js
var fs = require('fs');
var conteudo = fs.readFileSync('./arq.txt', "utf8");
console.log(conteudo);
console.log('Leitura do primeiro arquivo terminou');
console.log('Ler próximo arquivo');
```

Retorno da execução:
> "1. Primeira linha do primeiro arquivo"
> "2. Segunda linha do primeiro arquivo"
> "3. Terceira linha do primeiro arquivo"
> "4. Quarta linha do primeiro arquivo"

> "Leitura do primeiro arquivo terminou"
> "Ler próximo arquivo"

**Assíncrona**

```js
'use strict'
var fs = require('fs');
fs.readFile('./index.txt',(err, result) => { //err e result são os callbacks de falha e sucesso, respectivamente
    if(err) console.log(err);
    console.log(result.toString());
    console.log('Leitura do primeiro arquivo terminou');
})
console.log('Ler próximo arquivo');
```
Retorno da execução:
> "Ler próximo arquivo"
> "1. Primeira linha do primeiro arquivo"
> "2. Segunda linha do primeiro arquivo"
> "3. Terceira linha do primeiro arquivo"
> "4. Quarta linha do primeiro arquivo"
> "Leitura do primeiro arquivo terminou"

Como foi possível notar, na execução síncrona só foi iniciada a leitura do próximo arquivo após acabar a leitura do primeiro, já na assícrona a leitura do próximo arquivo foi iniciada antes mesmo da leitura de cada linha do primeiro.

##2. Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.

- Quando V8 recebe o código em JavaScript, ele o analisa para criar árvore de sintaxe abstrata (AST - Abstract Syntax Tree), uma espécie de preparação para o gerador de byte code.
- Em seguida, a AST é alimentado no gerador de byte code para produzir byte code.
- O ambiente de execução V8 então interpreta esse byte code e com a ajuda de um compilador JIT (Just-In-Time) produz o código de máquina nativo que é executado.

Na imagem abaixo confira o fluxograma desse funcionamento:
![Imagem Fluxo v8](img/fluxoV8.png)

##3. Qual a diferença entre um sistema single para um multi-thread?

Um sistema `single-thread` executa tarefas em uma única thread. Dessa forma, é necessário esperar o termino de uma tarefa para executar outra.
Um sistema `multi-thread` possui várias threads para execução de tarefas, podendo realiza-las simultaneamente.

##4. Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?

A quinta requisição fica aguardando uma das quatro primeiras terminar para entrar na `Thread Pool`.

##5. Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?

- Necessita de bem menos investimento em hardware por ser muito mais eficiente que seus concorrentes.
- Possui Inúmeras biblicotecas open-source e mais sendo criada a cada dia, eliminando custos com software.
- O NodeJS é em linguagem JavaScript que é um linguagem muito bem difundida e conhecida pela comunidade.
- É uma plataforma extremamente eficiente, possui bibliotecas assíncronas, que com investimento em hardware muito baixo em relação a concorrentes pode atender a milhões de requisioções

##6. Qual a versão do seu `node`?

> $ node -v
> v5.0.0

##7. Qual a versão do seu `npm`?

> $ npm -v
> 3.3.6


text:
# Node.js - Aula 01 - Exercício

**user:** [gilsondev](https://github.com/gilsondev)

**autor:** Gilson da Silva Borges Filho

**date:** 1457204302220

## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.

**Processo Síncrono**: É quando o processo é enviado para execução, e o Node.js espera
finalizar sua execução. Enquanto aguarda, outros processos fica em modo de suspensão,
esperando sua vez.

**Processo Assíncrono:** Nesse caso é o padrão do Node.js, quando o Event Loop ao receber
os processos, envia para executá-las, mas diferente do assincrono, as mesmas precisam
ter uma função de callback, para executar quando o processamento for finalizado. Assim,
o event loop é notificado e retorna o seu resultado para quem a requisitou. Isso, libera
o mecanismo de receber processos depois de enviar cada uma delas para execução.

## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.

Ele compila o código para o código nativo de máquina para assim executá-lo. Do contrário,
que o código era interpretado, sua compilação aumenta a performance da aplicação Javascript.

Seguindo as boas praticas em uma VM, o V8 possui dois tipos de compiladores: Full compiler e Optimizing Compiler

**Full Compiler**: É aonde inicia a compilação do código Javascript. Ele não faz
análise de tipo, já que ele usa a estratégia de Inline Cache enquanto executa o
mesmo. Quando precisa de mais performance é usado o segundo compilador

**Optimizing Compiler**: É aqui onde ele produz um código performático, recompilando
funções que estão tendo alto índice de uso.

Segue um exemplo de como funciona: http://runtimejs.org/jsconf/img/runtimejs-arch.png

## Qual a diferença entre um sistema single para um multi-thread?

**Single-Thread**: É uma aplicação que roda em uma thread, e que oferece uma
vantagem de de economizar memória e processamento.

**Multi-thread**: É uma aplicação que criar várias threads, que normalmente são
criadas para executar tarefas distintas como requisição de cada usuário que
acessa, conexão com o banco de dados.

## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?

As 4 primeiras requisições enviadas será alocadas na thread pool, mas a quinta estará
no queue list. Mas esse tamanho pode ser mudado passando o valor para uma variável de
ambiente com o nome `UV_THREADPOOL_SIZE`, em que vai ser o tamanho desse pool. Lembrando,
que na documentação mostra que o máximo suportado é de 128.

## Como você venderia o peixe do **Node.js** na sua empresa para tentar convencer seu chefe da sua adoção?

1 - O Node.js traz uma unidade no quesito de linguagem de programação. Agora podemos trabalhar com
Javascript em praticamente todas as camadas de uma aplicação;

2 - Trabalha de forma assíncrona por padrão: Dessa forma evitaria possíveis gargalos em grandes
execuções de processos, assim sem deixar que a aplicação congele por exemplo.

3 - Com ele você possui soluções de real-time altamente abstraídos.

4 - Comunidade ativa e com criação de ferramentas cada vez mais performáticas e fáceis de trabalhar,
gerando novos conhecimentos, cases para serem usadas no dia a dia.

5 - E temos cases muito bem seguros de pesquisar, e ver o lado bom e ruim de usar o Node.js e analisar
os relatórios de mudança, para concluir qual ganho teremos ao usar. E como percebe-se, os ganhos são
consideráveis no quesito de performance, escalabilidade e produtividade no desenvolvimento.

## Qual a versão do seu `node`?

```bash
$ node --version
v.5.7.0
```

## Qual a versão do seu `npm`?

```bash
$ npm --version
v3.7.5
```


text:
# Node.js - Aula 01 - Exercício
**user:** [augustoody](https://github.com/AugustoOdy)
**autor:** Augusto Ody
**date:** 1454431830404

## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.

Em um processo assíncrono, a função recebe uma função callback para que após sejá executado o processo, seja chamada está função, causando assim o não travamento da aplicação pra sua execução.

```js
var fs = require("fs");

fs.readFile("myfirstexample.txt", "utf8", function(error, data) {
  console.log(data);
});
```

Já no síncrono, a execução espera para que seja feito todo aquele processo, não possibilitando outras ações. Como no exemplo, após iniciar a leitura, toda ela deve ser feita para que então seja passado para próxima linha e executado um `console.log()`.

```js
var fs = require("fs");

var data = filesystem.readFileSync("myfirstexample.txt", "utf8");

console.log(data);
```

## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.

Com a single thread do V8, é executado o Event loop, que ainda serve todos o usuários. A parte de I/O é passada para a `libeio` (susbtituida agora pela `libuv`), que pode acaba retornando os dados necessários.

![NodeJs Architecture](http://blog.pivotal.io/wp-content/uploads/2012/04/NodeJS-EventedIOAsyncIO_latest.png)

## Qual a diferença entre um sistema single para um multi-thread?

**Single Thread :** As requisições são lançadas em uma única thread, gerando uma fila para sua execução, gerando um processamento mais rápido.
**Multi Thread :** Cada requisição gera uma nova thread, diferentemente da Single, podendo assim então gerar mais processamento.

## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?

Segunda a documentação da `libuv`, o tamanho *default* da Thread Pool é 4, porem podendo ser alterado para até o máximo de 128. No caso de enviado mais requisições que o valor suportado, as requisições ficam aguardando para que uma "vaga" seja liberada, para a sua execução.

## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?

Mostraria os cases do Paypal e Netflix, aonde a performance, o número de programadores, e a velocidade de desenvolvimento foram melhoradas, incluindo ainda o fato da possibilidade de unir mais a equipe do front-end e do back-end, se não cabar juntando-as para um melhor aproveitamento da tecnologia.

## Qual a versão do seu `node`?
```sh
$ node -v
v5.2.0
```

## Qual a versão do seu `npm`?
```sh
$ npm -v
3.3.12
```


text:
# Node.js - Aula 01 - Exercício
Autor: Juliano Padilha | julianopadilha
Data: Date.now()

## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.

- Processo Síncrono: O processo síncrono se caracteriza pela necessidade de se aguardar o término
de um processo para que outro se inicie, podendo ser descrito como uma fila, onde os processos subsequentes se manterão em espera até que o processo corrente seja finalizado. Um exemplo de um processo síncrono é um lavajato de carros, onde formasse uma fila e um novo carro só começa a ser lavado após o atual ter finalizado.
```
function dataAtual() {
	var date = new Date();
	console.log(date);
}

function meuNome() {
	var nome = 'Juliano Padilha'
	console.log(nome);
}

dataAtual();
meuNome();
```

- Processo Assíncrono: O processo assíncrono se caracteriza pela execução de um Callback após a finalização do processo. Em um processo assíncrono os processos ocorrem de forma independentes, não sendo necessário que um processo seja finalizado para que outro comece a ser executado. Um exemplo de um processo assíncrono é
```
function confirmacaoPagamento(){
    console.log("Sua operadora de cartão confirmou o pagamento da sua compra.");
}
function compra(){
    setTimeout(confirmacaoPagamento, 0);
    console.log("Obrigado por comprar com a gente!");
    console.log("Volte sempre!");
}
compra();
```

## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.

- o V8 executa Javascript através da sua interpretação, similar à JVM do Java. O trabalho dele é basicamente compilar o código de Javascript para o código nativo de máquina para depois executá-lo.

```
![V8 Example](https://camo.githubusercontent.com/58b3ea90dd5b39f11bd500444070defdfe9dc7cd/687474703a2f2f72756e74696d656a732e6f72672f6a73636f6e662f696d672f72756e74696d656a732d617263682e706e67)
```

## Qual a diferença entre um sistema single para um multi-thread?

- Uma das características do Node é a forma como trabalha com threads, sendo apenas um, mas podendo ser criadas outras. Um sistema single thread tem como vantagem o consumo de mémoria e a não necessida de criar uma nova thread para um novo processo. O Node controla tudo com apenas uma thread utilizando o Event Loop.

	* Um sistema Single Thread é capaz de executar apenas uma tarefa por vez. Enquanto a tarefa é executada, todo o sistema aguarda que a thread finalize para que possa seguir adiante.

	* Um sistema Multi Thread consegue executar várias tarefas simultaneamente. Cada solicitação vira uma thread e o servidor consegue trabalhar com ela isoladamente, sem intereferir nas outras

## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?

- Neste caso, a quinta requisição ficara no Idle Thread aguardando a liberação de uma das quatro primeiras. Na sequência, ela é jogada para a Thread Pool para ser executada. @geriel

## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?

- Acredito que primeiramente eu iria atrás de adquirir uma boa base em Node.js para mostrar para meu chefe que não iniciaríamos do zero no quesito conhecimento. Eu também levaria comparações do Node com a tecnologia atual da empresa para compararmos juntos os pros e contras. Eu também iria me dispor a facilitar a inclusão dos outros desenvolvedores em Node por meio de treinamentos.

## Qual a versão do seu node?

```
Julianos-MacBook-Pro:~ julianopadilha$ node -v
v6.2.2
```

## Qual a versão do seu npm?
```
Julianos-MacBook-Pro:~ julianopadilha$ npm -v
3.9.5
```


text:
# Node.js - Aula 01 - Exercício
**User:** ronal2do
**Author:** Ronaldo Lima
**Date:**  1467987772532

## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.

Os processos síncronos espera a finalização de uma tarafa para dar início a próxima.

Por padrão no Node.js qualquer função é assíncrona sendo que um processo não precisa acabar para dar início ao próximo, quando a função assíncrona for concluída como retorno ela recebe uma função chamada de callback, enquanto isso os demais processos continuam sendo executandos paralelamente.

## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.

o V8 é um interpretador de JavaScript, ele compila o JS para o código nativo da máquina e depois executalo. Elevando em muito a velocidade de leitura com esse motor.

No Motor do Node funcinária assim.

Application => V8 => Node API => EVENT LOOP => WORKER THREAD / Retorna o Callback => EVENT LOOP => Node API => V8 => Application.

Como usado nos slides.

## Qual a diferença entre um sistema single para um multi-thread?

O Apache é um sistema multi-thread ele gera uma nova thread para cada processo diferente do Node.js que é single-thread trabalhando apenas com uma thread, evitando o grande problema de alocação de memória e usao de CPU.

## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?

A quinta requisição vai ficar no Idle Thread (Thread em pré-execução que mitiga o custo de memória) até que haja liberação no ciclo de tasks dentro da Thread Pool.

## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?

Ciente que cada caso é um caso, usaria o ótimo exemplo do Paypal passado em aula.

Runtime Google V8 - Explicaria como funciona o processo e criaria uma comparação do produto/mercado atual da empresa e os números($$$) de ganho em performance.

O Node.js trabalha com o modelo de IO não-bloqueante

Grandes cases. LinkedIn, Wallmart, Groupon, Microsoft e Paypal são algumas das empresas usando Node.js atualmente.

[Fonte:] (https://udgwebdev.com/6-motivos-para-usar-nodejs).

## Qual a versão do seu `node`?

```
sh-3.2# node -v
v5.10.1
```

## Qual a versão do seu `npm`?

```
sh-3.2# npm -v
3.8.3
```


text:
# Node.js - Aula 01 - Exercício
autor: **Sergio Diniz Correia**

# 1 - Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Em um processo **Síncrono**, uma requisição é enviada e o processo remetente permanecesse bloqueado até que ocorra uma resposta, isso significa que não é possível enviar novas requisições até que a primeira requisição enviada, a que se encontra em processo, seja finalizado. Desta forma, podemos dizer que existe sincronismo entre as requisições.

Para entendermos melhor esse processo, imagine uma fila que vende ingressos de cinema. Quando você está na fila, você precisa esperar que a pessoa que esta na sua frente escolha qual filme ela quer assistir, quantas entradas, qual a sala e o horário, pagar e finalmente a atendente entregar, como resposta, o bilhete de entrada. Neste caso, a atendente só pode atender um cliente na fila por vez.

Em um processo **Assíncrono**, não existe sincronismo, ou seja, o processo não ficará bloqueado por já esta atendendo uma requisição, isso quer dizer que podemos enviar várias requisições em paralelo, neste caso, cada resposta é enviada quando estiver pronta.

Para entendermos melhor esse processo, imagine que você está em um bar e quer comer um espetinho e carne, você chama o garçom, faz o pedido e ele vai para o churrasqueiro dizer que precisa de um espetinho de carne, e então o churrasqueiro começa a ajeitar o pedido, porem, enquanto isso acontece, o garçom esta livre apara atender outras mesas e, da mesma forma, entregar o pedido ao churrasqueiro. Quando o espetinho finalmente estiver pronto, o churrasqueiro repassa o espetinho para o garçom que entrega o pedido.

# 2 - Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O interpretador V8, ou maquina virtual javascript, é uma ferramenta desenvolvida em c++ e tem como função, acelerar o desempenho da aplicação compilando código javascript para linguagem de maquina.

![alt text](http://image.slidesharecdn.com/wherenode-140123132101-phpapp02/95/where-nodejs-meets-ios-54-638.jpg)

# 3 - Qual a diferença entre um sistema single para um multi-thread?
A característica de sistema **Singlethread** é que ele só consegue suporta apena um programa no seu espaço de endereçamento, ou seja, o sistema fica bloqueado ate o seu termino, isso pode ser um problema pois demanda muito consumo de diversos recursos do sistema. Sempre que um processo é criado, o sistema deve alocar recursos para cada processo, consumindo tempo de processador neste trabalho.

Já em um sistema **Multithread**, cada processo pode responder a várias solicitações concorrentemente ou mesmo simultaneamente, caso haja mais de um processador.

# 4 - Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Caso haja um numero maior de requisições do que o espaço alocado para a Thread Pool, as requisições sobressalentes são colocadas em uma espece de fila de esperara, onde ficam aguardando que uma thread seja liberada para receber uma nova requisição.

Apesar do valor padrão ser 4, esse numero pode ser alterado ate 128.

```
Its default size is 4, but it can be changed at startup time by setting the UV_THREADPOOL_SIZE environment variable to any value (the absolute maximum is 128).
```
referencia: [libuv](http://docs.libuv.org/en/v1.x/threadpool.html)

# 5 - Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Para poder mostrar as vantagens e o poder do Node.js, eu faria:
+ uma pesquisa com comparações entre o Node e a linguagem principal que a empresa usa,
+ mostra também o quando a linguem pode ter um desenvolvimento ágil,
+ ter um alto desempenho,
+ ter uma comunidade ativa e crescente,
+ diversos materiais na internet,
+ ter uma linguagem que pode ser usada tanto no back como no front-end
+ e um curso gratuito e muito foda na Webschool.io para treinamento.

# 6 - Qual a versão do seu node?
```javascript
Sergios-MacBook-Pro:~ sergiodiniz$ node -v
v5.5.0

```

# 7 - Qual a versão do seu npm?
```javascript
Sergios-MacBook-Pro:~ sergiodiniz$ npm -v
3.3.12

```


text:
## 1. Explique como um processo síncrono e assíncrono roda no Nodejs, dê um exemplo para cada.

No processo síncrono só temos o retorno da função quando a mesma é executa de forma total, com isso o processo aguarda o termino de cada função e executa uma de cada vez. Ex: [fs.readFileSync](https://nodejs.org/api/fs.html#fs_fs_readfilesync_file_options).

No processo assíncrono premite que o programa continue executando enquanto a função faz determinada tarefa e chama um *callback* quando é finalizada. Ex: [fs.readFile](https://nodejs.org/api/fs.html#fs_fs_readfile_file_options_callback).

## 2. Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.

Ele basicamente compila o código "JavaScript" para linguagem de máquina utilizando "C++".

![Hidden class](http://thibaultlaurens.github.io/assets/themes/img/post/21-03-13-v8/hiddenclass.PNG)

![Hidden class](http://thibaultlaurens.github.io/assets/themes/img/post/21-03-13-v8/transition.PNG)

> Confesso que não domino o funcionamento do V8, segue no link o artigo das imagens para melhor entendimento. [How the V8 engine works?](http://thibaultlaurens.github.io/javascript/2013/04/29/how-the-v8-engine-works/)

## 3. Qual a diferença entre um sistema single para um multi-thread?

No sistema Single-Thread consiste em somente um processo sendo excutado por vez dentro de uma quantidade especifica de tempo, onde em seu termino é executado o próximo processo agendado. Já no processo multithread, cada thread tem o seu próprio contexto compartilhando recursos do processo.

## 4. Como a Thread Poll tem um tamanho padrão de 4, o que acontece se enviar 5 requisiçoes ao banco?

A requisição 5 entra em uma estado de espera e aguarda o termino das primeiras 4 requisições.

## 5. Como você venderia o peixe do Nodejs na sua empresa para tentar convencer seu chefe da sua adoção?

O Node.js é uma tecnologia de vanguarda que rompe um pouco com a programação tradicional, exitem situações onde o desenvolvimento se torma mais simples e com melhor desempenho. Além de usar JavaScript, que é uma linguagem fácil de aprender e com uma grande comunidade que cria novas soluções em uma velocidade incrível.

## 6. Qual a versão do seu `node`?
```
~ λ node --version
v5.12.0
```

## 7. Qual a versão do seu `npm`?
```
~ λ npm --version
3.8.6
```


text:
# Node.js - Aula 01 - Exercício
**Autor:** Diego Ferreira
**Data:** 23/02/2016 - 10:00

## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
##### Processo Síncrono

É executada apenas uma função por vez, ou seja, os recursos ficam todos disponívels para determinada tarefa e somente são liberados após a tarefa ser completamente finalizada e respondida ao usuário. Ou seja, neste momento "travando" o Node e impedindo naquele instante que o mesmo continue o processamento de outras tarefas. Por exemplo, se essa função fizer um I/O em disco, ele vai bloquear o sistema inteiro, deixando o processador ocioso enquanto ele usa outros re-cursos de hardware, como por exemplo, leitura em disco, utilização da rede etc, e somente liberará os recuros após a finalização da tarefa.

##### Processo Assíncrono

 Em um processo assíncrono o servidor não bloqueia os recursos da máquina durante o processamento de uma requisição neste momento apenas o recurso que esta sendo utilizado fica bloqueado e os demais ficam liberados para o processamento de outras requisições, o node utiliza do recurso de callbacks ou seja, o cliente envia a requisição o nodejs responde a primeira requisição e aguarda a chamada de retorno, ao mesmo tempo atende outras requisições e fica escutando a chamada de CALLBACK das outras requisições enviadas. E com isto vai processando todas as requisições, e a medida que os CALLBACKS são acionados ele vai devolvendo as respostas para o cliente, compartilhando assim os recursos da máquina, e processando várias requisições ao mesmo tempo.

## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.

O V8 funciona como uma máquina virtual, ele recebe e lê o script escrito em javascript compila o código para linguagem de máquina quando é executado pela primeira vez. Ele cria classes ocultas para o determinado objeto prevendo que o mesmo irá ser utilizado por todos os objetos futuros acessados na mesma sessão de código, e utiliza estas informações para atualizar o cache interno que contém a classe.

Se V8 prever corretamente o valor da propriedade, é atribuído (ou forçado) em uma única operação. Se a previsão estiver incorreto, V8 corrige o código para remover a otimização.

Por exemplo, o código JavaScript para acessar a propriedade x de um objeto Teste é:

```

teste.x
```

Na V8, o código de máquina gerado para acessar x é:

```

# ebx = o objeto teste
cmp [ebx,<hidden class offset>],<cached hidden class>
jne <inline cache miss>
mov eax,[ebx, <cached x offset>]

```

Se classe oculta do objeto não corresponde à classe oculta em cache, a execução salta para o sistema de execução V8que lida com erros de cache em linha realiza correções no código de cache embutido. Se houver uma correspondência, o que é o caso comum, o valor da propriedade x é simplesmente recuperado.

A combinação de uso de: classes ocultas para acessar propriedades, caching embutido e geração de código de máquina, otimiza a forma com a qual os objetos são criados e acessados e com isso melhora gradativamente a velocidade com que o código javascript é executado.

## Qual a diferença entre um sistema single para um multi-thread?

##### Single-Thread

Em um sistema single-thread uma única tarefa é executada por vez, funcionando como se fosse uma fila, chega a tarefa um o sistema executa, responde, pega a tarefa 2 executa e responde e assim por diante. Uma tarefa somente é executada após a finalização da execução da tarefa anterior.

#### Multi-Thread
Em um sistema multi-thread, as tarefas são executadas em paralelo, enquanto uma tarefa esta aguardando em um processo de IO, as outras podem fazer uso da(s) CPU's disponíveis, e com isso gerando a impressão para o usuário que as tarefas estão sendo executas mais rápidas.

## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se enviar 5 requisições ao banco?

Quando é enviado um número de requisições a mais do que a thread pool suporta, estas requisições "adicionais" são colocadas na Task Queue, que é uma fila de espera onde as tarefas ficam até que a thread pool libere espaço para que as mesmas possam ser executadas.

## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?

Atualmente trabalho com Java para Web, então para a adoção do Node, seria necessário fazer um estudo comparativo mostrando ao gerente a performance de uma app java e uma app node, e mostraria que o node economizaria também em recursos operacionais para a empresa. Caso ele ainda não acreditasse, pegaria alguma funcionalidade de algum projeto existente e faria a mesma em node, como prova de conceito e para tirar as dúvidas existentes.

## Qual a versão do seu `node`?
```
node --version
v5.4.1
```

## Qual a versão do seu `npm`?
```
npm --version
3.5.3
```

## Bibliografia
```
https://developers.google.com/v8/design#mach_code
Node.js - Aplicações web real-time com Node.js
```


text:
# NodeJS - Aula 01 - Exercício
**Autor:** Rafael Crispim Ignácio

**Data** 1451226657631

# 1. Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
- Processos Síncronos

Nos processos síncronos, exste uma dependencia da finalização de um método com a utilização deste retorno após o mesmo. Neste caso não podemos dar prosseguimento em uma rotina até que determinado método tenha terminado. Isto leva ao enfileiramento de processos, onde estes são executados em fila.

```js
// Exemplo na forma síncrona
var files = fs.readdirSync("/home/user");

console.log(files);
```

- Processos assíncronos

Nos processos assíncronos utilizamos funções de retorno chamadas de `callback`. Estas funções nos permitem chamar métodos sem esperar o seu término, pois quando isto ocorrer a função de retorno será executada e a rotina será concluída ou dará prosseguimento ao processo. É bastante indicada para recursos que são mais lentos com por exemplo um acesso ao disco.

```js
// Exemplo na forma assíncrona
var fs = require("fs");

fs.readdir("/home/user", function(err, files){
  console.log(files);
});
```

# 2. Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O V8 compila o javaScript diretamente em código de máquina na primeira vez que é executado. Não existe bytecode intermediário nem interpretador. Ao executar ele cria estruturas ocultas dos objetos conforme necessário e utiliza um cache embutido para facilitar o acessos aos mesmos. Conforme a necessidade estes objetos são atualizados ou descartados.

Por exemplo, o código abaixo demonstra um código em javascript onde uma determinada propriedade de uma classe é acessada.

```js
point.x
```

O código acima gera a seguinte interpretação no V8:

```c++
# ebx = ponteiro para o objeto
cmp [ebx,<hidden class offset>],<cached hidden class>
jne <inline cache miss>
mov eax,[ebx, <cached x offset>]
```

# 3. Qual a diferença entre um sistema single para um multi-thread?
A diferença está na quantidade de threads que o sistema pode utilizar simultaneamente. No single somente é possível utilizar 1 thread e no multi é possível utilizar 1 ou mais.

# 4. Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Neste caso a quinta requisição deve aguardar até que uma das 4 threads seja concluída.

# 5. Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Acredito que a melhor maneira de `vender o peixe` é criando um protótipo e comparando com a outra solução. Não creio que exista uma bala de prata onde todos os problemas devem ser solucionados com apenas uma ferramenta, desta forma precisamos demonstrar as vantagens conforme as opções disponíveis.

# 6. Qual a versão do seu `node`?

```
~:$ node -v
v5.0.0
```

# 7. Qual a versão do seu `npm`?

```
:~$ npm -v
3.3.6
```


text:
# NodeJS - Aula 01 - Exercício
autor: Wellerson Roberto

## 1) Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.

### Processo síncrono

Em um processo síncrono, a execução fica parada esperando o término do método para continuar.

```
var contents = fs.readFileSync('test.txt').toString();
console.log(contents);
```

O método **readFileSync** faz a leitura de um arquivo de maneira síncrona. Então, a execução será parada e só voltará assim que o arquivo terminar de ser lido.

### Processo assíncrono

É no processo assíncrono que está a grande magia do Node.js, pois a execução não será parada e o resultado de tal função será passada através de um **callback**.

```
fs.readFile('/etc/hosts', 'utf8', function (err,data) {
  if (err) {
    return console.log(err);
  }
  console.log(data);
});
```

Neste caso, o método **readFile** é assíncrono. Mesmo fazendo a leitura de um arquivo, o sistema não irá parar. Quando o método finalizar a leitura do arquivo, a função passada no terceiro parâmetro será executada passando um possível erro ou o resultado da leitura.

Pode-se fazer ainda a analogia de um restaurante. Imagine um restaurante trabalhando de modo síncrono vs assíncrono:

Modo síncrono -> Após um cliente fazer um pedido, todo o restaurante será bloqueado. Apenas a comida dele será feita, enquanto todos os outros clientes posterior terão que esperar o término do pedido dele para o seu pedido finalmente iniciar. Após o pedido desse cliente ser executado, o restaurante atende outro pedido e assim vai...

Modo assíncrono -> O restaurante irá atender vários pedidos por vez.

## 2) Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.

O V8 é bastante rápido pois basicamente compila o código JavaScript para o código nativo da máquina antes de executá-lo, permitindo que ele rode na velocidade de um código binário compilado. O código compilado ainda é reotimizado em tempo de execução.

![](https://raw.githubusercontent.com/wellerson010/be-mean-exercicios/master/nodejs/class01.png)

## 3) Qual a diferença entre um sistema single para um multi-thread?

O sistema single-thread usa apenas um único processo para ser executado, enquanto o multi-thread faz uso de dois ou mais processos. Embora o sistema multi-thread possa ser mais rápido, pois pode fazer o uso dos múltiplos cores do processador para executar mais de uma tarefa ao mesmo tempo, ele acaba também fazendo mais uso de memória.

## 4) Como o Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?

Das 5 requisições, 4 irão ser executadas enquanto uma irá ficar no estado **idle** (dormindo), esperando uma dessas terminar para então ser executada. É importante ressaltar que é possível aumentar o número do Thread Pool para até 128.

## 5) Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?

Mostraria primeiramente onde o Node.JS é usado e como ele melhorou a produção em grandes empresas, como o Paypal e o Linkedin. Diria também que o custo seria diminuído, visto que precisariamos de servidores menos potentes, e portanto mais baratos, para ter o mesmo número de acessos que a gente tem com os servidores atuais. Além disso, citaria o fato de usar apenas uma única linguagem no back-end e no front-end, o que facilitaria demais aqueles que são especializados mais no front-end a também ajudarem no back-end, e se tornarem mais independentes.

## 6) Qual a versão do seu Node?

```
D:\Developer\BlogBeMean>node -v
v5.0.0
```
## 7) Qual a versão do seu NPM?

```
D:\Developer\BlogBeMean>npm -v
3.3.6
```


text:
# Node.js - Aula 01 - Exercício

**user:** [jeffersondanielss](https://github.com/jeffersondanielss)

**autor:** Jefferson Daniel Santos Silva

**date:** 1449708675195

#### Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
O processo síncrono se caracteriza pela necessidade de um processo acabar para poder executar um próximo processo.
Já o assíncrono pode executar vários processos ao mesmo tempo enquanto espera a resposta dos mesmos para quando estiverem prontos.
Podemos pegar como exemplo uma transportadora.
Em um processo síncrono ela só poderia ter um caminhão na rua entregando uma mercadoria por vez para que quando voltasse ele recebesse outra mercadoria e assim voltasse para a rua.
Já com um processo assíncrono a transportadora poderia enviar vários caminhões a rua fazendo suas entregas e quando a transportadora receber a informação que a mercadoria foi entregue com sucesso ela pode reabastecer esse caminhão e envia-lo novamente as ruas.

#### Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O fluxo de compilação de javascript para o código nativo da máquina, no v8 do nodejs:
![Execution v8 nodejs](http://image.slidesharecdn.com/nodejs-140507132306-phpapp02/95/nodejs-code-tracing-2-638.jpg?cb=1427946166)

#### Qual a diferença entre um sistema single para um multi-thread?
Uma single thread trata apenas uma requisição por vez já o multi-thread cria uma nova thread por requisição podendo tratar várias requisições ao mesmo tempo.

#### Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Ela não será executada até que umas das quatro anteriores sejam finalizadas.

#### Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Explicaria as vantagens que

+ Linha de aprendizado é muito mais rápida já que js é requisito pra trabalhar na web.
+ A vantagem de investir em uma linguagem que está em constante ascensão.
+ [Empresas grandes usam nodejs](https://github.com/nodejs/node-v0.x-archive/wiki/Projects%2C-Applications%2C-and-Companies-Using-Node)

#### Qual a versão do seu `node`?
v5.2.0

#### Qual a versão do seu `npm`?
3.3.12


text:
# Node.js - Aula 02 - Exercício
**user:** [dayvsonsales]https://github.com/dayvsonsales
**autor:** Dayvson Sales
**date:** Sex Dez 11 22:39:07 BRT 2015

## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.

Suponhamos que tenhamos uma lista de tarefas

Assíncrono:

	Se executarmos de forma assíncrona, essas tarefas irão ser executadas de forma concorrente, simultaneamente. Uma não dependerá da outra para finalizar, podendo assim, a primeira ser a última a retornar ou a última ser a primeira e vice-versa.
	Sempre que utilizarmos assíncrono no node.js devemos passar uma função callback que será executada assim que a tarefa terminar sua execução.

	Exemplo:

	 ```
	 	db.query(sql, function(err, data){
	 		if(err){
	 			throw err;
	 		}
	 		console.log("inserido " + data);
	 	});
	 	console.log("essa mensagem pode vir antes ou depois do inserido ou error")
	 ```

Síncrono:

	Quando uma tarefa é executado de forma síncrona, a thread principal irá esperar a tarefa ser executada e aguardar seu retorno para dar continuidade a outras tarefas.

	```
		var data = db.querySync(sql);
		console.log(data);
	 	console.log("essa mensagem só aparecerá depois da execução da função acima");

	```

## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.

http://runtimejs.org/jsconf/img/runtimejs-arch.png

http://jbcdn2.b0.upaiyun.com/2012/05/11.jpg

## Qual a diferença entre um sistema single para um multi-thread?

Um sistema single thread se caracteriza por executar tarefas na mesma thread. Dessa forma, é necessário esperar o termino de uma tarefa para executar outra.

Um sistema multi-thread se caracteriza por criar várias threads para execuções de tarefas, podendo realiza-as simultaneamente.

## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?

A quinta só será executada após a finalização das uma das quatro primeiras. Mas é possível aumentar esse número até 128.

## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?

Mostraria o Node.js em si, suas vantagens e desvantagens em relação ao negócio da empresa e mostraria casos de sucesso com ele, como o da Netflix (que mudou seu core de Java para Node).

## Qual a versão do seu `node`?

dayvs0n in ~/be-mean-instagram-nodejs-exercises λ-> node -v
v5.2.0

## Qual a versão do seu `npm`?

dayvs0n in ~/be-mean-instagram-nodejs-exercises λ-> npm -v
3.3.12


text:
```md
# Node.js - Aula 01 - Exercício
**user:** [josecarloweb](https://github.com/josecarlosweb)
**autor:** JOSÉ CARLOS DA SILVA DE CARVALHO
**date:** Tue Dec 15 2015 14:56:53 GMT-0300 (BRT)

## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.

Um processo síncrono bloueia todo o ciclo de eventos, parando execução de seu código até que haja as saídas de processo gerado.
Chamadas síncronas são principalmente úteis para a execução de tarefas gerais e para simplificar o carregamento/processamento de configuração do aplicativo na inicialização. Uma vez que utilizado um processo síncrono no NodeJs, o processo principal será bloqueado até que a chamda síncrona seja executada (tenha uma saída).
Ex. Inicialização de uma aplicação, como um jogo que precisa carregar aquivos. O processo principal deve ser bloqueado até que todos os arquivos tenham sido carregados.

Processos assíncronos ocorrem independentemente do fluxo de programa principal. Ações assíncronas são ações executadas em um esquema de não bloqueio, permitindo que o fluxo de programa principal para continuar o processamento. Esse é o tipo de processo padrão do NodeJS.
Ex. Uma aplicação exibe um vídeo em tempo real (streaming) enquanto um processo de chat é executado ao mesmo tempo.

Detalhes e fonte: <http://kikobeats.com/synchronously-asynchronous/>

## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.

V8 compila JavaScript para código de máquina(IA-32, x86-64, ARM, ou MIPS ISA, também foi portado para PowerPC e IBM s390 para uso em servidores) antes de executá-lo, em vez de técnicas mais tradicionais, como a interpretação de bytecode ou compilar todo o programa para código de máquina e executá-lo a partir de um sistema de arquivos. O código compilado é adicionalmente otimizado (e re-optimized) dinamicamente em tempo de execução, com base em heurísticas de perfil de execução do código. Mais informações <http://thibaultlaurens.github.io/javascript/2013/04/29/how-the-v8-engine-works/>
```
```c++
#include <v8.h>
using namespace v8;
int main(int argc, char* argv[]) {
  // Create a stack-allocated handle scope.
  HandleScope handle_scope;
  // Create a new context.
  Handle<Context> context = Context::New();
  // Enter the created context for compiling and
  // running the hello world script.
  Context::Scope context_scope(context);
  // Create a string containing the JavaScript source code.
  Handle<String> source = String::New("'Hello' + ', World!'");
  // Compile the source code.
  Handle<Script> script = Script::Compile(source);
  // Run the script to get the result.
  Handle<Value> result = script->Run();
  // Convert the result to an ASCII string and print it.
  String::AsciiValue ascii(result);
  printf("%s\n", *ascii);
  return 0;
}
```
```

## Qual a diferença entre um sistema single para um multi-thread?

Tem mais arquiteturas além de single-thread (ST) e multi-thread (MT). Basicamente o ST só pode tratar uma requisição de cada vez, então o processamento de cada uma não pode ser demorado, nem pode bloquear (por exemplo, ficar esperando pelo banco de dados). O MT, assumindo que se crie uma thread por requisição, pode tratar várias requisições em paralelo, mesmo que demorem ou bloqueiem.

Um servidor ST pode ser eficaz, desde que nunca bloqueie. O Node.js é assíncrono de modo a não bloquear. Qualquer processamento demorado deve ser delegado a um outro processo, o que também pode ser feito no Node com subprocess.

Outra forma de abordar o problema: o prefork do Apache cria um pool de subprocessos, e delega as requisições para cada subprocesso conforme elas chegam. Isto garante o paralelismo e evita as complexidades de programação MT. Isto pode ser implementado também no Node mas o Apache entrega isto de fábrica, o que facilita a vida do desenvolvedor PHP por exemplo, pois ele não precisa se preocupar se está bloqueando.

coletado em: <http://pt.stackoverflow.com/questions/75144/diferen%C3%A7a-entre-multi-e-single-thread>

## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?

Caso seja feita a quinta requisição ao banco, essa requisição será incluída no **Idle Thread** e ficará aguardando para ser inserida na **Thread Pool** e ser executada.

## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?

Hoje em uma empresa que presto serviço, há uma API em PHP que sofre constantes modificações e já consome de infraestrutura o valor de 2 salários de desenvolvedores pleno. O primeiro argumento é o menor custo de infraestrutura, uma vez que o SGBD atual é postgres e o serviço RDS na aws custa bem caro, diferente do mongo ou cassandra. Os custos com infra poderiam cair até 40%.
É desejável que uma nova versão seja criada para corrigir os erros de implementação existentes. Logo uma nova versão da API com o Node/Express seria muito mais produtiva (rápida) e muito mais econômica.

## Qual a versão do seu `node`?
carlos@carlos-pc:~/Documentos/be-mean-instagram-node$ node -v
v5.2.0

## Qual a versão do seu `npm`?
carlos@carlos-pc:~/Documentos/be-mean-instagram-node$ npm -v
3.3.12

```


text:
# Node.js - Aula 01 - Exercício
**user:** [souzacristsf](https://github.com/souzacristsf)

**autor:** Michel Ferreira Souza

**date:** 1457272367278

## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.

**Sync:** no processo síncrono temos que aguarda a execução de um por um, nesse caso para a execução de varias tarefas, temos que aguardar o processo final de cada um.
```js
var fs = require('fs');
var file = "síncrono.txt";
fs.writeFileSync(file, "Hello Node.js!");
console.log("Criando arquivo sincrono: " + file);
```

**Async:** no processo assíncrono, não temos que ficar aguardando, pois enquanto a tarefa é realizada a proxima tarefa é chamada e assim por diante.
```js
var fs = require('fs');
var file = "síncrono.txt";
fs.writeFile(file, "Hello Node.js!", function(err, out) {
    console.log("Criando arquivo assincrono: " + file);
});
```

## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
V8 é uma ferramenta desenvolvida na linguagem C++ e open source. O `v8` compila o código javaScript para o formato nativo de máquina antes de executá-lo, obtendo uma grande performance.

![V8](https://qph.is.quoracdn.net/main-qimg-ab2a954b51c404efe66cdc7681da6b85?convert_to_webp=true)

## Qual a diferença entre um sistema single para um multi-thread?
**multi-thread:** varios processos criado.

**single-thread:** apenas um processo.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
A `libuv` tem um tamanho de *threads pool* padrão de 4, e se dispõe de uma fila para gerenciar o acesso a thread pool. O interessante é que se você tem 5 requisição de consulta ao banco e todos indo ao mesmo tempo, um deles e qualquer outra ação assíncrona estará esperando por essas consultas para começar seu processo.

## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Primeiramente, mostrar quais empresas estão adotando essa nova ferramenta e em seguida comparar e implementar alguns testes de exemplo em relação ao produto da organização.

## Qual a versão do seu `node`?
```js
michel@souzacrists:~$ node -v
v5.0.0
```
## Qual a versão do seu `npm`?
```js
michel@souzacrists:~$ npm -v
3.3.6
```


text:
# Nodejs - Aula 01 - Exercício
autor: Ricardo Pereira

## Explique como um processo síncrono e assíncrono roda no Node.js, de um exemplo para cada.

Síncrono: O processo síncrono bloquea o node de executar qualquer outro codigo até o mesmo estar concluído. Síncrono é bloqueante para I/O.
Assíncrono: Executa todo o codigo parelamente as chamadas de I/O, nao-bloqueantes.
Exemplo Síncrono:
```
var fs = require('fs');
for(var i = 0; i < 10; i++){
    fs.readFileSync('./mean.txt', 'utf8', callback);
}
```
Exemplo Assíncrono:
```
var fs = require('fs');
for(var i = 0; i < 10; i++){
    fs.readFile('./mean.txt', (err, data) => {
        console.log(data);
    });
}
```

## Como o V8 executa Javascript? Demonstre 1 exemplo com o código ou imagem.

Ele interpreta o código javascript como uma maquina virtual e transforma em código de máquina.
Exemplo:
```
svn co http://v8.googlecode.com/svn/trunk v8-trunk
cd v8-trunk
scons
g++ ./samples/shell.cc -o v8-shell -I include libv8.a
./v8-shell
V8 version 2.0.2
> var x = 10;
> x
10
> function foo(x) { return x * x; }
> foo
function foo(x) { return x * x; }
> quit()
./v8-shell -e 'print("10*10 = " + 10*10)'
10*10 = 100
```
## Qual a diferenca entre um sistema single para um multi-thread?
Single-thread tem a instancia de um único processo.
Multi-tread tem varias instancias rodando em paralelo, conhecido como programacao concorrente.

## Como a tread pool tem um tamanho de padrao 4, o que acontece se voce enviar 5 requisicoes para o banco

Ela se torna uma Idle-thread que é pre-executada e fica aguardando a task.

## Como voce venderia o peixe do Nodejs na sua empresa para tentar convencer seu chefe da sua adocao?

Comecava a explicar o basico da historia do node e mostraria os problemas de outras ferramentas que o node resolve.
Apresentava alguns cases de sucessos e a economia que isso pôde gerar para empresa com servidores.
Logo em seguida faria uma abordagem da linha de aprendizagem do Nodejs e principalmente mostraria que poderiamos usar uma única linguagem para Back-end e Front-end.
Uma comunidade muita ativa e todas os modulos que ja estao disponiveis para serem utilizados e as empresas de servidores que possuim APIS para nodejs.

## Qual a versao do seu node

MacBook-Pro-de-Ricardo:~ ricardo$ node -v
v5.6.0

## Qual a versao do sua npm
MacBook-Pro-de-Ricardo:~ ricardo$ npm -v
3.6.0


text:
# Node.js - Aula 01 - Exercício
**user:** [carloshenriqueribeiro](https://github.com/carloshenriqueribeiro)
**autor:** Carlos Henrique Oliveira Ribeiro
**date:** 2017-07-31T14:40:00

##1. Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.

De forma geral um processamento síncrono é uma fila única de processos, ou seja, um novo processo só começa quando o atual termina.
Já no processamento assíncrono não existe essa fila única, após responder a requisição de um processo o mesmo se inicia e o próximo já é atendido e iniciada execução, trazendo ganhos enormes de desempenho e eficiência. Para que seja gerenciado o termino dos processos, que não vai ocorrer na mesma ordem que foram iniciados, cada processo possui um callback que ao terminar o dispara, seu término é tratado como se deve e é dada continuidade ao processos.

O Noje.js é por padrão assíncrono, sendo assim as funções que terminam com o sufíxo "Sync" são as funções **síncronas** e as funções que ocultam o sufíxo, são funções **assíncronas**.

Abaixo exemplos de uma execução síncrona e uma assíncrona de leitura de arquivos.

**Síncrona:**

```js
var fs = require('fs');
var conteudo = fs.readFileSync('./arq.txt', "utf8");
console.log(conteudo);
console.log('Leitura do primeiro arquivo terminou');
console.log('Ler próximo arquivo');
```

Retorno da execução:
> "1. Primeira linha do primeiro arquivo"
> "2. Segunda linha do primeiro arquivo"
> "3. Terceira linha do primeiro arquivo"
> "4. Quarta linha do primeiro arquivo"

> "Leitura do primeiro arquivo terminou"
> "Ler próximo arquivo"

**Assíncrona**

```js
'use strict'
var fs = require('fs');
fs.readFile('./index.txt',(err, result) => { //err e result são os callbacks de falha e sucesso, respectivamente
    if(err) console.log(err);
    console.log(result.toString());
    console.log('Leitura do primeiro arquivo terminou');
})
console.log('Ler próximo arquivo');
```
Retorno da execução:
> "Ler próximo arquivo"
> "1. Primeira linha do primeiro arquivo"
> "2. Segunda linha do primeiro arquivo"
> "3. Terceira linha do primeiro arquivo"
> "4. Quarta linha do primeiro arquivo"
> "Leitura do primeiro arquivo terminou"

Como foi possível notar, na execução síncrona só foi iniciada a leitura do próximo arquivo após acabar a leitura do primeiro, já na assícrona a leitura do próximo arquivo foi iniciada antes mesmo da leitura de cada linha do primeiro.

##2. Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.

- Quando V8 recebe o código em JavaScript, ele o analisa para criar árvore de sintaxe abstrata **(AST - Abstract Syntax Tree)**, uma espécie de preparação para o gerador de byte code.
- Em seguida, a AST é alimentado no gerador de byte code para produzir byte code.
- O ambiente de execução V8 então interpreta esse byte code e com a ajuda de um compilador JIT (Just-In-Time) produz o código de máquina nativo que é executado.

Na imagem abaixo confira o fluxograma desse funcionamento:
![Imagem Fluxo v8](img/fluxoV8.png)

##3. Qual a diferença entre um sistema single para um multi-thread?

Thread e tarefas são a mesma coisa!

Uma thread é a divisão do processo principal de um programa representado por uma linha de instrução que o processador deverá executar.

Um sistema `single-thread` executa uma thread em um único processo. Dessa forma, é necessário esperar o termino de uma tarefa para executar outra.
Um sistema `multi-thread` possui várias threads para cada processo, podendo realiza-las simultaneamente.

##4. Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?

A quinta requisição fica aguardando, na "Task Queue",  uma das quatro primeiras terminar para entrar na `Thread Pool`.

##5. Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?

- Necessita de bem menos investimento em hardware por ser muito mais eficiente que seus concorrentes.
- Possui Inúmeras biblicotecas open-source e mais sendo criada a cada dia, eliminando custos com software.
- O NodeJS é em linguagem JavaScript que é um linguagem muito bem difundida e conhecida pela comunidade.
- É uma plataforma extremamente eficiente, possui bibliotecas assíncronas, que com investimento em hardware muito baixo em relação a concorrentes pode atender a milhões de requisioções

##6. Qual a versão do seu `node`?

> $ node -v
> v7.7.4

##7. Qual a versão do seu `npm`?

> $ npm -v
> 4.1.2


text:
# Node.js - Aula 01 - Exercício
**user:** [yesroh](https://github.com/yesroh)
**autor:** Ronaiza Cardoso
**date:** 1469727485264

## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.

O processo síncrono espera a resposta de cada operação, não realizando nenhuma outra operação enquanto não recebe tal resposata.

```js

// Código Síncrono
fs.writeFileSync('arquivo.txt', 'Hello World');
console.log('Executa a função síncrona');

```
Enquanto o processo assíncrono executa várias tarefas nunca esperando a resposta da operação.

```js

// Código Assíncrono
fs.writeFile('arquivo.txt', 'Hello World', function(error){
    console.log('Executa a função Assíncrona');
});

```

## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.

Google criou o V8 (interpretador escrito em C++) para criar classes escondidas e assim executar o JS

[Processo de execução V8](https://www.future-processing.pl/wp-content/uploads/2015/04/threads-in-node.ja_.png)

## Qual a diferença entre um sistema single para um multi-thread?

 - single-thread não esperam um bloqueio síncrono ou uma operação de longa duração
 - multi-thread colocam os eventos na fila

## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?

Ela aguarda até que uma thread seja liberada, enquanto isso ela ficará na idle thread esperando sua vez para ser executada

## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?

Faria uma apresentação com os case de sucesso com a susbtituição do node pelos servidores que a minha empresa usa.

## Qual a versão do seu `node`?

```js
~$ node -v
v4.4.7
```

## Qual a versão do seu `npm`?

```js
~$ npm -v
2.15.8
```


text:
# Node.js - Aula 01 - Exercício

**Autor:** Wendell Adriel Luiz Silva - [WendellAdriel](https://github.com/WendellAdriel)
**Data:** 1454965303866

## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.

- **Processo Síncrono:** Um processo síncrono mantém uma única fila de processos, sendo necessário terminar um processo
antes de se iniciar outro. Exemplo:

```js
var fs = require('fs');

// Faz leitura do primeiro arquivo por completo e escreve no console
var greeting = fs.readFileSync('./greeting.txt', 'utf8');
console.log(greeting);

// Faz leitura do segundo arquivo por completo e escreve no console
var hello = fs.readFileSync('./hello.txt', 'utf8');
console.log(hello);
```

- **Processo Assíncrono:** Um processo assíncrono não mantém uma fila única de processos e não precisa terminar um para
iniciar outro processo. Eles são executados simultaneamente, não sabendo em qual ordem serão terminados, dessa maneira os
processos precisam de um `listener` que irá disparar um `callback` quando aquele processo for concluído. Exemplo:

```js
'use strict';
var fs = require('fs');

/* Faz leitura do primeiro arquivo e define uma função de callback para ser
 * executada quando a leitura do mesmo for concluída
 */
fs.readFile('./greeting.txt', (err, result) => {
  // Caso ocorra algum erro escreve ele no console
  if (err) console.log(err);

  console.log(result.toString());
});

/* Faz leitura do segundo arquivo e define uma função de callback para ser
 * executada quando a leitura do mesmo for concluída
 */
fs.readFile('./hello.txt', (err, result) => {
  // Caso ocorra algum erro escreve ele no console
  if (err) console.log(err);

  console.log(result.toString());
});
```

## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.

O V8 é um interpretador escrito em C++ criado pela Google e usado no Google Chrome. Sua função é melhorar o desempenho de uma aplicação JavaScript compilando o código para linguagem de máquina, fazendo assim que o mesmo rode em uma velocidade de um código binário compilado.

![V8](https://qph.is.quoracdn.net/main-qimg-ab2a954b51c404efe66cdc7681da6b85?convert_to_webp=true)

## Qual a diferença entre um sistema single para um multi-thread?

- **Single Thread:** Tem um único `caminho` de execução, porém não quer dizer que não se possa executar mais de um processo dentro da mesma `thread`. Economiza uso de memória e de processamento da CPU, pois cria apenas um único processo para todos usuários.
- **Multi Thread:** Tem diversos `caminhos` de execução, podendo executar diversos processos ao mesmo tempo. Consome mais memória e mais processamento da CPU, pois cria um processo diferente para cada usuário.

## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?

Quando são enviadas mais requisições do que a `Thread Pool` pode aguentar, as requisições restantes ficam em uma fila de espera, aguardando a liberação de um espaço na mesma.

O valor padrão da `Thread Pool` é 4, porém esse valor pode ser alterado como podemos ver [aqui](https://github.com/joyent/libuv/blob/v0.10.19/src/unix/threadpool.c#L32).

## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?

Mostraria casos de sucesso de grandes empresas como **Paypal** e **Netflix** e também faria uma pequena aplicação utilizando **Node.js** e a linguagem atualmente utilizada na empresa para mostrar uma comparação entre as duas.

## Qual a versão do seu node?

```
node -v
v5.0.0
```

## Qual a versão do seu npm?

```
npm -v
3.3.6
```


text:
# Node.js - Aula 01 - Exercício
**user:** [lesilva00](https://github.com/lesilva00)
**autor:** Luís Eduardo Tenório Silva

## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.

Um processo **síncrono** é executado seguindo uma lógica sequencial onde é necessário o término do processo para que um novo processo seja executado, similar a uma fila de execução.

### Exemplo de execução síncrona usando o NodeJS:

```js

var fs = require("fs");
var data = fs.readFileSync('/tmp/ex.txt');
console.log(data.toString());

// Executando o node no servidor
$ node sincrono.js
Arquivo txt.

```
Um processo **assíncrono** permite que novos processos sejam executados sem o término do processo atual, eliminando o comportamento de lógica sequencial. Isso significa dizer que o Node.js é uma arquitetura não bloqueante. O diferencial do Node.js a outros servidores web é que ele é projetado para funcionar principalmente de maneira assíncrona, e isso é dado através do uso da biblioteca _libuv_, uma das principais bibliotecas do Node.js.

### Exemplo de execução assíncrona usando o NodeJS:

```js

var fs = require('fs');
// A função readFile() do módulo fs é por padrão
// assíncrona, ou seja, é executada sem bloquear
// nenhum outro processo. Após o término da
// leitura, uma função de Callback é invocada.
var data = fs.readFile('/tmp/ex.txt', function(err,data){
   if(err)
      return console.error(err);
   console.log(data.toString());
});

// Executando o node no servidor
$ node sincrono.js
Arquivo txt.
```

## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.

O V8 é um motor de interpretação de JavaScript desenvolvido em C++ pela Google como motor principal do [Chrome](https://www.google.com/chrome/). Atualmente, outros projetos de browsers implementam o V8 como principal motor javascript devido a sua alta performance (Ex: Opera, Chromium, etc). Basicamente o V8 funciona compilando um código javascript em código de máquina, permitindo executar o código final como um binário, garantindo assim uma boa performance. A imagem abaixo demonstra o funcionamento de um motor de compilação do código em JavaScript para código de máquina.

![Funcionamento do motor V8](https://qph.ec.quoracdn.net/main-qimg-ab2a954b51c404efe66cdc7681da6b85?convert_to_webp=true)

## Qual a diferença entre um sistema single para um multi-thread?

Um sistema **_multi-thread_** executa cada solicitação de um cliente em uma _thread_, criando assim diversas threads (também denominada pool de _threads_) para atender diversos usuários. Alguns exemplos de servidores que utilizam o modelo de sistemas em _multi-thread_ são o Apache e JSP. Esses sistemas possuem uma arquitetura onde várias _threads_ são pré-alocadas e ficam no aguardo de solicitações de usuários. Dessa maneira recursos como memória e processamento não são bem aproveitados.

Um sistema **_single-thread_** executa as solicitações dos clientes em uma única _thread_. O Node.js é um exemplo de sistema web que trabalha de modo _single-thread_. Cada solicitação recebida gera um evento que é processado por uma única thread denominada _Event-loop_ que observa de maneira cíclica uma fila de eventos. Quando um evento ocorre, o _Event-loop_ captura-o e executa uma função de Callback definida naquele evento. Essa função é executada de maneira assíncrona (embora possa ser executada de maneira síncrona) em um _pool_ de _threads_ pré especificado. Embora existam um conjunto de _threads_ para a execução de eventos, a captura dos eventos é realizada por uma _single-thread_.

## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?

Embora o tamanho padrão do _Thread Pool_ seja 4, pode-se alterar o número de _threads_ utilizadas para até 128 _threads_ (através da variável de ambiente `UV_THREADPOOL_SIZE`) ou em tempo de execução através do comando `process.env.UV_THREADPOOL_SIZE`. Quando o valor de requisições é maior que o número disponível de _threads_ no _Thread Pool_, as solicitações que não foram atendidas esperam na fila de _threads_ (_Task Queue_) até que uma thread do _Thread Pool_ esteja disponível.

## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?

Primeiramente faria uma pequena apresentação do que é o Node.js e suas principais diferenças quando comparado com outros modelos de servidores web disponíveis no mercado.

Após isso, apresentaria números de performance em comparação a outros servidores, número de desenvolvedores necessários para realizar um determinado projeto, número de desenvolvedores necessários para manter o projeto, nível de complexidade(número de arquivos e linhas de código) e curva de aprendizado (se necessário).

Para finalizar apresentaria os casos de sucesso da implantação do Node.js e as principais empresas que migraram seus servidores para essa nova tecnologia (ex: PayPal e Netflix) e suas principais opiniões.

## Qual a versão do seu `node`?

Versão LTS (2016)
```
ubuntu@ubuntu:~$ node -v
v4.4.7

```

## Qual a versão do seu `npm`?

```
ubuntu@ubuntu:~$ npm -v
2.15.8

```


text:
# Node.js - Aula 01 - Exercício
**Autor:** Ednilson Amaral
**Data:** 15/12/2015 às 18:15

## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.

### Síncrono

Em um processo síncrono é executado apenas uma função por vez, não mais que isso. Um exemplo simples para entendermos, digamos que tenhamos que baixar 20 imagens de um servidor, no processo síncrono ele vai fazer a requisição para o servidor e baixar uma imagem, e, enquanto não terminar de baixar essa imagem, ele não vai fazer outra requisição para baixar a próxima imagem. Ou seja, vai demorar séculos para baixar todas as 20 imagens do servidor.

### Assíncrono

Já em um processo assíncrono, é possível executar várias funções por vez. Não possui uma ordem definida e não sabemos qual irá terminar primeiro ou por último.

Seguindo o mesmo exemplo do download das 20 imagens de um servidor, no processo assíncrono, é enviado ao servidor várias requisições ao mesmo tempo, para baixar as 20 imagens. Então, será baixado as 20 imagens ao mesmo tempo. Porém, não sabemos qual terminará por primeiro ou por último, e não terá uma ordem para baixar as imagens.

## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.

Ele compila o código JavaScript para o formato nativa de máquina, assim, permitindo que rode na velocidade de um código binário compilado.

O V8 compila e executa o código JavaScript, manipulando a alocação de memória para objetos e coletando os que não é necessário nos objetos. Essa coleta de objetos descenessários é uma das chaves para o desempenho do V8. O V8 também oferece todos os tipos de dados, operadores, objetos e funções escificadas no padrão ECMA.

![Exemplo de como funciona o engine do JS com V8](https://raw.githubusercontent.com/ednilsonamaral/be-mean-instagram-nodejs/master/img/exemplo-v8.png)

## Qual a diferença entre um sistema single para um multi-thread?

Single-thread quer dizer que será executado apenas uma tarefa por vez. Então o sistema espera até que essa tarefa seja conclúida antes de iniciar outra tarefa. Cada tarefa será executado dentro de um processo, ou seja, se temos três tarefas, teremos três processos.

Nas multi-thread são executadas múltiplas tarefas de uma só vez, em um único processo.

## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?

Caso tenha 5 requisições ao banco, ele aguarda até que uma thread seja liberada, e então, a execute.

> Its default size is 4, but it can be changed at startup time by setting the UV_THREADPOOL_SIZE environment variable to any value (the absolute maximum is 128).
>
> [Thread pool work scheduling](http://docs.libuv.org/en/v1.x/threadpool.html?highlight=uv_threadpool_size)

## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?

### PHP vs Node.js

Caro chefinho, você nos solicitou um sistema imobiliário para termos uma base de apartamentos para solteiros na região metropolitana de SP, correto? Nós estudamos como faríamos e gostariamos de apresentar os motivos para que seja optado seu desenvolvimento com Node.js.

Imagine conosco:

* Milhões de solteirões na região metropolitana de SP;
* Com o marketing digital eficaz, esperamos inúmeros acessos simultâneos no site, principalmente durante à noite e madrugada;
* Queremos esse sistema funcionando o mais rápido possível, em menos de três meses;
* Não temos dinheiro para contratar muita mão-de-obra;
* Não temos tempo para entrevistar novos colaboradores;
* Etc 1;
* Etc 2;
* Etc 3;
* Etc (...);

Então, resolveremos da seguinte maneira esses impasses:

1. Se desenvolvermos com PHP:
* Teremos um certo limite, caso atinjamos um número muito alto de acessos simultâneos, e a cada nova requisição no nosso servidor, vai começar a dar BO, vai travar;
* Precisaremos contratar um backend foda em PHP, pois nós só manjamos de JavaScript. E o senhor já nos disse que não tempo e nem dinheiro pra isso;
* Se formos parar tudo pra aprender PHP pra poder desenvolver esse sistema, levaremos mais de três meses apenas para aprender esse paranaue.

2. Se desenvolvermos com Node.js:
* Nós já manjamos de JavaScript, então, podemos utilizar uma stack MEAN, por exemplo, totalmente em JavaScript para desenvolver o sistema;
* Será desenvolvido pela metade do tempo ou menos do que seria em PHP;
* Poderemos aguentar um número gigantérrimo de usuários simultâneos em nosso site, com um número gigantérrimo de requisições em nosso servidor, que ele vai aguentar, danadinho;
* Não gastará mais do que o planejado, pois já manjamos de JavaScript e Node.js é JavaScript!

Conseguiu perceber chefinho? Podemos utilizar Node.js em nosso sistema, sairá mais barato e mais rápido, e ainda, bem melhor do que seria em PHP! =D

Além de fazer essa jabazinho malandro, poderia também, lá no inicio, mostrar casos reais, como foi mostrado em aula, do PayPal, para ver exemplos reais de utilização do Node.js e seus inúmeros benefícios e vantagens.

## Qual a versão do seu `node`?

```
ednilson@EDNILSON-NB:~$ node -v
v5.2.0
```

## Qual a versão do seu `npm`?

```
ednilson@EDNILSON-NB:~$ npm -v
3.3.12
```


text:
# Node.js - Aula 01 - Exercício
**user:** [celosm](https://github.com/celosm)
**autor:** Marcelo Santana Martins
**date:** 1450083112501

## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
###Processo Síncrono
Um processo síncrono é executado sozinho, ou seja, quando a aplicação solicita a execução de vários processos, eles são executados apenas quando o seu antecessor finalizar.
```
var fs = require('fs');
var contents = fs.readFileSync('https://raw.githubusercontent.com/zemirco/sf-city-lots-json/master/citylots.json').toString();
console.log(contents);
```

###Processo Assíncrono
Um processo assíncrono consegue executar mais do que uma tarefa simultaneamente. Após o processo finalizar, uma funcção de _callback_ deverá ser chamada.
```
var fs = require('fs');
fs.readFile('https://raw.githubusercontent.com/zemirco/sf-city-lots-json/master/citylots.json', function(err, buf) {
  if(err)
    throw err;

  console.log(buf.toString());
});
```

## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
Ele interpreta o código JavaScript e o executa. O V8 é um interpretador escrito em C++ pelo Google no qual é possível integrá-lo em qualquer aplicativo. Assim, ele não fica restrito apenas ao navegador, e pode ser executado no servidor.

## Qual a diferença entre um sistema single para um multi-thread?
Um sistema _Single Thread_ é capaz de executar apenas uma tarefa por vez. Enquanto a tarefa é executada, todo o sistema aguarda que a _thread_ finalize para que possa seguir adiante.

Um sistema _Multi Thread_ consegue executar várias tarefas simultaneamente. Cada solicitação vira uma _thread_ e o servidor consegue trabalhar com ela isoladamente, sem intereferir nas outras.

## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Neste caso, a quinta requisição ficara no _Idle Thread_ aguardando a liberação de uma das quatro primeiras. Na sequência, ela é jogada para a _Thread Pool_ para ser executada.

## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Acredito que a melhor forma de convencer a adoção do Node.Js seria expondo suas vantagens. Mostrando também quais grandes empresas utilizam a tecnologia (Walmart, Ebay, Linkedin, Paypal, etc) e como um mesmo sistema seria desenvolvido em um prazo e custo menores.

## Qual a versão do seu `node`?
```
marcelo@marcelo-VirtualBox:~$ node --version
v5.0.0
```

## Qual a versão do seu `npm`?
```
marcelo@marcelo-VirtualBox:~$ npm --version
3.3.6
```


text:
# NodeJS - Aula 01 - Exercício
autor: Gustavo Prado

## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.

FORMA SÍNCRONA

Em NodeJS, os processos sincronos são bloqueantes. Portato, se existir outros processos
ou códigos a serem executados, o NodeJS aguarda o término do anterior para executar o próximo.

```js

var fs = require( 'fs' );
for (var i = 0; i <= 5; i++) {
  var file = 'sync-txt' + i + '.txt'
    , out = fs.writeFileSync(file, 'Hello Node.js!');
    console.log(out);

}
```

Esta abordagem irá parar a execução do restante dos processos até que a tarefa seja concluída.

FORMA ASSÍNCRONA

A forma assíncrona por outro lado, executa os processos de forma paralela.

```js

var fs = require( 'fs' );

for (var i = 0; i <= 5; i++) {
  var file = 'async-txt' + i + '.txt'
    , fs.writeFile(file, 'Hello Node.js!', function (err, out) {
      console.log(out);
    });
}
```

Esta abordagem voltará imediatamente para não bloquear o restante dos processos.

## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.

O V8, engine do NodeJS, interpreta e compila a linguagem JS para C++, convertendo para funções do V8,
permitindo a execução em código nativo.

## Qual a diferença entre um sistema single para um multi-thread?

Thread é uma forma de um processo dividir a si mesmo em duas ou mais tarefas que podem ser executadas concorrencialmente.
O suporte à thread é fornecido pelo próprio sistema operacional, ou implementada através de uma biblioteca de uma determinada linguagem.

Uma thread permite, por exemplo, que o usuário de um programa utilize uma funcionalidade do ambiente enquanto outras linhas de execução realizam outros cálculos e operações.

O node utiliza apenas uma thread para executar suas tarefas, podendo outras serem criadas, desta forma economizando memória. Portanto ele não precisa criar um novo processo para cada novo usuário poupando CPU.

Enquanto um sistema multi-thread utiliza várias threads para executar suas tarefas e desta forma acaba consumindo muito mais seus recursos computacionais, tais como: memória, cpu, etc.

Um bom exemplo é o Apache, que é um servidor HTTP multi-threaded. Para cada pedido que o servidor recebe ele cria uma thread separada que lida com esse pedido.

## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?

A quinta requisição aguarda a liberação de uma thread para ser executada.

De acordo com a  documentação  da LIBUV, o tamanho padrão da thread pool é 4, mas pode ser alterado em tempo na inicialização, definindo a variável de ambiente UV_THREADPOOL_SIZE para qualquer valor, sendo o máximo 128.

## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?

Enfatizando as principais qualidades do NodeJS, como:

Permite criar aplicações de rede rápidas e altamente escaláveis;
As aplicações em NodeJS executam em uma única thread;
É assíncrono e baseado em eventos;
Utiliza o modelo de I/O não bloqueante;
Economia de recursos, financeiros e computacionais;
É possível trabalhar com uma mesma linguagem base, o JS, o que acaba por criar profissionais fullstack;

## Qual a versão do seu NodeJS?

```
gustavo@gustavo-Inspiron-3442:~$ node -v
v5.6.0
```

## Qual a versão do seu NPM?

```
gustavo@gustavo-Inspiron-3442:~$ npm --version
3.6.0
```


text:
# Node.js - Aula 01 - Exercício

**user:** https://github.com/paulosilva92

**autor:** Paulo Roberto da Silva

**date:** Fri Feb 26 2016 22:33:04 GMT-0300 (BRT)

## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.

#### Assíncrono
Processos assíncronos no NodeJS fazem com que o *Event Looper* da plataforma funcione como deve funcionar, ou seja, de modo não bloqueante. Ele irá pegará um processo e irá delegar ele para seu respectivo lugar mas não ficará esperando ele ser completado para que inicie outros processos. Depois de terminada este processo ele disparará a *trigger* para sua função de *callback*, voltando para a fila que será executada pelo *Event Looper*.

##### Exemplo Assíncrono:
Utilizarei como exemplo a função assíncrona *readFile()* do módulo nativo do Node, o FS;

```js
const fs = require('fs'); //chamada do módulo

fs.readFile('./texto.html', 'utf-8', function(err, data){  //chamada da função passando o caminho do arquivo a ser lido, a codificação, e uma função de callback que será executada assim que o arquivo terminar de ser lido
    if (!err) console.log(data); //após a leitura do arquivo o seu conteúdo será mostrado na tela
});
console.log('lendo o arquivo...'); // como a função acima é assíncrona essa linha será executada antes do resultado da função readFile ser mostrada
```

#### Síncrono

Processos síncronas, por outro lado, funcionam de forma bloqueante, ou seja, farão o *Event Looper* ficar esperando sua resolução para que possa ir para outros processos. Isso diminui muito o desempenho da aplicação e não é o modo ideal de se trabalhar com NodeJS.

##### Exemplo Síncrono:

```js
const fs = require('fs'); //chamada do módulo

var texto = fs.readFileSync('./texto.html', 'utf-8'); //chamada da funão síncrona de leitura de arquivos, note que ela não possui uma função de callback sendo necessário armazenar seu retorno em uma variável para poder mostrar na tela
console.log(texto); //esta linha só será executada quando a função acima terminar, ou seja, caso o arquivo seja grande todo os processo ficarão parados
```

## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.

O V8 compila o código javascript para o código nativo da máquina para depois executá-lo. Ele trabalha de forma semelhante ao compilador do Java, sendo o NodeJs semelhante a máquina virtual do Java.

!['Imagem V8'](http://blog.gopivotal.com/wp-content/uploads/2012/04/NodeJS-EventedIOAsyncIO_latest.png)

## Qual a diferença entre um sistema single para um multi-thread?

Um sistema single thread trabalha com apenas uma thread. Isso faz com que haja um ganho de performance e de consumo de recursos do computador pq não será necessário abrir variás threads para diversos processos, que é como os multi threads funcionam. Sistemas multi threads tendem a consumir mais memória RAM, como no caso do Apache, que aloca uma quantidade de RAM para cada usuário que conecta, fazendo com que haja uma limitação dos recursos de cada máquina.

O Node é um sistema single thread que se utiliza de muitas ferramentas para poder fazer igual ou mais que outras plataformas muitl thread em questão de desempenho, mas com menos recursos.

## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?

Quando é enviado um número de requisições que excedem o tamanho da Thread Pool as requisições excedentes ficam esperando para que possam uma "vaga" seja liberada.

## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?

Mostraria os diversos casos de usos de grandes empresas que migraram seu backend para Node, como a Netflix e o Paypal. Mostraria também o comparativo de velocidade e consumo de recursos entre o Node e outras linguagens usuais do mercado, como Java e PHP.

## Qual a versão do seu `node`?

```
➜  ~ node -v
v5.7.0
```

## Qual a versão do seu `npm`?

```
➜  ~ npm -v
3.6.0
```


text:
# NodeJS - Aula 01 - Exercício
**Autor:** Rony souza (user: rxon7)
**Data** 28/06/2016

# 1. Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.

```

**Síncrono**:  Em um processo síncrono, a medida que os usuários irão acessá-la, ela vai gerando
múltiplos processos no servidor e apenas uma função será executada por vez, como por exemplo
uma espera de um pedido no restaurante que tem apenas um garçon e só um cliente será atendido
 por vez demorando muito mais para ser atendido.

**Assíncrono**: No processo assíncrono várias funções são executadas por vez. O Servidor responde a
primeira Requisição da fila e aguarda a sua chamada de retorno.  o cliente envia a requisição
o nodejs responde a primeira requisição e aguarda a chamada de retorno, ao mesmo tempo atende
outras requisições e fica escutando a chamada de CALLBACK das outras requisições enviadas.

Voltando ao exemplo do restaurante, no modelo assíncrono, o garçom pegaria o pedido do cliente,
passaria para a cozinha, e enquanto a cozinha prepara o prato, o garçom atende a segunda mesa.

```

# 2. Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.

O V8 compila o JavaScript para c++ alocando esses espaços na memoria criando classes escondidas, em tempo de execução,
a fim de ter uma representação interna do sistema de tipo e para melhorar o tempo de acesso as propriedades.

Exemplo:

!['Imagem V8'](http://i.imgur.com/NZlw2Z5.png)

```

# 3. Qual a diferença entre um sistema single para um multi-thread?

```

Com o single thread vocẽ econômiza mais memória, pois você pode ter a instancia de um
processo por vez, já com o multi thread você pode ter os processos e os auxiliares
do processo além dos outros threads rodando em paralelo.

```

# 4. Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?

```
Como ele é I/O bloqueante, uma das requisições vai ter que esperar as 4 outras terminarem,
Neste caso, a quinta requisição, entrará na fila de execução, aguardando que o alguma
requisição seja entregue para que ela entre em execução.

```

# 5. Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?

```

Mostraria cases de sucesso como o paypall e falaria de suas vantagens e da economia tanto em codigo como eu
mão de obra e equipes que já estão implementando em suas empresas e como vem ajundando no desenvolvimento rapido
e com baixo custo.

```

# 6. Qual a versão do seu `node`?

```
node -v
v6.2.0

```

# 7. Qual a versão do seu `npm`?

```
npm -v
3.8.9

```


text:
# Node.js - Aula 01 - Exercício
**user:** https://github.com/FranciscoValerio
**autor:** Francisco Henrique Ruiz Valério
**date:** 2015-12-08T21:59:10

## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.

Assíncrono:
	Exemplo:
		A API Google Maps V3 (Geocoding service) trabalha de forma assíncrona, como ela recebe milhões de requisições de endereços para serem transformados em latitude e longitude. Ela não aguarda uma requisição terminar e retornar o resultado, pense isso seria muito lento para a quantidade de requisições que ela recebe. Portanto ela recebe as requisições e não espera seu resultado e vai recebendo as próximas da "fila". But what about the results???

		No Node como por padrão qualquer função é assícrona sempre precisaremos de uma função que sempre será chamada após o processamento ter sido finalizado, estas chamadas de callback.

		Portanto é assim que o resultado e obtido na consulta a API mencionada acima.

Síncrono:
	A beleza do Node está em utilizar requisições assíncronas.

	Exemplo:
		Um exemplo de síncrono poderiamos pegar uma fila de pedágio. A operadora da cabine não consegue atender mais de um carro ao mesmo tempo portanto ela deverá anter um carro receber dele e liberar a passagem, após esse processo ela estara "liberada" para atender o próximo carro da fila gerando assim uma demora como bem conheçemos.

		Para utilizar o Node de forma síncrona é nescessário passar duas funções como parametro, uma para tratamento de erro e outra para sucesso.
		Muito cuidado com a "Síncrona" pois o Node é Single Thread isso significa que caso um processo bloqueie essa Thread o Node também irá ficar bloqueado aguardando seu termino.

## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.

https://github.com/FranciscoValerio/imagens/blob/master/img-be-mean/v8-sample.jpg

## Qual a diferença entre um sistema single para um multi-thread?

Um sistema single thread, significa que aquele sistema consegue executar apenas uma tarefa pois trabalha somente com uma thread, ou seja caso seja executado um processamento muito demorado o sistema ficará bloqueado aguardando o termino desse processamento. Já em um sistema multi-thread caso seja necessário executar um processamento que o sistema irá ficar bloqueado é aberto uma nova thread para ser executado esse processamento nessa ou seja, com isso o sistema irá ficar liberado para uso.

## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?

Por padrão a thread pool é de 4 no Node, a 5 requisição será incluída a idle thread oque seria essa idle thread nada mais é do que as requisições que estão aguardando uma das 4 requisições que estão na thread pool serem executadas para as mesmas poderem serem executadas.

## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?

Primeiramento mostraria um comparativo de JAVA com NodeJS mostrando os números de beneficíos que a empresa ganharia se migrace para Node primeiramento os ganhos no desempenho do software gerando a satisfação dos clientes. Segundo a economia de tempo de desenvolvimento devido a curva de aprendizado ser grande, e por último não menos importante mostraria a economia que Node geraria na folha de pagamento da empresa. Claro que tudo isso com muitos gráficos e percentual de redução de custo operacional.

## Qual a versão do seu `node`?

PS C:\Be-Mean\NodeJS\Aula01> node -v
v5.1.1

## Qual a versão do seu `npm`?

PS C:\Be-Mean\NodeJS\Aula01> npm -v
3.3.12


text:
# Node.js - Aula 01 - Exercício
**user:** [marks88martinez](https://github.com/marks88martinez)
**autor:** Marcos Antonio Martinez Florentin
**date:** 1457436489971

## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.

O processo Síncrono realiza uma operação de execução, depois da execução passa a seguinte operação

```js

var fs = require('fs');
fs.writeFileSync('/path', function(err, buf) {
  console.log('Codigo Sincrono');
});

```

Processo assíncrono executa várias tarefas ao mesmo tempo, ele nunca espera que uma operação seja concluída, mas sim executa todas as operações.

```js

fs.writeFile('/path', function(err, buf){
    console.log('Codigo Assincrono');
});

```

## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.

O Motor de V8 do google compila o javascript em eventos não bloqueante,
Todos os códigos se executam em um única thread.

http://image.slidesharecdn.com/betabeers-mean-140329120323-phpapp01/95/full-stack-javascript-mean-betabeers-zgz-6-638.jpg?cb=1396094667

## Qual a diferença entre um sistema single para um multi-thread?

**single-thread** O processo de thread não espera um bloqueio síncrono, ou uma operação de duração. O nodejs coloca na fila de eventos.

**multi-thread** A cada requisição saô feitas em uma Thread pode assim então gerar mais processos.

## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?

Ele vá fazer as 4 requisições e o 5to fica no _Idle Thread_ aguardando que um seja liberado das 4 primeiras, na seqüência ele e jogado no _Thread Pool_ para ser executado

## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?

Nodejs é uma tecnología ágil e atual, possibilitando amplo crescimento.

As empresas que a utilizam são de êxito total, como PayPal e Nexflix que ao implementar diminuíram o tempo no desenvolvimento. Assim aumentaram para o dobro o número de requisições ao serviço comparado a outra plataforma.

## Qual a versão do seu `node`?

```js
~$ node -v
v5.4.1
```

## Qual a versão do seu `npm`?

```js
~$ npm -v
3.3.12
```


text:
# Node.js - Aula 01 - Exercício:w
**user:** [sostenesfreitas](https://github.com/sostenesfreitas)
**autor:** Sóstenes Freitas de Andrade
**date:** new Date()

## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Processo assíncrono é quando é executado apenas um processo por vez, onde o Node ficará limitado aquele processo ate que o mesmo termina, para só aṕos finalizar a execução daquele determinado processo, poder iniciar a execução novo processo.
EX:
```
function exemploSincrono1(){
    console.log("sicrono1");

}
function exemploSicrono2(){
    console.log("sicrono2");

}
test();
test2();
```

Já o processo assíncrono que é utilizado pelo Node por padrão, é capaz de executar vários processos de uma só vez, em 'paralelo'
mas o que acontece na verdade não é que ele executa varios processos simultaneos, ele simplesmente manda executar o processo com um callback e já vai para o próximo processo, quando qualquer um dos processos que já foi mandado executar terminar seu processo ele manda o callback de retorno para o Node finalizar aquele processo.
EX:
```
function exemploAssicrono1(){
    console.log("Assíncrono1");

}
function exemploAssicrono2(){
    setTimeout(Assicrono, 0);
    console.log("Assíncrono");
    console.log("Assicronoo2");

}
exemploAssicrono2();
```

## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O V8 é o motor de renderização do javaScript que funcioná como uma máquina virtual que compila o código em js para o formato nativo de máquina antes de executá-lo, tendo como propósito aumentar o desempenho da aplicação.

![Exemplo](http://image.slidesharecdn.com/15fuv8js7ulf1nzuakfe-140628073041-phpapp01/95/nodejs-enterprise-middleware-25-638.jpg?cb=1403940779)

## Qual a diferença entre um sistema single para um multi-thread?
Tem mais arquiteturas além de single-thread (ST) e multi-thread (MT). Basicamente o ST só pode tratar uma requisição de cada vez, então o processamento de cada uma não pode ser demorado, nem pode bloquear (por exemplo, ficar esperando pelo banco de dados). O MT, assumindo que se crie uma thread por requisição, pode tratar várias requisições em paralelo, mesmo que demorem ou bloqueiem.

## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Devido ao fato de a thread pool suportar apenas 4 requisições, caso acontece de a quantidade de requisição ultrapassar o tamanho padrão da thread pool, as requisições suplentes vão para a 'Task Queue'(fila de tarefas) e aguarda até que umas das threads sejam liberadas.

## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Ready for real-time: O Node.js ficou popular graças aos seus frameworks que interagem em real-time entre cliente e servidor. SockJS, Socket.IO, Engine.IO são alguns exemplos disso. Eles são compatíveis com o novo protocolo WebSockets e permitem trafegar dados através de uma única conexão bi-direcional, tratando as mensagens via eventos no JavaScript.
Big players usando: LinkedIn, Wallmart, Groupon, Microsoft e Paypal são algumas das empresas usando Node.js atualmente.

## Qual a versão do seu `node`?
 miojo at corsair in ~ [19:34:13]
→ node -v
v6.2.1

## Qual a versão do seu `npm`?
miojo at corsair in ~ [19:34:45]
→ npm -v
3.9.3

```
```
```
```