text:
# Node.js - Aula 01 - Exercício
**user:** [airton](https://github.com/airton)
**autor:** Airton Vancin Junior
**date:** 1455241588976

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

Processo síncrono espera que cada operação seja executada por completo, depois que é executado ele passa para a operação seguinte.

```js

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

```

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

```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.

O Nodejs roda em uma JavaScript V8 VM, ou seja, JavaScript no lado do servidor. O motor JavaScript V8 compila o códigio JavaScript para código de máquina para depois executá-lo.

![nodejs](https://cloud.githubusercontent.com/assets/397832/12302385/0ca4ffce-ba0c-11e5-9ab8-7546dc52d646.png)

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

PHP, Ruby, ASP entre outras linguagens server-side são "multi-thread" mas o Nodejs é "single-thread"

A single-thread não tem que esperar um bloqueio síncrono ou uma operação de longa duração. O Nodejs coloca na fila de eventos e segue em frente.

## 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 5 requisição ao banco, ela aguarda até que uma Thread seja liberada, então essa requisição será incluída em uma Idle Thread esperando sua vez de ser jogada no 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?

Citaria os cases do PayPal e Netflix que mudaram a plataforma Java para Nodejs, e ambos diminuiram o tempo e quantidade de pessoas 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.6.0
```

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

```js
~$ npm -v
3.6.0
```


text:
# Nodejs - Aula 01 - Exercício
autor: Marcelo Alves
github: MalvesGO

## 1- Explique com um processo sincrono e assincrono roda no Nodejs, dê um exemplo para cada

Síncrono: No modo síncrono existe uma fila de espera que só termina assim que o usuário receber a resposta, assim o proximo usuário tem que aguardar até que o processo seja concluído.

Exemplo: A fila de um banco

Assíncrono: No modo assíncrono não existe filas então a cada requisição já obtemos a resposta imediata da solicitação.

Exemplo: Estacionamento de carros

## 2- Como o V8 executa Javascript? Demonstre um exemplo com código ou imagem

O V8 foi o nome dado ao interpretador Javascript, também conhecido de VM (maquina virtual), foi desenvolvido pela Google para ser usado no navegador Google Chrome.

A principal virtude do V8 é acelerar o desempenho de aplicações compilando o codigo Javascript para o formato nativo de maquina antes de ser executando, permitindo assim que rode a velocidade de um código binário ja compilado.

Tendo como premissa a idéia do Nodejs é trabalhar com múltiplas requisições e permanecer leve e eficiente.

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

A diferença entre sistemas single e multi-thread é que ao usar uma unica thread apenas uma tarefa pode ser realizada em determinado tempo e o programa deve esperar até a tarefa ser concluida, já nos sistemas multi-thread as tarefas podem ser realizadas de modo simultáneo não bloqueando novas requisições o que nos proporciona um ganho imenso em produtividade e desempenho.

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

Libuv tem um tamanho total de  4 threads por padrão e utiliza uma fila para gerenciar o acesso ao poll de threads. Nesse caso quando você tiver 5 pesquisas de longa duração simultaneas um deles vai ficar aguardando por estas pesquisas antes mesmo delas começarem.

Podemos aumentar o tamanho deste conjunto de threads através da variável de ambiente UV_THREADPOOL_SIZE, e modificarmos a variável de acordo com as necessidades do projeto process.env.UV_THREADPOOL_SIZE = 10;

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

Acho que a melhor forma de convencer uma pessoa a usar Nodejs seria mostrar com uma aplicação real rodando e demonstrar o "poder de fogo" do Javascript. Criaria um dashboard fazendo requisições nos dados da empresa e mostrar o seu funcionamento utilizando socket.io (dados em tempo real). Isso seria o pontapé inicial para tentar convencer a adoção do Nodejs.

## 6- Qual a versão do seu Node.js?

```
marcelo@marcelo-js:~/Projetos$ node -v
v0.10.41

```

## 7- Qual a versão do seu NPM?

```
marcelo@marcelo-js:~$ npm -v
1.4.29

```

repo_language: JavaScript

mime_type: text/plain


text:
# Node.js - Aula 01 - Exercício
**user:** [sergiokopplin](https://github.com/sergiokopplin)
**autor:** Sergio Kopplin
**date:** 1454730409490

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

Um processo síncrono em node.js consiste em executar uma função e esperar o seu fim para que desse modo o sistema possa continuar a execução de outras funções. Por exemplo:

```JS
var fs = require('fs');
var contents = fs.readFileSync('/etc/passwd').toString();
console.log(contents);
```

Nesse primeiro exemplo, apenas quando a função **readFileSync** for terminada ele executará o **console** que vem em seguida, executando ambos de forma **síncrona**.

A grande diferença entre ambos é de que o processo assíncrono pode ocorrer e o sistema continuará a executar outros processos distintos, de forma **assíncrona**, impedindo assim que o seu funcionamento sofra uma parada na execução.

```JS
var fs = require('fs');
fs.readFile('/etc/passwd', function(err, buf) {
  console.log(buf.toString());
});
```

No nosso último exemplo, o javascript executará o **console** enquanto ele lê o arquivo através da função **readFile**, executando os dois ao mesmo tempo, de forma **assíncrona**.

ref: [daveeddy.com](http://www.daveeddy.com/2013/03/26/synchronous-file-io-in-nodejs/)

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

O v8 é um tipo de "Máquina Virtual". O objetivo do v8 é compilar a linguagem JS escrita pelo desenvolvedor para uma linguagem otimizada que o browser entenda ou que seja embarcada em uma aplicação.

No core fo v8 temos dois compiladores diferentes. "Full-codegen" que compila com mais velocidade e produz código sem otimização e o "Crankshaft" que demora mais em sua compilação mas produz código otimizado.

![Imagem v8](img/v8-2.jpg)

Na nossa imagem de exemplo temos uma pequena ideia de como uma engina JS funciona. Seguindo esses passos a engine consegue compilar o código e devolver algo que o navegador ou aplicação consegue interpretar.

Durante a compilação, a engine utiliza o C++ para conversão do código necessário.

ref: [quora.com](https://www.quora.com/How-does-a-JavaScript-engine-work)
ref: [thibaultlaurens.github.io](http://thibaultlaurens.github.io/javascript/2013/04/29/how-the-v8-engine-works/)

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

![Thread](img/thread_processes.jpg)

Na nossa imagem de exemplo podemos visualizar as "Single Threaded Process" e as "Multi-threaded Process". Basicamente, um sistema que utiliza o processamento de modo "Single" consegue executar um processo de modo único, indo de passo em passo até o final de sua execução. No caso do "Multi" o sistema pode sim executar mais de uma função ao mesmo tempo sem que isso afete cada processo individualmente, podendo então gerenciar o processamento de modo a atender a todos os processos necessários e atingir o resultado satisfatório para todos os processos.

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

Caso a thread pool receba processos além de sua capacidade, os em questão entrarão em uma fila de espera até que possam ser executados.

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

O node.js é uma linguagem atual e quem crescido muito. A motivação principal se dá quando pensamos em velocidade e performance, mas também podemos pensar nas apis disponíveis e em como a linguagem pode ser escalada e alterada com facilidade.

O nodejs tem se apresentado firme em sua utilização, e o casos de uso disponíveis na internet são mais que suficientes para saber que a linguagem é sim, poderosa e estável, e não uma linguagem passageira que não tem a força necessária para se perpetuar definitivamente.

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

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


text:
# NodeJS - Aula 01 - Exercício
**Autor:** Luan da Silva Oliveira
**User:** luanconecte

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

A beleza do NodeJs está em sua assincronicidade. Esse processo faz com que ao executarmos um evento de entrada ou saída (I/O) no sistema, o mesmo não fique bloqueado, aguardando o término da operação, para só então executar uma nova atividade.
No processo síncrono acontece uma fila de processos na qual o evento sucessor depende do termino do evento antecessor para ser executado.

Para os exemplos criei um arquivo itens.txt para ser lido com File System.

itens.txt
```
item 1
item 2
item 3
```

Exemplo de processo síncrono

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

console.log( fs.readFileSync("itens.txt").toString() );

console.log("item 4");

/*
result:
item 1
item 2
item 3
item 4
*/
```

Exemplo de processo assíncrono
```js
var fs = require('fs');

fs.readFile("itens.txt", [], function(err, data) {
    if (err) {
        throw err;
    }
    console.log(data.toString());
});

console.log("item 4");

/*
result:
item 4
item 1
item 2
item 3
*/
```

Como podemos perceber nos exemplos a cima, no processo síncrono o File System leu o arquivo itens.txt para só depois mostrar o item 4. No processo assíncrono o node comunicou que o arquivo itens.txt precisa ser lido, mostrou o item 4 e quando obteve a resposta do File System mostrou o conteúdo do arquivo itens.txt. Por isso a ordem da lista é diferente nas duas abordagens.

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

O Node usa o JavaScript V8 VM (Virtual Machine) que é a engine criada pela equipe do google para ser utilizada em seu navegador Google Chrome. O V8 é um projeto open source de alta performace escrito em C++, ele funciona compilando o código JavaScript e manipulando a alocação de memória de objetos que já não são mais necessários.

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

Um sistema single thread é executado utilizando uma unica thread para todo o seu funcionamento, através do event-loop que gerencia as execuções. Já um sistema multi-thread, para cada nova requisição é criado um novo processo, que por conseguinte aumenta o uso de memória e processamento da máquina.

# 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 ficará aguardando que uma das requisições anteriores saia do Thread Poll, para só então seja executada.

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

Primeiramente desenvolveria algum produto simples e eficaz, que atendesse algum tipo de demanda da empresa com maior escabilidade ou performasse do que as linguagens que utilizamos atualmente (PHP, Ruby on Rails). Depois que ganhei a atenção com o novo produto, demonstro alguns cases de sucesso de outras empresas com a mesma tecnologia (LinkedIn, Wallmart, Groupon, Microsoft e Paypal). Para concluir e quem sabe ganhar a aprovação de todos demonstro alguns dos pontos fortes da linguagem:

+ Non-Blocking IO
+ Comunidade Ativa
+ Ready for real-time

É claro que surgirão questionamentos e se bem conheço meu ambiente de trabalho o que mais impactaria seria o fato de ter que aprender uma nova tecnologia, o que é um argumento válido para uma empresa onde o objetivo principal é produzir, produzir e produzir... Mas felizmente o NodeJs utiliza o JavaScript para tudo, então além de não ter que aprender uma nova linguagem vamos utilizar a mesma no client, server-side e banco de dados.

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

```
luanoliveira@luanoliveira ~/www/be-mean-instagram-nodejs-exercises/class-01 $ node -v
v5.3.0
```

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

```
luanoliveira@luanoliveira ~/www/be-mean-instagram-nodejs-exercises/class-01 $ npm -v
3.3.12
```


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

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

**autor:** LUCAS DA SILVA MOREIRA

**date:** 1449700152468

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

**Síncrono**: No processo síncrono apenas uma função será executada por vez. Fazendo uma analogia com o mundo real, pense na fila do **Mc Donalds** que tem apenas um caixa disponível. Apenas um cliente será atendido por vez criando uma fila imensa e desagradável.

**Assíncrono**: No processo assíncrono várias funções são executadas por vez. Nunca sabemos quem terminará primeiro. Por isso, se quisermos executar algo quando uma função chegar ao seu fim, temos de fazer isso através de um **callback**. Exemplo:

```
fs.readFile('arquivo.txt', function(data) {
	// faz algo
});
```

Fazendo uma analogia com o mundo real e processos assíncronos, pense na mesma fila do **Mc Donalds** mas com vários caixas funcionando. Muitos usuários são atendidos por vez.

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

![v8](https://github.com/fauker/be-mean-instagram-nodejs/blob/master/images/v8-code.png)

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

Em um sistema que suporta apenas Single Thread, apenas uma tarefa será executada por vez, caso as tarefas sejam síncronas. E, enquanto uma tarefa está sendo executada, todo o sistema para esperando essa Thread terminar. Ou seja, o processamento é bloqueado.

Já em um sistema Multi-Thread, se uma Thread estiver sendo executada, outra Thread pode ser criada para que o processamento não seja bloqueado.

## 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** esperando sua vez se ser jogada no **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?

Bom, eu defenderia os casos de sucesso de empresas que adotaram o **Node.js**, como o Paypal, Netflix etc. Também eu poderia fazer a mesma aplicação que hoje está em produção, só que em Nodejs e comparar os ganhos. Com o argumento da comparação de ganhos eu acho que qualquer chefe, investidor ficaria convencido.

## 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:** [leolimadev](https://github.com/leolimadev)
**autor:** LEONARDO CASSURIAGA LIMA
**date:** Tue Dec 15 2015 22:27:28 GMT-0200

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

Um processo síncrono bloqueia o event loop enquanto processa, ele não pede para o kernel fazer uma gravação síncrona no sistema de arquivos.
Exemplo:

fs.readFileSync('/arquivo.txt', "utf8");

Note que como a execução é síncrona não existe a chamada de um callback, diferente do exemplo abaixo que é assincrono.

Um processo assincrono não bloqueia o event loop enquanto processa, não fazendo outros processos aguardarem pelo fim da execução.

fs.readFile('/arquivo.txt', function (err, data) {
  if (err) throw err;
  console.log(data);
});

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

Javascript é uma linguagem baseada em protótipos com tipagem dinamica. O V8 trabalha criando classes escondidas conforme a necessidade de representar
o tipo que a propriedade esta sendo acessada. Isto ajuda muito na otimização, visto que o V8 consegue a partir disto agrupar objetos com as mesmas propriedades.
!['V8 Javascript'](http://thibaultlaurens.github.io/assets/themes/img/post/21-03-13-v8/transition.PNG)

 Referências:
 https://developers.google.com/v8/design?hl=en
 http://thibaultlaurens.github.io/javascript/2013/04/29/how-the-v8-engine-works/

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

Em um sistema single thread todas as requisições são enfileiradas, para uma requisição iniciar, a anterior deve ter sido finalizada.
Em um sistema mult thread mais de uma requisição pode ser inciada 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 requisição entra em uma fila de espera até que uma das outras quatro libere o acesso a esta.

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

Node é baseado em javascript, a linguagem que todo desenvolvedor de aplicações web e hibridas deveria ter um bom nível de conhecimento.
Tirando as particularidades do javascript, qualquer desenvolvedor de outra linguagem back-end ou programador javascript front-end terá uma curva
de aprendizagem pequena versus a produtividade possível.
É uma linguagem rápida, fácil de escalar que além de ser open source já esta sendo adotada por grandes players de mercado como netflix, pay pal e wallmart.
Alguns destes players divulgam com frequência números tanto de dedempenho quanto de produtividade ganhos com a adoção do NodeJS.

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

v5.0.0

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

3.3.6


text:
# NodeJS - Aula 01 - Exercício
**Autor**: Igor luíz
**Github**: [Halfeld](https://github.com/Halfeld)
**Data**: 1455743835692

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

**síncrono**: Aqui os processos são realizados um depois do outro, ou seja, tendo dois processos, o segundo só começa quando o primeiro terminar.

**assíncrono**: Aqui os processos são realizados paralelamente, ou seja, tendo dois processos, eles executam juntos.

![exemplo](http://www.diogomatheus.com.br/blog/wp-content/uploads/2013/02/Requisicao_Analogia_Pizza.jpg)

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

O V8 transforma o código escrito em javacript e compila para linguagem de maquina, manipulando alocação de memória.

_Exemplo:_

>**I/O**
>Código JavaScript ==> V8 ==> libuv ==> Sistema Operacional
>
>**Callback**
>Sistema Operacional ==> libuv ==> V8 ==> Código JavaScript

#### 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, 1 das requisições vai ter que esperar as 4 outras terminarem, entretando um _cluster_ resolveria o problema.

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

Demonstraria o funcionamento do Node de forma simples e com linguagem mais coloquial o possível(tratando de alguém que não sacasse dos paranauê), resaltando como ele poderia dimuir o tempo de trabalho, dor de cabeça e aumentando eficiência e satifação do clientes dele.

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

v5.5.0

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

3.3.12


text:
# Node.js - Aula 01 - Exercício
**user:** [viniciusmazzeo](https://github.com/viniciusmazzeo)
**autor:** Vinicius Moreira Mazzeo
**date:**

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

Processos síncronos funcionam de forma sincronizada, há uma ordem definida, um processo novo só pode ser executando após o atual ser terminando.
Como exemplo uma fila de banco com apenas um caixa, você tem uma fila de clientes e eles são atendidos apenas um por vez, o próximo cliente só é atendido quando o atendimento do atual cliente terminar.

**síncrono**

```js

function a(){
    console.log("a");
}
function b(){
    console.log("b");
}

a();
b();

```
As funções serão executadas em ordem, primeiro a, depois b.

Já um processo assíncrono não precisa esperar a sua vez para ser executado ele já é executando sem esperar o atual terminar, gerando um ganho de desempenho da aplicação.
Com o mesmo exemplo do banco, um processo assíncrono funciona da seguinte forma, ao chegar no banco as pessoas retiram senhas em um ordem mas como neste banco possui vários caixas apenas podem ser atendidas simultaneamente, ela não precisa esperar o atendimento anterior terminar pois já é possível ser atendida ao mesmo tempo.

**assíncrono**

```js

function a(){
    console.log("Assíncrono aqui");
}
function b(){
    setTimeout(a, 0);
    console.log("b");
}
b();

```
O resultado sera

b
Assíncrono aqui

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

O V8 foi feito em C++ ele é um interpretador de JavaScript, com o V8 podemos executar o JavaScript no servidor.
Ele recebe o código JavaScript, compila esse código para um código nativo de máquina assim podendo executá-lo.
Fazendo uma comparação o V8 seria como um Vitual Machine do Java, graças a ele conseguimos executar nosso script feito em JS no servidor.

![nodev8](img/nodev8.jpg)

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

Single thread ele gera apenas uma processo gerenciando este únicos processo, com isso gera uma economia de processamento de memória, os sistemas multi-thred gera uma nova thered para casa processo, para cada requisição, com isso acaba gerando um consumo de memória e processamento maior.

## 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 5 requisições, a quinta fica aguardando o término de uma das requisições para assim entrar na thread pool.

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

Mostraria que os custos seriam reduzido, pois o node é assíncrono com isso reduziria o consumo de memória e processamento automaticamente reduzindo custos.
Mostraria a melhora de desempenho que o Node poderia trazer.
Por possuir muitas bibliotecas opensource e a cada dia surge uma nova, assim reduzindo custos com softwares de terceiros.
A aplicação seria desenvolvida em JavaScript uma linguagem difundida no mercado.

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

```js

~$ node -v
v6.2.2

```

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

```js

~$ npm -v
3.9.5

```


text:
# Node.js - Aula 01 - Exercício
**user:** https://github.com/VagnerSilva
**autor:** Vagner Pereira Silva
**date:** 26/03/2016

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

Assíncrono: Independe do término de execução de alguma atividade. São funções executadas de forma tardia, cujo chamamos de callback.
No nodejs quase todas as funções são assíncronas.

	```js
    fs.readFile('./Index.html', function read(err, data) {
    console.log(data)
    }

```

Síncrono: seu processamento e realizado de forma sequencial, ou seja, o início de uma tarefa depende do termino da outra.
No nodejs as funções síncronas utilização o "prefixo" sync
  ex:.

```js
    var data = fs.readFileSync(filename, "utf8");
    console.log(data);
```

## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
  ![V8](https://pbs.twimg.com/media/Bt5ywJrIEAAKJQt.jpg)

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

No multi-theard temos um thread para cada requisição, no single, como o nome mesmo sugere temos apenas uma thread, tratando as requisições.
![thread](https://sathyalog.files.wordpress.com/2014/05/toptal-blog-1_b.png)

## 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, mas pode ser configurada para até 128 threads.
No caso de os valores de requisição ser maior, as requisições excedentes ficam na fila aguardando as demais serem executadas.

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

Fazendo um exemplo básico e mostrando suas vantagens.

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

C:\>node -v
v5.7.1

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

C:\>npm -v
3.6.0


text:
#NodeJS - Aula 01 - Exercícios
autor: Dariano Soares

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

Um procedimento **Sícrono** é aquele em que uma operação ocorre após o término de outra.
```js
console.log('1');

correr();

console.log('3');

function carrer(){
	console.log('2');
}
```

Um procedimento **assíncrono** não bloqueia a execução do código. Se um procedimento leva certo tempo para ser encerrado, a linha após esse procedimento será executada antes dele terminar.
```js
console.log('1');

correr();

console.log('3');

function correr(){
	setTimeout(function(){
		console.log('2');
	}, 10);
}
```

Referência -> Livro Construindo Aplicações com NodeJS, William Bruno Moraes.

##2. Como o v8 executa JavaScript? Demostre 1 exemplo com código ou imagem.
![Node.js Architecture](http://image.slidesharecdn.com/15fuv8js7ulf1nzuakfe-140628073041-phpapp01/95/nodejs-enterprise-middleware-25-638.jpg?cb=1403940779)

##3. Qual a diferença entre um sitema `single` para um `multi-thread`?
Em **Single Thread** cada aplicação terá instância de um unico processo. Uma tarefa será executa enquanto a outra fica aguardando o termino da primeira para ser executada na seguência.

Em **Multi Thread** uma aplicação pode ter varias tarefas sendo executada em paralelo usando mais de um processo do sistema.

##4. Como a `Thread Pool` tem um tamanho `padrão de 4`, o que acontece se você `enviar 5 requisições` ao banco?
A 5 requisição fica na Idle Thread esperando a finalização de uma das 4 requisições para ser redirecionada a Thread Pool.

##5. Como você `venderia o peixe do Node.js` na sua empresa para tentar convencer seu chefe da sua adoção?
> * Grandes empresas já adotaram o NodeJs em seus projetos. Empresas como Walmart, Linkdin, Pay Pal, Uber estão usando o NodeJs.
> * Existe uma comunidade participativa.
> * Existem muitos modulos prontos que facilitam o desenvolvimento podendo aumentar a produtividade.
> * O Nodejs utiliza o Google V8 JavaScript Engine e você desenvolve usando javascript, com isso é possível ter uma única linguagem em todo o sistema tanto no front-end, back-end e no banco de dados.
> * O Nodejs é open source e multiplataforma.
> * Permite uma maneira simples de desenvolver programas de rede que precisem escalar.

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

v5.1.0

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

3.3.12


text:
# Node.js - Aula 01 - Exercício
autor: Angelo Rogério Rubin

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

Por exemplo, se você quiser ler um arquivo no node você pode fazê-lo de forma assíncrona:

var fs = require('fs');
fs.readFile('/path', function(err, buf) {
  console.log(buf.toString());
});

O node continuará a executar qualquer código javascript que encontre durante a leitura do arquivo. Uma vez que todo o javascript foi executado e o arquivo foi lido, ele executará a função anônima e imprimirá o conteúdo do arquivo.

Você pode fazer a mesma tarefa de forma síncrona:

var fs = require('fs');
var contents = fs.readFileSync('/path').toString();
console.log(contents);

No código acima o conteúdo será definido para a variável contents e nenhum código javascript será executado enquanto o arquivo está sendo lido.

A primeira abordagem é feita de forma assíncrona e voltará imediatamente para não bloquear o código executado.

A segunda é feita de forma síncrona e irá parar a execução do código até que a tarefa seja concluída.

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

O trabalho da engine (motor) V8 do google é compilar o javascript para código nativo da maquina, para depois executá-lo.

![alt text](img/v8.jpg)

## 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, no caso da linha de execução ao nível do núcleo (em inglês: Kernel-Level Thread (KLT)), ou implementada através de uma biblioteca de uma determinada linguagem, no caso de uma User-Level Thread (ULT).

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, ele é 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.

Segundo a documentação  da [libuv](http://docs.libuv.org/en/v1.x/threadpool.html) o tamanho padrão da thread pool é 4, mas pode ser alterado em tempo de inicialização, definindo a variável de ambiente UV_THREADPOOL_SIZE para qualquer valor (o máximo absoluto é de 128).

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

Citando os pontos fortes do node:

+ Permite criar aplicações de rede rápidas e escaláveis;
+ Utiliza o modelo de I/O não bloqueante e baseado em eventos;
+ As aplicações Node.js executam em uma única thread;
+ Assíncronicidade;
+ Você pode trabalhar com a mesma linguagem (javascript) no Front, Back-End e Base de Dados.

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

PS C:\Projetos\be-mean-instagram-nodejs-exercises> node --version
v0.12.4

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

PS C:\Projetos\be-mean-instagram-nodejs-exercises> npm --version
2.10.1


text:
## Class 01 - Estevan Jantsk

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

```javascript
var filesystem = require("fs");

filesystem.readFile("arquivoex.txt", "utf8", function(error, data) {
  console.log(data);
});
```
No exemplo acima, a função readFile recebe como parâmetro o nome do arquivo que será lido  e como callback uma função. Sendo executada de forma assíncrona outras leituras de arquivos poderiam ser executadas ao mesmo tempo. Sempre que a leitura do arquivo termina, a função de callback irá printar o seu conteúdo no log. Por ser async, o desempenho da aplicação não irá prejudicar no sistema.
##### Sync

```javascript
var filesystem  = require("fs");
var data = filesystem.readFileSync("arquivoex.txt", "utf8");

console.log(data);
```
Já neste outro exemplo, a função readFileSync irá receber como parâmetro o nome do arquivo que seá lido, porém como ela é executada de forma síncrona os códigos abaixo dela não serão executados enquanto ela não terminar de ler o arquivo, isso é extremamente ruim, pois não irá possibitar outras tarefas serem executadas enquanto essa outra não terminar.
2. Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.

javascript code -> Chrome V8 Engine -> Native Machine Code

O V8 compila código feito em JS para código nativo de máquina antes de executá-lo.

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

Depende, no caso do Node, ele é single thread no entanto ele conta com o event loop que faz todo o gerenciamento de recebimento de operações, cadastramentos de callbacks e quando a operação estiver completa disparar o callback para quem fez a requisição. Já para um sistema multi thread, cada operação vira uma thread e cada thread tem um custo de memória que pode impactar no funcionamento e disponibilidade do seu sistema.

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

Se todas as threads estiverem ocupadas os próximos requests começarão a serem enfileirados e executados de acordo com a disponibilidade.

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

Com certeza iria mostrar o case de sucesso do Paypal que mostra como eles ganharam demais ao migrado do java para node.js.

Pontos interessantes: redução de código (linhas escritas), redução na quantidade de arquivos (comparado aos XML's da vida do Java), velocidade no desenvolvimento e também a redução na quantidade de pessoas que precisaria para realizar um projeto. E principalmente por ser TUDO JAVASCRIPT s2.
6. Qual a versão do seu 'node'?
```sh
node -v
v4.4.4
```
7. Qual a versão do seu 'npm'?
```sh
npm -v
2.15.1
```


text:
# Node.js - Aula 01 - Exercício
**user:** [mauriciord](https://github.com/mauriciord)
**autor:** Maurício Reatto Duarte
**date:** 15/07/2016

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

Em termos simples, programação **síncrona** é fazer uma coisa a seguir à outra, sendo de execução sequencial e linear. Quando há comandos a serem executados, são efetuados somente após o término do comando anterior.

### Exemplo de processo síncrono com nodeJS

```js
var fs = require('fs');
var arquivo = "./index.html";
var rdf = fs.readFileSync(arquivo, "utf8");

res.writeHead(200, {"Content-type":"text/html"});
res.write(rdf);
res.end();
```

*Você pode observar que o javascript aguardou o leitura do arquivo*

Já a programação **assíncrona**, é quando a rotina acaba sendo não bloqueante, ou seja, no caso do nodeJS, é enviada ao _Event Loop_ e o resto dos comandos continuam a executar normalmente.

### Exemplo de processo assíncrono com nodeJS

```js
var fs = require('fs');
var arquivo = "arquivo.txt";
fs.readFile(arquivo, function(err, data){
	if(err) return console.error(err);
	console.log(data.toString());
});
console.log('Vamos ver qual aparece antes');
```

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

![javascript V8 engine](https://pbs.twimg.com/media/Bt5ywJrIEAAKJQt.jpg)

## Qual a diferença entre um sistema single para um multi-thread?
Sistema single-thread, conforme o nome sugere, temos apenas uma thread tratando as requisições com um único processamento(isso evita gasto de processamento), porém elas são tratadas no _Event Loop_.
Já no caso da Multi-thread, para cada processamento no servidor, é gerado uma thread, tendo assim um gasto maior de processamento.

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

Será executada apenas quando uma das quatro terminar, liberando espaço para essa nova requisição. O limite padrão é 4, porém com expansão até 128 requisições.

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

Primeiramente, eu explicaria para ele sobre o menor gasto de processamento, por ser S.T. e que isso poderia reduzir gastos com servidores. Depois para reforçar, iria demonstrar os casos de uso das famosas e medias empresas que usaram Node.js e que obtiveram resultados satisfatórios.

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

v6.3.0

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

3.10.3


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

**autor:** Paulo Roberto

**date:** 1452734591897

## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Síncrono: Supondo que uma pessoa fez uma requisição via htttp, em um processo sícrono o Node teria que esperar essa
requisão ser completada para ai sim atender outras requisições.

Assíncrono: É o oposto do síncrono, pegando o mesmo exemplo da requisão http, nesse caso o Node pode atender outras
requisições, mesmo que uma não esteja completa. Ele iria atender as requisições e devolver as respostas de acordo com que
ficassem prontas tudo isso assíncronicamente.

## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
!['Explicação V8 Javascript'](http://blog.gopivotal.com/wp-content/uploads/2012/04/NodeJS-EventedIOAsyncIO_latest.png "Optional title")
Como você pode ver o motor V8 é responsável pela parte de Event Loop, que é responsável por redirecionar todas as requisições e respostas
pro seus devidos lugares, de forma assíncrona, sendo assim simultaneamente uma requisição não precisa esperar outra ser completada
até ser levada a seu devido lugar ou receber sua resposta.

## Qual a diferença entre um sistema single para um multi-thread?
Single: Coloca todas requisições em uma única thread, diminuindo gastos de processamento.

Multi: Gera uma thread para cada requisição no servidor, tendo assim uma maior gasto de processamento.

## 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, quando 1 das 4 forem executadas. Liberando espaço para próxima.

Lembrando que o limite é 4 por default, porém pode ser expandido até 128 requisições.

## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Simplesmente mostrando dados de empresas que migraram de outras técnologias para o nodeJS, o ganho de perfomace que eles
obtiveram e também a diminuição de tempo gasto em produção.

## Qual a versão do seu `node`?
```
paulo@Paulo:~/Documentos/testando$ node -v
v5.4.1
```
## Qual a versão do seu `npm`?
```shell
paulo@Paulo:~/Documentos/testando$ npm -v
3.3.12
```


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

**user:** https://github.com/rafael-pessoni
**autor:** Rafael Bertanha Pessoni

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

#### Processos Síncronos:

Os síncronos bloqueiam a Thread de execução do node, fazendo com que o node consiga responder somente 1 Request por vez.

Um ótimo exemplo para isso é o atendimento de um restaurante, no modelo síncrono, o garçom pegaria o pedido do cliente na mesa, passaria este pedido para a cozinha, e esperaria a finalização deste pedido para ir atender a segunda mesa.

#### Processos Assíncronos:

Os processos assíncronos não bloqueiam a Thread de execução do node, permitindo assim que ele trabalhe na resposta de mais de um Request simultaneamente. A maior vantagem deste modelo está em situações onde, dentro da resposta do Request existe um grande processamento de I/O por exemplo, esse processamento é feito por componentes externos ao node, então, ele não precisa esperar esse processamento terminar para começar a trabalhar em outro Request.

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.

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

![](https://raw.githubusercontent.com/Rafael-Pessoni/Learn/master/be-mean/nodejs/images/event-loop.jpg)

Sempre que algo acontece no node um evento é disparado, esse evento então entra no final da fila de eventos(Event Queue), o Event Loop pega o primeiro item da fila e o direciona aos componentes da thread pool, e é nesse momento que a principal característica do node entra em ação, ele não espera até que o elemento da thread pull termine seu processamento, ele continua se trabalho pegando o próximo elemento da fila, quando o elemento da Thread Pool termina o processamento, um novo evento entra na Event Queue, esse evento é chamado de callback

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

Um bom exemplo para isso seria o funcionamento de um posto de combustível, imagine um posto de combustível com uma única bomba, todos os carro teriam que se enfileirar para serem atendidos, este é o funcionamento de um sistema sigle-thread, já no multi-thread, vários clientes podem ser atendidos de uma única vez, como em um posto convencional, neste exemplo cada bomba de combustível representa um processador, ou core de processador.
O node é single thread, mas como é assíncrono também, ele consegue atender a varias requisições ao mesmo tempo, o problema está em quando ele é forçado a fazer algo síncrono, toda essa velociada é jogada fora.

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

Elas são enfileiradas para serem atendidas assim que uma for resolvida, mas este tamanho pode ser configurado

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

Mostrando os grandes casos de sucesso, e também, a sua superioridade diante de alguns cenários

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

    [rafael.pessoni@localhost nodejs]$ node --version
    v0.10.41

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

    [rafael.pessoni@localhost nodejs]$ npm --version
    3.6.0


text:
# Node.js - Aula 01 - Exercício
**Autor:** Eric Lessa

**User:** [falconeric](https://github.com/falconeric)

**Data:** 1465880788

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

Processos síncronos são processos bloqueantes, só permitirão que outros processos sejam executados após que este tenha terminado. Na documentação do Node.JS temos um exemplo de processo assíncro, veja:

```
const fs = require('fs');

fs.unlinkSync('/tmp/hello');
console.log('successfully deleted /tmp/hello');
```
neste exemplo o log só será exibido quando **fs.unlinkSync** terminar de executar.

Processos assíncronos em Node.JS não esperam que um processo seja concluido para iniciar outro, quando um processo é concluido é emitido um evento informando o resultado, chamamos esse evento de callback. Veja o exemplo de um processo assíncrono:

```
const fs = require('fs');

fs.unlink('/tmp/hello', (err) => {
  if (err) throw err;
  console.log('successfully deleted /tmp/hello');
});
```
o exemplo acima retirado da documentação do Node.JS apresenta uma forma melhorada da versão síncrona, desta vez é passado um callback para o método **fs.unlink** que informa o resultado da operação.

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

Em termos simples, o v8 pega o código-fonte, divide em strings, converte em bytecode que um compilador pode entender, e então executa.

V8 compila código javascript diretamente em código máquina quando executado pela primeira vez. Sem bytecodes intermediários, sem interpretador. O acesso as propriedades é tratado pelo código em cache que pode ser corrigido com outras instruções de máquina enquanto V8 é executado.

Durante a execução inicial do código para acessar uma propriedade de um determinado objeto, V8 define o objeto atual uma classe escondida. V8 otimiza o acesso à propriedade, prevendo que esse objeto também será usado por todos os objetos futuros acessados na mesma seção do código e use as informações na classe para corrigir o código em cache para usar a classe escondida. Se V8 previu corretamente o valor da propriedade é atribuído (ou forçado) em uma única operação. Se a previsão estiver incorreta, V8 corrige o código para remover a otimização.

Por exemplo, o código JavaScript para acessar a propriedade *x* de um objeto *Point* é:
```
point.x
```

Em V8, o código de máquina gerado para acessar *x* é:
```
# ebx = the point object
cmp [ebx,<hidden class offset>],<cached hidden class>
jne <inline cache miss>
mov eax,[ebx, <cached x offset>]
```

Se o objeto classe escondido não corresponde à classe escondida em cache, a execução salta para o sistema de execução V8 que lida com erros de cache e corrige o código em cache embutido. Se houver uma correspondência, o que é o caso comum, o valor da propriedade x é simplesmente recuperado.

**referência:** [Chrome V8](https://developers.google.com/v8/design#dynamic-machine-code-generation)

## Qual a diferença entre um sistema single para um multi-thread?
Em sistemas single-thread quando executamos um programa temos um fluxo único(thread) de controle sequencial.

![Image of single-thread](http://www.dsc.ufcg.edu.br/~jacques/cursos/map/html/threads/threads-single.gif)

Em sistemas multi-thread podemos ter multiplas threads sendo processadas ao mesmo tempo

![Image of single-thread](http://www.dsc.ufcg.edu.br/~jacques/cursos/map/html/threads/threads-two.gif)

>Thread é uma forma de um processo dividir a si mesmo em duas ou mais tarefas que podem ser executadas concorrencialmente.

## 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 ter que aguardar uma das outras quatro requisições terminar. Isso não significa que o event-loop será bloqueado ele continua atendendo novas requisições maaaas elas terão que aguardar.

## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Falaria das vantagens do Node.js em relação a tecnologia utilizada pela nossa empresa e que os custos da operação para migrar de tecnologia se refletiriam em economia de gastos no futuro, falaria da baixa curva de aprendizado e alta disponibilidade de profissionais javascript citaria cases de sucesso de grandes empresas que migraram para o Node.js.

## Qual a versão do seu `node`?\
v4.4.4
## Qual a versão do seu `npm`?
2.15.1


text:
# Node.js - Aula 01 - Exercício
autor: Igor Vidotto Felipe

#### 1 - Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
###### Processo Síncrono
Os processos síncronos invocam chamadas de I/O bloqueante, isso significa que para cada operação de I/O o sistema ficará bloqueado executando este processo e não poderá executar outro até que este termine.

Um exemplo seria um forno pequeno, no qual poderíamos cozinhar apenas uma coisa por vez.

###### Processos Assíncronos
Os processos assíncronos invocam chamadas de I/O "não-bloqueantes", ou seja, enquanto este processo está executando o sistema não vai ter que esperar ele terminar para que possa iniciar o processamento de outro. No entanto essa abordagem não nos permite saber quando esse processo irá finalizar sua execução, por isso devemos usar funções de *callback*, que serão invocadas quando este processo efetivamente for finalizado.

Em contraste com o exemplo do processo síncrono, podemos citar aqui um forno maior, o que nos permitiria cozinhar várias coisas de uma só vez, todavia teríamos que colocar um dispositivo para informar quando cada prato ficasse pronto (*callback*).

#### 2 - Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O V8 compila e executa o código fonte JavaScript, manipula alocação de memória para objetos, e faz uma limpeza na memória de objetos que não são mais necessários.

O JavaScript é mais comumente utilizado para script *client-side* num navegador, sendo usado para manipular os objetos do *Document Object Model (DOM)*, por exemplo. O DOM, no entanto não é fornecido pelo motor do JavaScript, mas sim por um navegador. O mesmo acontece com o V8 - O Google Chrome que fornece o DOM. Porém o V8 fornece todos os tipos de dados, operadores, objetos e funções especificados no padrão ECMA.

O V8 ainda permite que qualquer aplicação `C++` exiba seus próprios objetos e funções para o código JavaScript.

Podemos encontrar exemplos de como o V8 trabalha com JavaScript no site [Google Developers](https://developers.google.com/v8/). Eis um [código](http://v8-io12.appspot.com/#30) utilizado no evento Google I/O "Breaking the JavaScript Speed Limit with V8" para exemplificar as atuações desse motor.

#### 3 - Qual a diferença entre um sistema single para um multi-thread?
Um sistema **single-thread** pode ter a instância de um único processo por vez ao passo que o **multi-thread** pode conter vários processos com seus subcomponentes ou threads em paralelo, sendo que quando uma thread está fazendo uma operação de I/O as tarefas restantes podem fazer uso da CPU.

A princípio isso pode parecer uma grande desvantagem para o Node.js, porém um sistema multi-thread corre o risco de sofrer um [*deadlock*](http://www.devmedia.com.br/introducao-ao-deadlock/24794), algo que uma aplicação em Node.js não precisa se preocupar, e ainda mais, há a possibilidade de implementar a programação concorrente no Node.js por meio do [*cluster*](https://nodejs.org/dist/latest-v5.x/docs/api/cluster.html), que é um módulo nativo dele.

#### 4 - Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
As 4 threads dessa *Thread Pool* tratarão do processamento de 4 requisições. Pelo fato dessas requisições serem **I/O bloqueante** (síncronas) a requisição que não foi atribuída à uma thread terá que esperar a liberação de alguma das 4 para que somente então possa ser processada.

#### 5 - Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Primeiro eu mostraria as vantagens que existem no modelo *Single-Threaded* com *Event-Loop* do Node.js em relação ao *Multi-Threaded* de outras plataformas, baseando-se na forma em que servidor responde às requisições dos *clients*, evitando gargalos comuns que existem em outras plataformas, como consumo excessivo de memória e risco do sistema sofrer um *deadlock*. Mostrando ainda que também é possível trabalhar de forma concorrente com o módulo *cluster* nativo do Node.js.

Numa arquitetura comum, ficaria muito custoso montar um servidor para suportar várias requisições simultâneas, todavia o Node.js faz o uso máximo do poder de processamento de um servidor e utiliza pouca memória, o que quer dizer que o hardware do servidor não precisa ser excelente para suportar um alto número de requisições e proporcionar uma resposta rápida a elas.

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

```
node -v
v5.2.0
```

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

```
npm -v
3.3.12
```


text:
# Node.js - Aula 01 - Exercício
autor: Carlos Alberto de Araujo Barreto

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

Por padrão no node as funções são assíncronas, assim ele trabalha comcall backs pós finalização de processamento dos processos assíncronos.
Abaixo serão listados exemplos dos dois casos.

### Síncrono
A tarefa é executada de maneira que deixa a thread "presa" na sua execução, enquanto não finalizar essa tarefa a thread não é liberada.
Exemplo:
```
var arquivo = require("fs");
// Abaixo a função readFileSync lê completamente o conteúdo do arquivo e então exibe os dados via console
// Como essa função é síncrona o sistema só passa para a próxima linha de código quando terminar de ler completamente o arquivo.
var data = arquivo.readfileSync("exemplo.txt", "utf8");
console.lod(data);

```

### Assíncrono
A tarefa é executada de forma paralela, assim várias tarefas são executadas "simultaneamente". Como o node usa uma Thread somente as tarefas são executadas numa fila
chamada event loop onde cada tarefa é executada em um determinado tempo, não deixando a thread presa a tarefa.
Exemplo: Função Assíncrona de leitura de arquivo
```
var arquivo = require("fs");
// Abaixo o módulo de sistema de arquivos pega o nome do arquivo, os dados de referencia para o callback handler
// da função anonima. Então o objeto do sistema estará apto para processar qualquer outra operação
arquivo.readFile("exemplo.txt", "utf8", function(error, data) // Aqui o módulo de sistema de arquivos
{
  console.log(data);
});
```

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

O V8 compila o código de javascript para código nativo de máquina para depois executá-lo.
![Funcionamento do V8](http://image.slidesharecdn.com/sdp-nodejsfornetdev-150604162643-lva1-app6891/95/nodejs-workshop-sela-sdp-2015-19-638.jpg?cb=1433435429)

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

A thread é responsável por executar tarefas, e uma thread pode apenas executar uma thread por vez(single thread).
No caso da multi-thread existem várias threads capazes de executar várias tarefas 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?

Como a thread pool funciona como uma fila cíclica, a 5 requisição só será executada após uma das 4 threads terminar de executar.

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

Defendendo as características marcantes do node:
1 - Modularização de seus componentes
2 - Usa a javascript engine V8
3 - Possui um tempo de resposta rápido para volume de requisições entrada/saída
4 - Alta escalabilidade
5 - Alto desempenho com requisições assíncronas

## Qual a versão do seu node?
```
root@carlos-VirtualBox:/home/carlos# node -v
v5.2.0
```

## Qual a versão do seu npm?
```
root@carlos-VirtualBox:/home/carlos# npm -v
3.3.12
```


text:
# Node.js - Aula 01 - Exercício
**autor:** Geriel Castro

## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
####Processo Assíncrono
Um processo assíncrono consegue executar tarefas simultâneas. Após o processo finalizar, uma função de _callback_ deverá ser chamada.
Um detalhe importante sobre assincronismo é que, na maioria dos casos, os callbacks possuem como parâmetro uma variável de erro, que serve para impedir a execução dos callbacks subsequentes, caso haja algum problema.
```
function bar(){
    console.log("Default: Hoegaarden");
}
function garcom(){
    setTimeout(bar, 0);
    console.log("Garçom? Me traz uma cerveja por favor!");
    console.log("...");
}
garcom();
```

####Processo Síncrono
Processo executado apenas quando o seu antecessor finalizar. Como uma fila (Primeiro a entrar é o primeiro a sair, depois é chamado o próximo) é basicamente isso.
O primeiro a ser executado precisa finalizar o processo para executar o segundo e assim sucessivamente.
```
function garcom(){
    console.log("Garçom? Me traz uma cerveja por favor!");
}
function bar(){
    console.log("Default: Hoegaarden");
}
garcom();
bar();
```

## 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 seria mostrando as vantagens que traria a empresa ao adota-lo. Mostraria tambem algumas empresas que possivelmente ja estão utilizando e como vem ajudando no desenvolvimento rapido e com menos custo.

## Qual a versão do seu `node`?
```
MacBook-Air-de-Geriel:be-mean-instagram-nodejs-exercises geriel$ node -v
v5.0.0
```

## Qual a versão do seu `npm`?
```
MacBook-Air-de-Geriel:be-mean-instagram-nodejs-exercises geriel$ npm -v
3.3.12
```


text:
# Node.js - Aula 01 - Exercício
**user:** [higordiego](https://github.com/higordiego)
**autor:** Higor Diego Alves Ferreira Pinheiro
**date:** Wed Jan 27 2016 15:00:06 GMT-0300 (BRT)

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

Assíncrono:
	Exemplo:
		Quando um processo não depende do outro para terminar.

		Exemplo: O garçom atende varias mesas sem precisar esperar na cozinha que o pedido seja feito, ele só
		aguarda chamar ou seja (callback).

Síncrono:
	Quando um processo depende do outro para acabar para passar do próximo.
	Exemplo: Fila de pão, o atendente não consegue entregar e atender o cliente para pegar o pão sem que o primeiro cliente
	já tenha sido atendido.

## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
![Imagem V8]
(http://static.17ky.net/Images/20151215/6358579084581674429956854.png)

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

Single Thread: Sistema consegue executar apenas uma thread, assim fica dependendo de um processo terminar para ir para o outro.

Multi-thread: Trabalha com varias threads, caso o sistema trave um processamento ele inicia uma nova assim liberando o uso.

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

Em caso da quinta requisição será incluída uma thread na espera, até vagar uma thread para entrar em execução.

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

	Mostraria o custo da tecnologia e tendências de mercado hoje, com base em perfomance e desempenho.

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

nodejs $ node -v
v5.5.0

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

nodejs $ npm -v
3.3.12


text:
# NodeJS - Aula 01 - Exercício
**Autor:** Fábio Calheiros (conta: fabiocalheiros)
**Data** 1450308789659

# 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. Um sistema de arquitetura síncrono vai enfileirar cadarequisição que são realizadas ao mesmo tempo e depois ele vai processando, uma a uma. Este modelo não permite múltiplos processamentos ao mesmo tempo. Enquanto uma requisição é processada, as demais ficam em espera, ou seja, a aplicação bloqueia os demais processos de fazer I/O no servidor, mantendo-os em um pequeno período de tempo numa fila de requisições ociosas.

Exemplo Síncrono:

var fs = require('fs'),
    filenames,
    i,
    processId;

filenames = fs.readdirSync(".");
for (i = 0; i < filenames.length; i++) {
    console.log(filenames[i]);
}
console.log("Ready.");

processId = process.getuid();

Assíncrono: O Servidor responde a primeira Requisição da fila e aguarda a sua chamada de retorno.
Ao mesmo tempo que atende a outras requisições ele fica atento a chamada de CALLBACK das outras requestes enviadas anteriormente.

Exemplo Assíncrono:

var fs = require('fs'),
    processId;

fs.readdir(".", function (err, filenames) {
    var i;
    for (i = 0; i < filenames.length; i++) {
        console.log(filenames[i]);
    }
    console.log("Ready.");
});

processId = process.getuid();

```

# 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:
https://www.future-processing.pl/wp-content/uploads/2015/04/threads-in-node.ja_.png

```

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

```

Single-threded tem apenas uma thread que está executando todo o código no aplicativo, baseado em uma fila.
Multi-threaded tem mais de uma uma thread em execução ao mesmo tempo e pode ser executado simultaneamente, cada qual com usa fila de execuções.

```

# 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, entrará na fila de execução, aguardando que o alguma requisição seja entregue para que ela entre em execução.
Para alterarmos isso, podemos usar a variavel "UV_THREADPOOL_SIZE" que torna posivel alterar a quantidade de Thread Pools que nossa aplicação vai receber.
Exemplo: UV_THREADPOOL_SIZE = 5

```

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

```

Na verdade já vendi o peixe para o meu chefe.
Em uma conversa outro dia, expliquei a ele as novas tendências de como o node funciona.
Toquei em diversos assuntos como:
- o tempo de resposta é muito menor do que um site feito em php.
- A conversão de mídias, como mobile, desktop e web, por se tratar de código javascript é relativamente facil
- Mencionei um problema que tivemos recentemente com uploads de vídeos, onde o node possui recursos que não so possibilita isso, como também não salva o arquivo no servidor e sim em um banco de dados.
- Mencionei que ferramentas como o paypal, popkorn time, spotify, netiflix, todas elas utilizam nodejs.
- Expliquei também como o node é eficiente quando se trata de escabilidade, ou seja a medida de que a aplicação cresça é possivel como o mongoDb por exemplo dividir essas informações em variados servidores.

```

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

```
fabio@fabio-Inspiron-7520:~$ node -v
v5.2.0

```

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

```

fabio@fabio-Inspiron-7520:~$ npm -v
3.3.12

```


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

##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.

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

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

**Single-thread** Apenas uma tarefa pode ser feito em um tempo e o programa espera até que uma tarefa é concluída antes de iniciar outra.

**Multi-thread** Aplicações multi-thread permitem que você execute várias threads ao mesmo tempo, cada uma executando uma etapa por exemplo.

##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 vai para o Idle Thread, e espera até ser colocada no thread pool. Digamos que a primeira requisição foi executada, então a quinta requisição poderá ir para o thread pool.

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

Sei do que estou falando. Faz com Node!

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

v6.3.1

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

3.3.12


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

autor: Bruno Lima da Silva

## 1. Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Quando um processo chega no Event Loop e é assíncrono, o mesmo é enviado para onde deve ser executado, por exemplo, uma requisição de leitura de arquivos no computador, e enquanto o sistema operacional trata essa requisição o Node.JS continua executando outros processos e tarefas. Quando a requisição termina é disparado uma trigger para o callback do processo assíncrono, e então esse processo retorna para a fila para ser executado no Event Loop. Ou seja, basicamente diz que qualquer leitura ou escrita de dados não espera seu processo finalizar para continuar o script, nesse caso os processos ocorrem paralelamente à execução.
Quando um processo chega no Event Loop e é síncrono, o mesmo é enviado para onde deve ser executado, por exemplo, uma requisição de leitura de arquivos no computador, porém, enquanto o sistema operacional trata essa requisição o Node.JS tem que aguardar o retorno sem executar outros processos ou tarefas, deixando a aplicação mais lenta e consumindo mais recursos do servidor/computador. Só após acontecer o retorno da requisição de leitura de arquivos o Node.JS executa o processo sínocrono e demais tarefas e processos que ele receba.

## 2. Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O Moto V8 é um interpretador de JavaScript desenvolvido pelo Google e o trabalho dele é basicamnete compilar o código de JavaScript para o código nativo de máquina para depois executá-lo. Com isso ele levou a velocidade dos códigos compilados para o JavaScript.

## 3. Qual a diferença entre um sistema single para um multi-thread?
Em um sistema multi-thread, como por exemplo o Apache, você tem um processo novo para cada usuário conectado ou um procesos novo para cada requisição feita.
Em um sistema single-thread você possui apenas uma thread.

## 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 é pré-processada no Event Loop e quando as quatro primeiras requisição são retornadas pelo banco de dados a quinta requisição é enviada ao banco e quando for finalizada retornará para o Event Loop.

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

## 6. Qual a versão do seu `node`?
node -v
v6.9.1

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


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

**autor:** Davidson da Silva Nascimento

**date:** 1453972359356

## 1. Explique como um processo síncrono e assíncrono roda no Nodejs, dê um exemplo para cada.
#### Síncrono
Uma operação ocorre após o término de outra, de forma **ordenada**. O processo é interrompido até que o procedimento em andamento seja finalizado.

> Cada passo é realizado após o término do passo anterior, ou seja, nenhuma operação é executada antes que a operação anterior seja finalizada

No exemplo abaixo é realizado o download de todas as imagens da API [HTTP Status Cats](https://http.cat/), onde é demonstrado através do tempo gasto como as requisições com processos síncronos podem vir a ser muito mais demorados.

Isso ocorre devido o fato de que cada imagem é "baixada", uma após a outra, e também neste caso se ocorrer algum tipo de problema é impossibilida a continuidade dos downloads.

```js
console.time('tempo gasto');

var fs = require('fs');
var request = require('request');

var URL = "https://http.cat/";

var statusCodes = [
  100, 101, 200, 201, 202, 204, 206, 207, 300, 301,
  302, 303, 304, 305, 307, 400, 401, 402, 403, 404,
  405, 406, 408, 409, 410, 411, 412, 413, 414, 415,
  416, 417, 418, 422, 423, 424, 425, 426, 429, 431,
  444, 450, 451, 500, 502, 503, 506, 507, 508, 509,
  599
]

function salvarImagem(error, response, body) {
  if (response.error) {
    console.log('Error: '+response.error);
  }
  if (!error && response.statusCode == 200) {

    fs.writeFileSync(response.request.href.slice(URL.length) + ".jpg", body);
    console.log("CAT Error: " + this.statusCodes[this.indice] + " SALVO");

    if ((this.indice + 1) < statusCodes.length) {
      var requisicao = {statusCodes: this.statusCodes, indice: this.indice + 1};
      request({uri: URL + this.statusCodes[requisicao.indice], encoding:null}, salvarImagem.bind(requisicao));
    }
  }
}

var requisicao = {statusCodes: statusCodes, indice: 0};
request({uri: URL + statusCodes[0], encoding:null}, salvarImagem.bind(requisicao));

process.on('exit', function () {
  console.timeEnd('tempo gasto');
});
```

#### Assíncrono
Não existe sincronismo, ou seja, podem ser realizados diversos procedimentos em paralelo. Cada resposta é retornada quando tiver sido concluído cada procedimento.

> Cada processo é tratado via [callback](http://www.tutorialspoint.com/nodejs/nodejs_callbacks_concept.htm), via tratamento de evento

O exemplo apresentado abaixo possui a mesma idéia que o anterior, porém implementado de forma assíncrona. Através dos registros do *LOG* pode ser visto que os downloads são realizados de forma não ordenada, ou seja, todas as imagens são disparadas e a medida que cada uma é finalizada **individualmente** é exibido apenas a mensagem de salvo.

```js
console.time('tempo gasto');

var fs = require('fs');
var request = require('request');

var URL = "https://http.cat/";

var statusCodes = [
  100, 101, 200, 201, 202, 204, 206, 207, 300, 301,
  302, 303, 304, 305, 307, 400, 401, 402, 403, 404,
  405, 406, 408, 409, 410, 411, 412, 413, 414, 415,
  416, 417, 418, 422, 423, 424, 425, 426, 429, 431,
  444, 450, 451, 500, 502, 503, 506, 507, 508, 509,
  599
]

function salvarImagem(error, response, body) {
  if (response.error) {
    console.log('Error: '+response.error);
  }
  if (!error && response.statusCode == 200) {
    nome_arq = response.request.href.slice(URL.length);
    fs.writeFile(nome_arq + ".jpg", body, function (err) {
      if (err) throw err;
      console.log("CAT Error: " + nome_arq + " SALVO");
    });
  }
}

for (var i=0; i < statusCodes.length; i++) {
  request({uri: URL + statusCodes[i], encoding: null}, salvarImagem);
}

process.on('exit', function () {
  console.timeEnd('tempo gasto');
});
```

> **Comparar** evento síncrono e assíncrono é **completamente desleal**, a diferença de tempo gasto é surreal entre os dois pra executar a mesma atividade. Porém cada aplicação possui sua **particularidade** e deve ser implementado o que lhe melhor atender

Foram utilizados alguns recursos do JS e do Node.js que são novos para mim, e pode ser para você também hihi, os links para melhor entendimento podem se encontrados clicando [AQUI](#referências).

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

A maioria dos motores de JavaScript usam uma estrutura de dados como dicionários, para o armazenamento para propriedades de objeto, ou seja, cada acesso a uma propriedade requer uma pesquisa dinâmica para resolver o estabelecimento na memória. Essa abordagem se faz acessando propriedades em JavaScript tipicamente muito mais lento do que acessar variáveis de instância em linguagens de programação como Java e Smalltalk. Nestas linguagens, variáveis de instância estão localizados em deslocamentos fixos determinados pelo compilador devido ao layout do objeto fixo definido pela classe do objeto. O acesso é simplesmente uma questão de uma carga de memória, muitas vezes necessitando de apenas uma única instrução.

Para reduzir o tempo necessário para acessar as propriedades de JavaScript, o V8 não usa pesquisa dinâmica para propriedades de acesso. Em vez disso, o V8 cria dinamicamente classes ocultas.

O V8 cria as classes ocultas em tempo de execução, a fim de ter uma representação interna do sistema de tipo e para melhorar o tempo de acesso da propriedade. E um objeto muda de classe oculta quando uma nova propriedade é adicionado.

Veja, por exemplo, uma função "Point" e a criação de dois objetos "point":

```js
function Point(x, y) {
  this.x = x;
  this.y = y;
}

var p = new Point(11, 22);
var q = new Point(33, 44);
```

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

Se o esquema são os mesmos, o que é o caso aqui, "p" e "q" pertencem à mesma classe oculta criada pelo V8.

Agora vamos supor que nós queremos adicionar uma propriedade "z" ao nosso objeto "q", logo após a sua declaração (o que é perfeitamente bem com uma linguagem de tipagem dinâmica).

Como V8 vai lidar com este cenário? Na verdade, V8 cria uma nova classe oculta toda vez que a função de construtor declara uma propriedade e mantém o controle do changement na classe oculta. Por quê? Porque se dois objetos são criados ("p" e "q") e se um membro é adicionado ao segundo objeto ("q") após a criação, V8 precisa manter a última classe oculta criado (para o primeiro objeto "p ") e criar um novo (para o segundo objeto" q ") com o novo membro.

Pode parecer ineficiente criar uma nova classe oculta sempre que uma propriedade é adicionada. No entanto, devido às transições das classes, as classes ocultas podem ser reutilizados. Toda vez que uma nova classe oculta é criada, a anterior é atualizado com uma transição de classe indicando que classe oculta tem de ser usado em vez disso.

Veja exemplo abaixo:

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

Apesar do JavaScript ser mais dinâmico do que a maioria das linguagens orientadas a objeto, o comportamento de tempo de execução da maioria dos programas de JavaScript resulta em um alto grau de compartilhamento de estrutura utilizando a abordagem acima. Há duas vantagens para o uso de classes ocultas: acesso a propriedade não requer uma consulta do dicionário, e eles permitem o V8 usar a otimização baseada em classe clássico, inline caching.

## 3. 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 ([Wikipédia](https://goo.gl/aRBe6y))

##### Single-thread
O conceito de Single-thread(Thread única) é o processamento de um comando por vez, ou seja,  inicia na etapa 1 e continua sequencialmente (etapa 2, etapa 3, o passo 4) até atingir a etapa final.

Um exemplo poderia ser um servidor web servindo apenas um pedido de cliente de cada vez. O que pode tornar o período de espera de outros clientes ser muito longo.

##### Multi-thread
Permitem que você execute várias threads ao mesmo tempo, cada uma executando um passo por exemplo.

Nesta situação, um servidor web pode criar multíplas threads para atender a diversos clientes. O que aumenta a capacidade de resposta à solicitações de clientes.

## 4. Como a Thread Poll tem um tamanho padrão de 4, o que acontece se enviar 5 requisiçoes ao banco?
A última requisição aguarda na Task Queue(pilha de tarefas) até que alguma tarefa seja completada e sair da Thread Pool. Para assim tomar seu lugar e entrar na Thread Pool.

![Thread Pool](https://upload.wikimedia.org/wikipedia/commons/0/0c/Thread_pool.svg)

## 5. Como você venderia o peixe do Nodejs na sua empresa para tentar convencer seu chefe da sua adoção?
Man, é JavaScript no servidor, só isso já é maravilhoso. Não teremos que aprender nenhuma nova linguagem que o Google ou Facebook nem muito menos a Apple criou. É JavaScript, essa linguagem que é o Café com Leite para todos (pelo menos eu acho) os desenvolvedores Web. A comunidade é gigantescamente gigantesca.

A quantidade de módulos é enorme, o que nos possibilita trabalhar com infinitos recursos I/O no servidor. Com isso podemos, com uma grande facilidade,  trabalhas com protocolos como o HTTP, HTTPS, DNS, WebSockets sem nenhum problema e com poucas linhas de código. Além de manipulação de arquivo, criptografia, ou onde sua mente te levar.

A manipulação do JSON é mamata já que utilizaremos o JavaScript.

Alta escalabilidade já que possui uma característica marcante de Threads Não-Bloqueantes. Algo que não somos muito acostumados já que utilizamos .NET, JAVA e PHP.

Pra finalizar e não ter discurssão, nada mais nada menos do que LinkedIn, Wallmart, Groupon, Paypal, Netflix e até mesmo a Microsoft o utiliza.

Então o que me diz? Vamos viver de presente? De algo que de fato esta agitando a comunidade?

## 6. Qual a versão do seu `node`?
```js
davidson@davidson ~ $ node -v
v5.4.0
```
## 7. Qual a versão do seu `npm`?
```js
davidson@davidson ~ $ npm -v
3.3.12
```

## Referências
[Console module Node.js](https://nodejs.org/api/console.html)

[bind() function JS](https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Function/bind)

[Node.js: síncrono versus assíncrono](https://www.youtube.com/watch?v=-43EEc3C3cA)

[V8 - Design Elements](https://github.com/v8/v8/wiki/Design%20Elements)

[How the V8 engine works?](http://thibaultlaurens.github.io/javascript/2013/04/29/how-the-v8-engine-works/)


text:
# Node.js - Aula 01 - Exercício
**user:** [matheusjkweber](http://github.com/matheusjkweber)
**autor:** Matheus Jose Krumenauer Weber
**date:** 1456355702659

## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
```
No Node.js um processo síncrono funciona seguindo uma série de tarefas síncronas, realiza uma e depois vai para outra e depois para outra numa ordem pré determinada, como no exemplo do garçom do vídeo onde o mesmo atende um cliente e só vai atender o segundo quando todas as tarefas do primeiro tiver terminada.

Em um processo assíncrono, o mesmo realizará uma série de tarefas conforme as respostas do servidor, no exemplo do garçom ele irá atender o primeiro cliente e já irá atender o segundo cliente, mesmo que as tarefas do primeiro não tiverem sido terminadas, e quando a cozinha enviar uma mensagem para o garçom o mesmo voltará para o primeiro cliente para terminar as tarefas com ele(isso se a cozinha não mandar terminar as tarefas do segundo primeiro).```
```

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

O V8 compila e executa o código Javascript já fazendo uma limpeza na memória de objetos não mais necessários.

<img src="http://image.slidesharecdn.com/nodesecuritypresentationv3asfws-121126133358-phpapp02/95/asfws-2012-nodejs-security-old-vulnerabilities-in-new-dresses-par-sven-vetsch-7-638.jpg?cb=1353936909">
```

## Qual a diferença entre um sistema single para um multi-thread?
```
A diferença de um sistema single thread é que todo o sistema funcionará numa unica thread, ou seja, todo o programa rodará de uma só vez, ao contrário do multi-thread que pode dividir esse programa em diversas threads com funções para parar, iniciar, retomar, entre outras. Um sistema multi-thread é muito util para que o usuário não precise ficar esperando uma tarefa finalizar para iniciar outra, visto que a mesma pode ser jogada para a thread pool e iniciar outra, e só depois retomar aquela thread.
```

## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
```
Essa requisição terá que aguardar alguma das outras 4 ser liberada para que essa entre.

## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Explicaria que desenvolver o nosso sistema em Node.js melhoraria muito o desempenho e a segurança do mesmo, visto que o mesmo utiliza o mesmo motor do Google Chrome para funcionar. Também explicaria como o mesmo funciona com requisições assíncronas, possui bibliotecas poderosas, um bom controle de threads, entre outras.

Também falaria que é a mesma linguagem utilizada para desenvolver o Netflix e o Paypal.
```

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

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


text:
# Node.js - Aula 02 - Exercício
**user:** [fernandobd42](https://github.com/fernandobd42)
**autor:** Fernando Lucas
**date:** 1467347548312

## Estrutura

## Quais são os 4 verbos que utilizamos para o CRUD?
CRUD - (Create, Retrive/Read, Update, Delete)

-Create (POST)
-Retrive/Read (GET)
-Update (PUT)
-Delete (DELETE)

## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Para padronizar o retorno das requisições HTTP cliente-servidor.

###1XX Informação###
![Imagem 100](https://http.cat/100)

###2XX Sucesso###
![Imagem 200](https://http.cat/200)

###3XX Redirecionamento###
![Imagem 300](https://http.cat/300)

###4XX Erro do cliente###
![Imagem 400](https://http.cat/400)

###5XX Erro do servidor###
![Imagem 500](https://http.cat/500)

## Explique o que é cada parâmetro da função recebida no `createServer`.
Request recebe os parâmetros utilizados pelo usuário na requisição.
Response manipula a responsta a ser enviada ao usuário.

## O que é e para que serve a Querystring?
Querystring é um padrão que utiliza o método GET para receber valores na url.

## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:

```
'use strict';

var date = (new Date()).toJSON();

const http = require('http')
   , SUCCESS = {
       version: 1.0
       , name: 'Be MEAN'
       , created_at: date }
    , ERROR = {
       message: 'Não encontrado'
    };

http.createServer(function(req, res){
   switch (req.url) {
     case"/api/v1/pokemons/create":
       res.writeHead(200, {'Content-type': 'application/json; charset=utf-8'});
       res.write(JSON.stringify(SUCCESS));
       break;

     case "/api/v1/pokemons/read":
       res.writeHead(200, {'Content-type': 'application/json; charset=utf-8'});
       res.write(JSON.stringify(SUCCESS));
       break;

     case "/api/v1/pokemons/update":
       res.writeHead(200, {'Content-type': 'application/json; charset=utf-8'});
       res.write(JSON.stringify(SUCCESS));
       break;

     case "/api/v1/pokemons/delete":
       res.writeHead(200, {'Content-type': 'application/json; charset=utf-8'});
       res.write(JSON.stringify(SUCCESS));
       break;

     default:
       res.writeHead(400, {'Content-type': 'application/json; charset=utf-8'});
       res.write(JSON.stringify(ERROR));
       break;
    }

    res.end();
}).listen(3000, function(){
    console.log('Servidor rodando em localhost:3000');
});
```


text:
# Node.js - Aula 01 - Exercício
**user:** [falconeric](https://github.com/falconeric)
**autor:** Eric Lessa
**Data:** 1466310895

## Quais são os 4 verbos que utilizamos para o CRUD?
Para o CRUD utilizamos seguintes verbos http: Post (**C**reate), Get (**R**etrieve), Put (**U**pdate) e Delete (**D**elete).

## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
Os códigos de retorno HTTP foram criados para a identificação do retorno do servidor. Compostos por 3 dígitos padronizam a identificação do retorno.

**1xx Informacional**

!['Informacional'](https://http.cat/100)

**2xx Sucesso**

!['Successfull'](https://http.cat/200)

**3xx Redirecionamento**

!['Redirection'](https://http.cat/300)

**4xx Erro do Cliente**

!['Client Error'](https://http.cat/400)

**5xx Erro do Servidor**

!['Server Error'](https://http.cat/500)

## Explique o que é cada parâmetro da função recebida no `createServer`.
**Request:** Objeto com as informações de requisição do cliente, como URL, Headers e outras.

**Response:** O objeto response é usado para retornar a solicitação do cliente. Deve inicialmente chamar o método *response.writeHead()*, este método envia um HTTP status code e uma coleção de response headers ao cliente, após escrevermos os headers podemos escrever html utilizando o método *response.write()*, depois devemos chamar *response.end()*

## O que é e para que serve a Querystring?
Querystring são conjuntos de chave/valor anexados a URL.
Basicamente servem para recuperarmos valores de uma requisição.

## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:

```
//server.js

'use strict';

var date = (new Date()).toJSON();

const http = require('http')
    , SUCCESS = {
        version: 1.0
      , name: 'Be MEAN'
      , created_at: date
      }
    , ERROR = {
        message: ":/ Não encontrado!"
      }
    ;

http.createServer(function(request, response) {

  switch (request.url) {

    case '/api/pokemons/create':
      response.writeHead(200, {'Content-type': 'application/json; charset=utf-8'});
      SUCCESS.url = request.url;
      response.write(JSON.stringify(SUCCESS));
      break;

    case '/api/pokemons/read':
      response.writeHead(200, {'Content-type': 'application/json; charset=utf-8'});
      SUCCESS.url = request.url;
      response.write(JSON.stringify(SUCCESS));
      break;

    case '/api/pokemons/update':
      response.writeHead(200, {'Content-type': 'application/json; charset=utf-8'});
      SUCCESS.url = request.url;
      response.write(JSON.stringify(SUCCESS));
      break;

    case '/api/pokemons/delete':
      response.writeHead(200, {'Content-type': 'application/json; charset=utf-8'});
      SUCCESS.url = request.url;
      response.write(JSON.stringify(SUCCESS));
      break;

    default:
        response.writeHead(404, {'Content-type': 'application/json; charset=utf-8'});
        response.write(JSON.stringify(ERROR));

  }

  response.end();

}).listen(3000, function(){
  console.log('Servidor rodando em localhost:3000');
});

```


text:
# Node.js - Aula 02 - Exercício
**User:** [higordiego](https://github.com/higordiego)

**Autor:** Higor Diego

**Date:** Thu Jan 28 2016 18:53:31 GMT-0300 (BRT)

## Quais são os 4 verbos que utilizamos para o CRUD?
C - Crear - POST
R - Leitura - GET
U - Alterar - PUT
D - Deletar - DELETE

## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).
O 'Status Code' foi inventado para padronização de erro e facilitando a conversa de cliente e servidor.

* **1XX** - Informação

![](https://http.cat/101)

* **2XX** - Sucesso

![](https://http.cat/200)

* **3XX** - Redirecionamento

![](https://http.cat/304)

* **4XX** - Cliente Error

![](https://http.cat/400)

* **5XX** - Servidor error

![](https://http.cat/500)

## Explique o que é cada parâmetro da função recebida no `createServer`.

Requisão - São os parametros da requisão do feita pelo o usuário.

Resposta - Contém o retorno do servidor ( resposta requerida pelo o usuário )

## O que é e para que serve a Querystring?
QueryString o conjunto de parametro enviado para o servidor, serve para passar parametros para o servidor (na requisição.) obtendo resposta.

## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:

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

    var primeira = {
        status: 01,
        messagem: 'Primeira pagina'
    },
    segunda = {
        status: 02,
        messagem: 'Segunda pagina'
    },
    terceira = {
        status: 03,
        messagem: 'Terceira Pagina'
    },
    quarta = {
        status: 04,
        messagem: 'Quarta pagina'
    },
    error = {
        status: false,
        messagem: 'Quarta pagina'
    };

    http.createServer(function(req, res){
        var method = req.method
        ,   url    = req.url;
        switch(url){
            case '/t1':
            if(method == 'GET'){
                 res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
                 res.write(JSON.stringify(primeira));
            }else{
                res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
                 res.write(error);
            }
            break;

            case '/t2':
            if(method == 'POST'){
                 res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
                 res.write(JSON.stringify(segunda));
            }else{
                res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
                 res.write(error);
            }
            break;
            case '/t3':
            if(method == 'PUT'){
                 res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
                 res.write(JSON.stringify(terceira));
            }else{
                res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
                 res.write(error);
            }
            break;

            case '/t4':
            if(method == 'POST'){
                 res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
                 res.write(JSON.stringify(quarta));
            }else{
                res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
                 res.write(error);
            }
            break;

            default:
            res.writeHead(404, { 'Content-Type': 'application/json; charset=utf-8' });
            res.write('error: 404');
            break;

        }
    }).listen(3000,function(){
        console.log('servidor rodando porta http://localhost:3000');
    });

```


text:
# Node.js - Aula 02 - Exercício
**user:** [Zowder](https://github.com/Zowder)
**autor:** Emídio de Paiva Neto

## Quais são os 4 verbos que utilizamos para o CRUD?
>* Create(POST) - Read/Retrieve(GET) - Update(PUT) - Delete(DELETE)

## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat/).

Surgiu com a necessidade de padronização de retorno do servidor, facilitando o entendimento de cada um.

*  **1XX - Informacional**

![](https://http.cat/100)

*  **2XX - Sucesso**

![](https://http.cat/200)

*  **3XX - Redirecionamento**

![](https://http.cat/307)

* **4XX- Erro de cliente**

![](https://http.cat/404)

*  **5XX - Erro de servidor**

![](https://http.cat/502)

## Explique o que é cada parâmetro da função recebida no `createServer`.
**Request:** Parâmetro da requisição feita pelo usuário.
**Response:** Parâmetro que retorna as informações para o usuário.

## O que é e para que serve a Querystring?

>Na Internet, uma string de consulta (também chamado de querystring HTTP) faz parte do conjunto de caracteres de entrada automaticamente na barra de endereço de um site dinâmico quando um usuário faz uma solicitação de informação de acordo com certos critérios.

Exemplo:

    http://example.com/over/there?name=ferret

## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
```js
//server.js
'use strict';

var date = (new Date()).toJSON();

const http = require('http')
    , SUCCESS = {
        version: '1.0'
      , name: 'Be MEAN'
      , returned_at: date
      }

    , ERROR = {
        message: "Não encontrado!"
      }
    ;

http.createServer(function(req, response){
  switch(req.url){

  			case "/api/pokemons/create" :
  				response.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
  				response.end(JSON.stringify([SUCCESS, {info: "Create: Ok"}]));
  			break;
  			case "/api/pokemons/update" :
  				response.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
  				response.end(JSON.stringify([SUCCESS, {info: "Update: Ok"}]));
  			break;
  			case "/api/pokemons/read" :
  				response.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
  				response.end(JSON.stringify([SUCCESS, {info: "Retrieve: Ok"}]));
  			break;
  			case "/api/pokemons/delete" :
  				response.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
  				response.end(JSON.stringify([SUCCESS, {info: "Delete: Ok"}]));
  			break;
  			default:
  				response.writeHead(404, {'Content-Type' : 'application/json; charset=utf-8'})
  				response.end(JSON.stringify(ERROR));
  			break;
  	}
  response.end();
}).listen(3000, function(){
  console.log('Servidor rodando em localhost:3000');
});
```


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

**autor:** Maurício Reatto Duarte

## Quais são os 4 verbos que utilizamos para o CRUD?

- Create - Criar
- Read/Retrieve - Ler/Recuperar
- Update - Atualizar
- Delete - Excluir

## Para que foram inventados os Status Codes? Dê exemplo de 1 código por grupo e a imagem do [Cat Status Code](https://http.cat).

Esses _Status Codes_ foram criados para que houvesse uma forma de padronizar o retorno das requisições HTTP.

#### 1XX - Informacional
Resposta provisória para informar o cliente de que a solicitação foi recebida e não rejeitada pelo servidor.
![100](https://http.cat/100).

#### 2XX - Sucesso
Pedido aceito para processamento, mas ainda não se encontra concluído. É uma resposta à fim de que o servidor possa aceitar o pedido de outro processo.
![202](https://http.cat/202)

#### 3XX - Redirecionamento
Informa que a solicitação está temporariamente em uma URI diferente. O cliente deve continuar com essa URI para solicitações futuras.
![302](https://http.cat/302)

#### 4XX- Erro de cliente
Solicitação foi atendida, porém não será executada.
![403](https://http.cat/403)

#### 5XX - Erro de servidor
O servidor é usado como _Gateway_ ou _Proxy_
![502](https://http.cat/502)

## Explique o que é cada parâmetro da função recebida no `createServer`.

A função recebida no `createServer` é uma função anônima, do qual é passado dois parâmetros.
```js
http.createServer(function(req, res){
. . .
});
```
#### `request`
Objeto do qual corresponde a solicitação enviada pelo cliente, como por exemplo, a URL, cabeçalhos HTTP, etc.

#### `response`
Objeto de resposta do qual é utilizado para devolver os dados ao cliente.

## O que é e para que serve a Querystring?
Valores enviados pela _URL_ via `GET`. Na maioria das vezes, são de forma simples e pequena entre cliente/servidor, seguindo o padrão de `'key' : 'value'`
Exemplo:
```
.../caminho?nome=pikachu&tipo=eletrico
```

## Escreva no código do `server.js` uma forma de entregar um JSON de sucesso em 4 rotas diferentes:
- /api/pokemons/create
- /api/pokemons/read
- /api/pokemons/update
- /api/pokemons/delete

~~~js
'use strict';

const date = (new Date()).toJSON();

const http = require('http'),
		SUCCESS = {
			version: 1.1,
			code: 200,
			name: 'BE MEAN',
			created_at: date
		},
		ERROR = {
			message: 'Não encontrado!'
		};

http.createServer(function(req, res){

	const url = req.url;

	switch(url){

    case "/api/pokemons/create":
       create();
       break;

    case "/api/pokemons/read":
       read();
       break;

    case "/api/pokemons/update":
       update();
       break;

    case "/api/pokemons/delete":
       delete();
       break;

    default:
       res.writeHead(404, { 'Content-Type': 'application/json;' });
       res.write(JSON.stringify(ERROR));
       break;
  }

  res.end();

}).listen(3000, function() {
	console.log('Servidor ON em http://localhost:3000/');
});

function create(){
   res.writeHead(200, { 'Content-Type': 'application/json;' });
   res.write(JSON.stringify(SUCCESS));
}

function read(){
   res.writeHead(200, { 'Content-Type': 'application/json;' });
   res.write(JSON.stringify(SUCCESS));
}

function update(){
   res.writeHead(200, { 'Content-Type': 'application/json;' });
   res.write(JSON.stringify(SUCCESS));
}

function delete(){
   res.writeHead(200, { 'Content-Type': 'application/json;' });
   res.write(JSON.stringify(SUCCESS));
}

~~~