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

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

## Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma
```
const name = (nome, callback) => {
  if (typeof nome === 'string') {
    return callback(null, 'O nome é: '+ nome);
  } else {
    let err = new Error("Tipo de dado incorreto, digite uma string por favor.");

    return callback(err, null);
  }
}

const printName = (err, nome) => {
  if (err) {
    console.log(err);
  } else {
    console.log(nome);
  }
};

name('Fernando Lucas', printName); // 'O nome é: Fernando Lucas'
```

## Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula
```
const sum = (a, b, callback) => {
  if (typeof a === 'number' && typeof b === 'number') {
    let sum = a + b;
      return callback(null, 'A soma é: '+ sum);
  } else {
    let err = new Error('Tipo de dado incorreto, digite apenas números por favor.');
      return callback(err, null);
  }
}

const printSum = (err, sum) => {
  if (err) {
    console.log(err);
  } else {
    console.log(sum);
  }
}

sum(3,6, printSum); // A soma é: 9
```
## Criar uma função que calcula a média de dois valores e imprima essa média em outra função, como continuação da execução da mesma
```
const av = (a, b, callback) => {
  if (typeof a === 'number' && typeof b === 'number') {
    let average = (a + b) / 2;
      return callback(null, 'A média é: '+ average);
  } else {
    let err = new Error('Tipo de dado incorreto, digite apenas números por favor.');
      return callback(err, null);
  }
}

const printAv = (err, average) => {
  if (err) {
    console.log(err);
  } else {
    console.log(average);
  }
}

av(3,6, printAv); // A média é: 4.5
```

## Explicar a definição de continuação de uma função
O termo continuação de uma função consiste em passar uma função como parâmetro de outra função, que ao ser invocada dependerá do retorno da função que foi passada como argumento para continuar o processo. Ou seja, a função A que possui o callback (chamada de retornorno) executa as instruções necessárias e passa os argumentos para a função B, que é responsável pelo retorno.


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

**autor:** Paulo Roberto

## Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma.
```js
// file: name.js
function setName(name, callback){
	callback(name);
}

setName('paulo', function(name){
	console.log(name);
});
```
```js
paulo@Paulo:~/workshop-be-mean/nodejs/4$ node name.js
paulo
```
## Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula.
```js
// file: sum.js
function sum(num1, num2, callback){
	if(typeof num1 == "number" && typeof num2 == "number"){
		var resultado = num1+num2;
		callback(null, resultado);
	} else {
		callback("Passe um número por favor", null);
	}
}

sum(2,2,function(err, result){
	if(err){
		console.log(err);
	}else{
		console.log(result);
	}
});
```

```js
paulo@Paulo:~/workshop-be-mean/nodejs/4$ node sum.js
4
```

## Criar uma que calcular a média de dois valores e imprima essa média uma outra função, como continuação da execução da mesma.
```js
// file: media.js
function media(num1, num2, callback){
	if(typeof num1 == "number" && typeof num2 == "number"){
		var resultado = (num1+num2)/2;
		callback(null, resultado);
	} else {
		callback("Passe um número por favor", null);
	}
}

media(2,2,function(err, result){
	if(err){
		console.log(err);
	}else{
		console.log(result);
	}
});
```
```js
paulo@Paulo:~/workshop-be-mean/nodejs/4$ node media.js
2
```
## Explicar a definição de continuação de uma função.
Uma função que recebe como parâmetro outra função(callback), e executa essa função recebida passando para ela
seu resultado como parâmetro.

repo_language: JavaScript

mime_type: text/plain


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

## Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma.

```js
'use strict';

function input(name, callback) {
  if (typeof name === 'string') {
    return callback(null, name);
  } else {
    let error = new Error('Pow passa um string aí véi');
    return callback(error, null);
  }
}

input("Igor", (err, name) => {
  if (err) {
    console.log(err);
  } else {
    console.log(name);
  }
});
```
## Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula.

```js
'use strict';

function sum(num1, num2, callback) {
  if(typeof num1 === 'number' && typeof num2 === 'number') {
    let result = num1 + num2;
    return callback(null, result);
  } else {
    let error = new Error("Passe um numero");
    return callback(error, null);
  }
}

sum(2, 4, (err, result) => {
  if (err) {
    console.log(err);
  } else {
    console.log(result);
  }
});

```

## Criar uma função que calcula a média de dois valores e imprima essa média em outra função, como continuação da execução da mesma.

```js
'use strict';

function sum(num1, num2, callback) {
  if(typeof num1 === 'number' && typeof num2 === 'number') {
    let result = (num1 + num2) / 2;
    return callback(null, result);
  } else {
    let error = new Error("Passe um numero");
    return callback(error, null);
  }
}

sum(4, 8, (err, result) => {
  if (err) {
    console.error(err);
  } else {
    console.log(result);
  }
});

```

## Explicar a definição de continuação de uma função.
É simplesmente quando passamos um função como parametro de outra função.


text:
# Node.js - Aula 04 - Exercício
**Autor:** Ednilson Amaral
**Data:** 1450748289337

## Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma.

```js
function meuNome(nome, callback){
  if (typeof nome === 'string') {
    return callback(null, nome);
  } else {
    var err = new Error("Digite uma string, parça!");

    return callback(err, null);
  }
}

meuNome("Ednilson Amaral", function (err, nome){
  if (err) {
    console.log(err);
  } else {
    console.log(nome);
  }
});
```

Saída:

```
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs/exercicios-callbacks$ node exercicio_01.js
Ednilson Amaral
```

## Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula.

```js
function soma(n1, n2, callback){
  if (typeof arguments[0] == "number" && typeof arguments[1] == "number") {
    var result = n1 + n2;

    return callback(null, result);
  } else {
    var err = new Error("Digite um número, parça!");

    return callback(err, null);
  }
}

soma(5, 5, function (err, result) {
  if (err) {
    console.log(err);
  } else {
    console.log(result);
  }
});
```

Saída:

```
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs/exercicios-callbacks$ node exercicio_02.js
10
```

## Criar uma que calcular a média de dois valores e imprima essa média uma outra função, como continuação da execução da mesma.

```js
function soma(n1, n2, callback){
  if (typeof arguments[0] == "number" && typeof arguments[1] == "number") {
    var result = (n1 + n2) / 2;

    return callback(null, result);
  } else {
    var err = new Error("Digite um número, parça!");

    return callback(err, null);
  }
}

soma(8, 4, function (err, result) {
  if (err) {
    console.log(err);
  } else {
    console.log(result);
  }
});
```

Saída:

```
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs/exercicios-callbacks$ node exercicio_03.js
6
```

## Explicar a definição de continuação de uma função.

A continuação de função é quando ao chamar determinada função, chamamos outra função nela como parâmetro. Ou seja, em algum momento, A função passada como parâmetro vai enviar algo para a outra função para continuar com a execução do código.


text:
# Node.js - Aula 04 - Exercício
**user:** [filipe1309](https://github.com/filipe1309)
**autor:** Filipe Leuch Bonfim

## Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma
```js
function readName(name, printCallback) {
  if (typeof name == "string") {
    return printCallback(null, name);
  } else {
    var error = new Error("informe uma string!!!");
    return printCallback(error, null);
  }
}

function printCallback(err, result) {
  if (err) {
    console.log(err);
  } else {
    console.log(result)
  }
}

readName("nome_teste", printCallback); // nome_teste
readName(1, printCallback); // [Error: informe uma string!!!]
```

## Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula
```js
function sumValues(value1, value2, printCallback) {
 if (typeof value1 == "number" && typeof value2 == "number") {
    var result = value1 + value2;
    return printCallback(null, result);
  } else {
    var error = new Error("informe somente números!!!");
    return printCallback(error, null);
  }
}

function printCallback(err, result) {
  if (err) {
    console.log(err);
  } else {
    console.log(result)
  }
}

sumValues("nome_teste", 2, printCallback); // [Error: informe somente números!!!]
sumValues(1, 2, printCallback); // 3
```

## Criar uma função que calcula a média de dois valores e imprima essa média em outra função, como continuação da execução da mesma
```js
function average(value1, value2, printCallback) {
 if (typeof value1 == "number" && typeof value2 == "number") {
    var result = (value1 + value2)/2;
    return printCallback(null, result);
  } else {
    var error = new Error("informe somente números!!!");
    return printCallback(error, null);
  }
}

function printCallback(err, result) {
  if (err) {
    console.log(err);
  } else {
    console.log(result)
  }
}

average("nome_teste", 2, printCallback); // [Error: informe somente números!!!]
average(1, 2, printCallback); // 1.5
```

## Explicar a definição de continuação de uma função
Continuação de uma função, também conhecido como `continuation-passing style (CPS)` na programação funcional, é um estilo de programação em quem uma função recebe uma outra função como parâmetro (conhecida como função de **callback**), e ao final de sua execução, a função que foi passada como parâmetro é executada.


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

**Autor:** Sergiokopplin

**Date:** 1450670429154

## Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma.
```js
function imprimiNome(name, callback) {
    "use strict";

    if(typeof name === "string"){
        var str = "Seu nome é: " + name;
        return callback(null, str);
    } else {
        var erro = new Error("Você precisa passar uma string com o seu nome.");
        return callback(erro, null);
    }
};

imprimiNome("Sérgio Aragão Kopplin", function(erro, name) {
    "use strict";

    if (erro) {
        console.log(erro);
    } else {
        console.log(name);
    }
});
```

## Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula.
```js
function somaValores(num1, num2, callback) {
    "use strict";

    if(typeof num1 === "number" && typeof num2 === "number"){
        var res = num1 + num2;
        return callback(null, res);
    } else {
        var erro = new Error("Você precisa passar apenas números para a função.");
        return callback(erro, null);
    }
};

somaValores(13, 76, function(erro, name) {
    "use strict";

    if (erro) {
        console.log(erro);
    } else {
        console.log(name);
    }
});
```

## Criar uma função que calcula a média de dois valores e imprima essa média em outra função, como continuação da execução da mesma.
```js
function calculaMedia(num1, num2, callback) {
    "use strict";

    if(typeof num1 === "number" && typeof num2 === "number"){
        var res = ( num1 + num2 ) / 2;
        return callback(null, res);
    } else {
        var erro = new Error("Você precisa passar apenas números para a função.");
        return callback(erro, null);
    }
};

calculaMedia(1, 5, function(erro, name) {
    "use strict";

    if (erro) {
        console.log(erro);
    } else {
        console.log(name);
    }
});
```

## Explicar a definição de continuação de uma função.
A continuação de uma função consiste em chamar otura função como parâmetro dentro de uma função principal. Essa função parâmetro será, em determinado momento, chamada em forma de callback, sendo assim, quando o código executar a primeira função terá como callback o resultado de outra função.


text:
# Node.js - Aula 04 - Exercício
**User:** charles7421

**Autor:** Charles de Freitas Garcia

**Date:** 03/04/2016

## Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma.

```js
function sayMyName(name, callback) {
  if (typeof name === 'string') {
    return  callback(null, name);
  } else {
    var err = new Error('Informe ');
    return callback(err, null);
  }
}

sayMyName("Heisenberg", function(err, name){
  if (err){
    console.log(err);
  } else {
    console.log(name);
  }

});
```

## Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula.

```js
function soma(num1, num2, callback){
  if (typeof num1 == "number" && typeof num2 == "number") {
    var result = num1 + num2;
    callback(null, result);
  } else {
    var err = new Error("Informe um número");
    return callback(err, null);
  }
}

soma(1,1, function(err, result){
  if (err){
    console.log(err);
  } else {
    console.log(result);
  }
})

```

## Criar uma função que calcula a média de dois valores e imprima essa média em outra função, como continuação da execução da mesma.

```js
function media(num1, num2, callback){
  if (typeof num1 == "number" && typeof num2 == "number") {
    var result = (num1 + num2) / 2;
    callback(null, result);
  } else {
    var err = new Error("Informe um número");
    return callback(err, null);
  }
}

media(5,10, function(err, result){
  if (err){
    console.log(err);
  } else {
    console.log(result);
  }
})
```

## Explicar a definição de continuação de uma função.

A continuação de uma função ou CPS (Continuation-Passion style) é quando uma função é passada como parametro na chamada de uma função. Quando isso ocorre é processada e retorna o resultado para a função que realizou a chamada.


text:
# Node.js - Aula 04 - Exercício
**user:** [felipelopesrita](https://github.com/felipelopesrita)
**autor:** Felipe José Lopes Rita

## Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma
```js
'use strict';
function showName( name, callback ) {
	if( typeof name === "string" )
		return callback(null, name);
	else {
		var error = new Error("Tipo de dados inesperado, insira uma string");
		return callback(error, null);
	}
}

showName("Felipe", (err, resul)=>{
	if(err)
		console.log(err);
	else
		console.log(resul);
});
```

## Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula
```js
'use strict';
function sum( x, y, callback ) {
	if( typeof x === "number" && typeof y == "number" )
		return callback(null, x+y);
	else {
		var error = new Error("Tipo de dados inesperado, insira números");
		return callback(error, null);
	}
}

sum(14, 6, (err, resul)=>{
	if(err)
		console.log(err);
	else
		console.log(resul);
});
```

## Criar uma função que calcula a média de dois valores e imprima essa média em outra função, como continuação da execução da mesma
```js
'use strict';
function average( x, y, callback ) {
	if( typeof x === "number" && typeof y == "number" )
		return callback(null, (x+y)/2);
	else {
		var error = new Error("Tipo de dados inesperado, insira números");
		return callback(error, null);
	}
}

average(10, 6, (err, resul)=>{
	if(err)
		console.log(err);
	else
		console.log(resul);
});

```

## Explicar a definição de continuação de uma função
É o conceito de funções que recebem funções como parametro (First-class citizen). A função então retorna a execução da função que foi passada como parametro. Dessa forma, ocorre uma continuidade da execução através das funções.


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

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

**Autor:** Matheus José Krumenauer Weber

**Date:** 1456691485032

## Criar uma função com uma entrada para o nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma.
```js
    function sayName(name, callback){
        if(typeof name === 'string'){
            callback(null, name);
        }else{
            var err = new Error("It is not a string");
            return callback(err, null);
        }
    }

    sayName("Matheus", function(err,name){
        if (err){
            console.log(err);
        }else{
            console.log(name);
        }
    });
```
## Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula.
```js
    function sum(num1, num2, callback){
        if(typeof arguments[0] == "number" && typeof arguments[1] == "number"){
            var result = num1 + num2;
            callback(null, result);
        } else{
            var error = new Error("Arguments are not numbers.");
            return callback(error, null)
        }
    }

    sum(1,2, function(err,result){
        if (err){
            console.log(err);
        }else{
            console.log(result);
        }
    });
```
## Criar uma função que calcula a média de dois valores e imprima essa média uma outra função. como continuação da execução da mesma.
```js
    function average(num1, num2, callback){
        if(typeof arguments[0] == "number" && typeof arguments[1] == "number"){
            var result = (num1 + num2)/2;
            callback(null, result);
        } else{
            var error = new Error("Arguments are not numbers.");
            return callback(error, null)
        }
    }

    average(1,2, function(err,result){
        if (err){
            console.log(err);
        }else{
            console.log(result);
        }
    });
```

## Explicar a definição de continuação de uma função.
```js
    Continuation-passing style é quando um dos argumentos de uma função é outra função que trata da continuação dela. Por exemplo, no average acima o argumento callback foi passado para a segunda função e tratada como erro ou resultado.
```


text:
# Node.js - Aula 04 - Exercício
**user:** [diegolopesdev](http://www.github.com/diegolopesdev)
**autor:** Diego Lopes do Nascimento

## Exercícios de File System

## Criar um arquivo.

```
'use strict';

const fs = require('fs');

fs.writeFile('ola-mundo.txt', 'É o meu primeiro Olá Mundo.', (err) => {
   if(err) throw err;
   console.log('O arquivo foi criado com sucesso.');
});
```

## Ler um arquivo.

```
'use strict';

const fs = require('fs');

fs.readFile('ola-mundo.txt', (err, data) => {
   if(err) throw err;
   console.log(data.toString());
});
```

## Editar conteúdo desse arquivo.

```
'use strict';

const fs = require('fs');

var writeFileStream = fs.createWriteStream('./ola-mundo.txt');

writeFileStream.write('Inserindo um novo olá mundo!');
```

## Deletar arquivo.

```
'use strict';

const fs = require('fs');

fs.unlink('ola-mundo.txt', (err => {
   if(err) throw err;
   console.log('O arquivo foi deletado com sucesso.');
}));
```

## Renomear o arquivo.

```
'use strict';

const fs = require('fs');

fs.rename('./ola-mundo.txt', './ola-mundo-2.txt', (err) => {
   if(err) throw err;
   console.log('O arquivo foi renomeado com sucesso.');
});
```

## **Desafio: Criar um servidor web de arquivos estáticos: .css, .html, .js e etc...**

Challenge Accepted! Mãos na massa.

Para não poluir muito o código do meu mini servidor web de arquívos estáticos **sem usar express**, eu decidi por criar dois arquivos HTML: o **index.html** e o **404.html**, que serão nossos dois arquivos HTML padrões.

A lógica do servidor é baseada no client tentar acessar /nome-do-arquivo.extensao e, se o arquivo existir, carregará no browser e para caso não exista, retornar um error genérico 404.

**index.html**

```
<!DOCTYPE html>
<html>
   <head>
      <meta charset="utf-8">
      <title></title>
   </head>
   <body>
      <h1>Bem vindo ao meu servidor estático!</h1>
   </body>
</html>
```

**404.html**

```
<!DOCTYPE html>
<html>
   <head>
      <meta charset="utf-8">
      <title></title>
   </head>
   <body>
      <h1>Error 404 - Nada encontrado!</h1>
   </body>
</html>
```

**http-server.js**

```
'use strict';

const http = require('http')
    , fs   = require('fs');

http.createServer((req, res) => {
   let url = req.url;

   if(url == '/' || url == '/favicon.ico') url = 'index.html';

   const file = './' + url;

   fs.readFile(file, (err, data) => {
      if(err) {
         res.writeHead(404, {'Content-type': 'text/html; charset=utf-8'});
         res.write( fs.readFileSync('404.html') );
      } else {
         res.writeHead(200, {'Content-type': 'text/html; charset=utf-8'});
         res.write(data);
      }
      res.end();
   });

}).listen(8000, () => {
   console.log('O servidor está em localhost:8000');
});
```


text:
# Node.js - Aula 04 - Exercício
**user:** [FranciscoValerio](https://github.com/FranciscoValerio)
**autor:** Francisco Henrique Ruiz Valério

## 1. Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma.

var fileSytem = require('fs');

function sayName(name, callback){
   setTimeout(function(){
      if ( typeof name === 'string' ){
         return callback(null, name);
      } else {
         var error = new Error("O parâmetro passado não é do tipo string!");
         return callback( error, null);
      }
   }, 20 );
}

function printName(name){
   setTimeout(function(){
      if ( typeof name === 'string' ){
         console.log( name );
      }
   }, 10 );
}

sayName( "Francisco Valerio", function( error, result ){
   if ( error ){
      console.log( error );
   }
   printName(result);
});

## 2. Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula.

var fileSytem = require('fs');

function sum(numero1, numero2, callback){
   setTimeout(function(){
      if( typeof numero1 == "number" && typeof numero2 == "number" ){
         var result = numero1 + numero2;
         callback(null, result);
      } else {
         var error = new Error("Algum dos parâmetros passados não foi do tipo numérico.");
         return callback(error, null);
      }
   }, 20);
}

function printResult(result){
   setTimeout(function(){
      if ( typeof result === 'number' ){
         console.log( result );
      }
   }, 10 );
}

sum(4, 4, function( error, result ){
   if (error){
      console.log(error);
   }
   printResult(result);
});

## 3. Criar uma que calcular a média de dois valores e imprima essa média uma outra função, como continuação da execução da mesma.

var fileSytem = require('fs');

function average(numero1, numero2, callback){
   setTimeout(function(){
      if( typeof numero1 == "number" && typeof numero2 == "number" ){
         var media = ( numero1 + numero2 ) / 2;
         callback(null, media);
      } else {
         var error = new Error("Ops passe números.");
         return callback(error, null);
      }
   }, 20);
}

function printResult(result){
   setTimeout(function(){
      if ( typeof result === 'number' ){
         console.log( result );
      }
   }, 10 );
}

average(4, 4, function( error, result ){
   if (error){
      console.log(error);
   }
   printResult(result);
});

## 4. Explicar a definição de continuação de uma função.

Um forma simples de explicar essa definição é pensarmos em uma função que possa ser traçada em uma folha sem retirar a caneta do papel. Caso a função se interrompa e começe em outro local do papel, ocorre uma "descontinuidade". Ou seja, essa função não pode ser termina e iniciada em outra local "chamada".


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

autor: Bruno Lima da Silva

## 1. Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma.
```js
'use strict';

function callback (err, result) {
	if (err) throw new Error (err);
	console.log ('Meu nome é ', result);
}

function sayName (name, callback) {
	if (typeof name === 'string') return callback (null, name);
	const err = 'Você precisa passar uma STRING para name';
	return callback (err, null);
}
```
## 2. Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula.
```js
'use strict';

function callback (err, result) {
	if (err) throw new Error (err);
	console.log ('A soma é ', result);
}

function sum (value1, value2, callback) {
	if (typeof value1 === 'number' && typeof value2 === 'number') return callback (null, (value1+value2));
	const err = 'Você precisa informar dois números';
	return callback (err, null);
}
```
## 3. Criar uma que calcular a média de dois valores e imprima essa média uma outra função, como continuação da execução da mesma.
```js
'use strict';

function callback (err, result) {
	if (err) throw new Error (err);
	console.log ('A média é ', result);
}

function media (value1, value2, callback) {
	if (typeof value1 === 'number' && typeof value2 === 'number') return callback (null, ((value1+value2)/2));
	const err = 'Você precisa informar dois números';
	return callback (err, null);
}
```

## 04.Explicar a definição de continuação de uma função.


text:
# NodeJS - Aula 04.01 - Exercícios
**User:** [carloshenriqueribeiro](https://github.com/carloshenriqueribeiro)
**Autor:** Carlos Henrique Ribeiro
**Date:** 1501763351107

## 1. Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da mesma.

```js
function imprimirNome(nome,callback){
    if (typeof nome === 'string') {
        return callback(null,nome);
    } else {
        erro = new Error('Nome inválido!');
        return callback(erro,null);
    }
}

imprimirNome('Carlos Ribeiro', function(err, result){
    if (err) console.log(err);
    else console.log(result);
});
```

## 2. Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função que imprima-o, de acordo com o padrão apresentado em aula.

```js
function soma(val1, val2, callback){
    if (typeof val1 === 'number' && typeof val2 === 'number'){
        var resultado = val1 + val2;
        return callback(null,resultado);
    } else {
        var erro = new Error('Valores inválidos');
        return callback(erro, null);
    }
}

soma(666,333,function(err,result){
    if (err) console.log(err);
    else console.log(result);
});
```

## 3. Criar uma que calcular a média de dois valores e imprima essa média em uma outra função, como continuação da execução da mesma.

```js
function calcularMedia(val1, val2, callback){
    if (typeof val1 === 'number' && typeof val2 === 'number'){
        var resultado = (val1 + val2) / 2;
        return callback(null,resultado);
    } else {
        var erro = new Error('Valores inválidos');
        return callback(erro, null);
    }
}

calcularMedia(666,333,function(err,result){
    if (err) console.log(err);
    else console.log(result);
});
```

## 4. Explicar a definição de continuação de uma função.
Continuação de uma função é a técnica de chamar uma função dentro de outra função. O retorno da função chamada deve estar no formato de callback para a função chamadora. Podendo ser Async ou Sync.


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

##1. Criar uma função com **uma entrada** para nome e **imprimir** está entrada em uma outra função, como continuação da execução da mesma.
```js

	function imprimirNome(nome, callback) {
		if (typeof nome === 'string') {
			callback(null, nome);
		} else {
			var err = new Error('Opa, deu erro');

			callback(err, null);
		}
	};

	imprimirNome('Dariano', (err, nome) => {
		if(err) {
			console.log('erro', err);
		}else
		{
			console.log('nome = ', nome);
		}

	});

nome = Dariano

```
##2. Criar uma função que **calcula a soma** de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula.
```js

	function soma (num1, num2, callback) {
		if(typeof num1 === 'number' && typeof num2 === 'number'){
			var result = num1 + num2;

			callback(null, result);
		} else{
			var error = new Error('Passe o número valido');

			callback(error, null);
		}
	};

	soma(5, 5, (err, result) => {
		if(err){
			console.log('error', err);
		}
		else{
			console.log('soma = ', result);
		}
	});

soma = 10

```
##3. Criar uma função que **calcula a média** de dois valores e imprima essa média em uma outra função, como continuação da execução da mesma.
```js

	function media(num1, num2, callback) {
		setTimeout(() => {
			if (typeof num1 === 'number' && typeof num2 === 'number') {
				var result = (num1 + num2) / 2;

				callback(null, result);
			} else {
				var error = new Error('Passe o número valido');

				callback(error, null);
			}
		}, 1000);
	};

	media(30, 20, (err, result) => {
		if (err) {
			console.log('error', err);
		} else {
			console.log('media', result);
		}
	});

media 25

```
##4. Explicar a definição de **continuação de uma função**.
**Continuação de uma função** é a execução de uma função que pode receber outra função por parâmetro e logo após executar um procedimento e invocar a função passada por parâmentro. Ou pode ser uma função que executa um procedimento e logo após essa execução invoca outra função que pode executar seu fluxo e chamar outra função e assim sucessivamente. Isso também pode se chamadar de **funções aninhadas** ou **callback hell**.


text:
# Node.js - Aula 04 - Exercício
**User:** [Cerezini](https://github.com/Cerezini)
**Autor:** Mateus Cerezini Gomes

## Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma

```js
function printName(name, callback) {
  if (typeof name == 'string') {
    callback(name);
  } else {
    callback('Você deve passar uma string');
  }
}

printName('Pedro pão de batata', function(txt) {
  console.log(txt);
});

printName(3, function(txt) {
  console.log(txt);
});
```
```js
Pedro pão de batata
Você deve passar uma string
```

## Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula

```js
function sum(num1, num2, callback) {
  if (typeof num1 == 'number' && typeof num2 == 'number') {
    callback(null, num1 + num2);
  } else {
    var err = new Error('Você deve passar dois parêmetros numéricos');
    callback(err, null);
  }
};

sum(9, 9, function(err, value) {
  if (err) {
    console.log(err);
  } else {
    console.log('Soma = ', value);
  }
});

sum('9', 9, function(err, value) {
  if (err) {
    console.log(err);
  } else {
    console.log('Soma = ', value);
  }
});
```

```js
Soma =  18
[Error: Você deve passar dois parêmetros numéricos]
```

## Criar uma função que calcula a média de dois valores e imprima essa média em outra função, como continuação da execução da mesma

```js
function avg(num1, num2, callback) {
  if (typeof num1 == 'number' && typeof num2 == 'number') {
    callback(null, (num1 + num2)/2);
  } else {
    var err = new Error('Você deve passar dois parêmetros numéricos');
    callback(err, null);
  }
};

avg(3, 9, function(err, value) {
  if (err) {
    console.log(err);
  } else {
    console.log('Média = ', value);
  }
});

avg('9', 9, function(err, value) {
  if (err) {
    console.log(err);
  } else {
    console.log('Média = ', value);
  }
});
```

```js
Média =  6
[Error: Você deve passar dois parêmetros numéricos]
```

## Explicar a definição de continuação de uma função

Significa que a execução de um função é extendida pela execução de outra função, a qual é responsável pelo retorno da função original.


text:
# NodeJS - Aula 01 - Exercício
####Robson Fagundes - [http://robsonfagundes.github.io](robsonfagundes.github.io) - robsonfagundes@gmail.com

## 1. Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Node é uma aplicação single threaded, mas suporta a simultaneidade via conceito de eventos e callbacks. Como cada API do Node são assíncronas e sendo um único segmento, ele usa a função async chamadas para manter a simultaneidade. Node usa observador padrão. Node mantém um ciclo de eventos e sempre que qualquer tarefa de ficar concluída, ele aciona o evento correspondente que sinaliza a função de ouvinte de evento para obter executado.

## 2. Como o V8 executa o JavaScript? Demonstre 1 exemplo com código ou imagem.
[![Como o V8 executa o JavaScript](https://raw.githubusercontent.com/robsonfagundes/be-mean-instagram-nodejs-exercises/master/imgs/nodejs-event-loop.png)](https://raw.githubusercontent.com/robsonfagundes/be-mean-instagram-nodejs-exercises/master/imgs/nodejs-event-loop.png "Como o V8 executa o JavaScript")

## 3. Qual a diferença entre sistema single para um multi-thread?
#####Antes de mais nada... O que é uma Thread?

Uma Thread é uma sequencia de instruções sendo executadas em um programa. Uma thread pode ser interpretada como uma sequencia de instruções sendo executadas em um programa. Quando múltiplas thread são executadas em uma mesma entidade (no nosso caso, um processo), ela é chamada de multithreading.
[![Thread](https://raw.githubusercontent.com/robsonfagundes/be-mean-instagram-nodejs-exercises/master/imgs/thread.png)](https://raw.githubusercontent.com/robsonfagundes/be-mean-instagram-nodejs-exercises/master/imgs/thread.png "Thread")

#####Single-Threaded vs. Multithreaded
- Um sitema **singlethread** (thread única) inicia na etapa 1 e continua seqüencialmente (etapa 2, etapa 3, o passo 4) até atingir a etapa final.

- Já um sistema **multithread** (multiplas threads) permitem que você execute várias threads ao mesmo tempo, cada uma executando um passo por exemplo. Cada thread é executada em seu próprio processo, então, teoricamente, você pode executar o passo 1 em uma thread e, ao mesmo tempo executar o passo 2 em outra thread e assim por diante. Isso significa que a etapa 1, etapa 2, etapa 3 e etapa 4 podem ser executadas simultaneamente.

## 4. Como a Thread Pool tem tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
O processo do Node é single-thread, ou seja, um processo por instância. O **Event-Loop** fica recepcionando os eventos [(Reactor Pattern)](https://en.wikipedia.org/wiki/Reactor_pattern), e assim que recebido o evento, o mesmo é direcionado para um **Thread-Pool** que executará as tarefas em background liberando assim o event loop, e assim que as tarefas vão sendo concluídas, o Node acionará o callback que foi passado no início da execução do evento. Quando houver um numero de eventos que executa uma **Intensive-Operation** maior á 4, estes serão incluídos ao **Idle-Thread** que nada mais são, eventos que ficam aguardando um dos outros 4 eventos que estão na thread pool serem executadas para ser executado.

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

O objetivo declarado do Node é “fornecer uma maneira fácil de criar programas de rede escaláveis”. Qual é o problema com os programas de servidor atuais? Vamos fazer as contas. Em linguagens como Java™ e PHP, cada conexão inicia um novo encadeamento que, potencialmente, é acompanhado de 2 MB de memória. Em um sistema que tenha 8 GB de RAM, isto define o número máximo teórico de conexões simultâneas em cerca de 4.000 usuários.

À medida que sua base de clientes cresce, você deseja que seu aplicativo da Web suporte mais usuários e, portanto, será necessário adicionar mais servidores. É claro, isso se soma a custos de negócios, especificamente custos de servidor, custos de tráfego e custos de mão de obra. Adicione a esses custos o problema técnico potencial de que um usuário poderá usar diferentes servidores para cada solicitação, de forma que quaisquer recursos compartilhados deverão ser compartilhados por todos os servidores. Por exemplo, no Java, variáveis estáticas e caches precisam ser compartilhados entre as JVMs em cada servidor. Este é o gargalo de toda a arquitetura de aplicativos da web, o número máximo de conexões simultâneas que um servidor pode tratar.

O Node soluciona o problema mudando a forma como uma conexão é feita no servidor. Em vez de iniciar um novo encadeamento do SO para cada conexão (e alocar a memória correspondente com ele), cada conexão cria um processo, que não requer que o bloco de memória o acompanhe. O Node alega que nunca ocorrerá um impasse de bloqueios, pois não são permitidos bloqueios e ele não bloqueia diretamente para realizar chamadas de E/S. O Node também alega que um servidor que o execute pode suportar dezenas de milhares de conexões simultâneas. De fato, o Node altera o panorama do servidor ao mudar o gargalo do sistema inteiro do número máximo de conexões para a capacidade de tráfego de um único sistema.

[![Convencendo meu Chefe - Placar UOL Copa do Mundo e Eleições com Node js](https://raw.githubusercontent.com/robsonfagundes/be-mean-instagram-nodejs-exercises/master/imgs/braziljs.png)](https://www.youtube.com/watch?v=vR8CP0gE-No "Convencendo meu Chefe!!! Placar UOL Copa do Mundo e Eleições com Node js")

## 6. Qual a versão do NodeJS que utilizo?
```
robsonfagundes@R1:~/Personal-Projects/WebSchool.io/be-mean-instagram-mongodb-excercises$ node -v
v5.2.0
```
## 7. Qual a versão do npm que utilizo?
```
robsonfagundes@R1:~/Personal-Projects/WebSchool.io/be-mean-instagram-mongodb-excercises$ npm -v
3.3.12
```


text:
# Node.js - Aula 01 - Exercício
**user:** [PabloDinella](https://github.com/PabloDinella/)
**autor:** Pablo Rocha Dinella
**date:** 1453989977071

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

Um processo síncrono é quando um conjunto de tarefas (funções) são chamadas e são executadas uma por vez, então a próxima tarefa tem que esperar a primeira terminar.

### Exemplo

```
var foo = $.getSync('//foo.com');
var bar = $.getSync('//bar.com');
var qux = $.getSync('//qux.com');

console.log(foo);
console.log(bar);
console.log(qux);
```

Já o processo assíncrono é quando um conjunto de tarefas são executadas, e o stack manda a tarefa para a webapi com um callback, e já executa a próxima sem esperar pela primeira. Quando a webapi termina a tarefa ela manda o callback para o task queue, e daí o event loop pega o callback e manda pro stack (quando este estiver vazio).

### Exemplo

```JavaScript
console.log("Isso");

setTimeout(function(){
	console.log('assíncrono');
}, 5000);

console.log('é');

// Isso
// é
// assíncrono
```

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

O V8 compila o JavaScript para formato nativo de máquina para rodar mais rápido.

![JavaScript](img/javascript.png)

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

O multi-thread cria diversos processos, o single-thread não.

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

A quinta requisição fica numa idle thread até o event loop poder mandar ela pro stack.

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

Apresentaria cases de grandes empresas que migraram para o nodejs.

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

```
╭─owner@Pablos-MacBook-Air  ~/Projetos/be-mean/be-mean-instagram-nodejs ‹›
╰─$ node -v                                                                                v5.5.0
```

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

```
╭─owner@Pablos-MacBook-Air  ~/Projetos/be-mean/be-mean-instagram-nodejs ‹›
╰─$ npm -v
3.3.12
```


text:
# Node.js - Aula 01 - Exercício
**user:** [carlosmachel](https://github.com/carlosmachel)
**autor:** Carlos Machel
**date:** 1457839126351

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

Um processo `assíncrono` no Nodejs é baseado em eventos. a função é chamada junto com um parâmetro de callback (uma função de retorno). Esse processo entra no ciclo do event loop que por sua vez repassa o método para o Thread Pool. E o event loop continua o seu ciclo. Quando o processamento do método asincrono for finalizado a função de callback vai lidar com a informação e retornar para a pilha, sem paralizar o sistema.

O processo `síncrono` vai paralizar o sistema inteiro até ser executado. Seria como as pessoas subindo num carrossel, cada um por vez. E o carrossel tem que parar cada vez.

### Asincrono

- Código

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

console.log("Rodando readFile...");

fs.readFile("index.txt", (error,resultado) => {
            console.log("Conteudo : " + resultado);
});

console.log("Se o método readFile é sincrono eu só vou rodar depois ops! parece que eu rodo antes...");
```

- Resultado

```js
(aula-01) ➜ () ➜ node fsAsync.js
Rodando readFile...
Se o método readFile é sincrono eu só vou rodar depois ops! parece que eu rodo antes...
Conteudo : BE MEAN!
```

### Sincrono

- Código

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

console.log("Rodando readFileSync...");

var resultado = fs.readFileSync("index.txt");
console.log("Conteudo : " + resultado);

console.log("Se o método readFileSync é sincrono eu só vou rodar depois... entendeu?");
```

- Resultado

```js
(aula-01) ➜ () ➜ node fsSync.js
Rodando readFileSync...
Conteudo : BE MEAN!
Se o método readFileSync é sincrono eu só vou rodar depois... entendeu?
```

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

0 V8 é uma engine Javascript escrita em C++. Ele vai compilar o código de JavaScript para o código nativo de máquina implementando um compilador Just-In-Time.
Por baixo dos panos o V8 recebe o código JavaScript e tenta otimizá-lo. A maioria dos compiladores cria uma estrutura tipo dicionario que armazena as propriedades dos objetos e faz uma pesquisa dinamica para resolver a localização da propriedade. Isso acaba sendo lento. No caso do V8 ele cria "hidden classes" em runtime gerando assim uma representação do tipo que aquele objeto representa.

Assim se você cria dois objetos com as mesmas propriedades e com os mesmos nomes, ele vai ser representado pelo V8 como objetos pertencentes a uma classe apenas.

Ai você diz:

- Mas em JavaScript o objeto pode receber propriedades ou deixar de ter propriedades dinamicamente.

Sim o V8 armazena todos os processos de mudanças seguindo uma sequencia. Imaginando uma orientação a objetos seria como se o V8 fizesse uma classe genérica e fosse criando classes filhas dessa com mais especializações.

O V8 tem dois tipos de compiladores, um que compila rapidamente, mas que não gera códigos muito eficientes e um outro que é lento, mas gera códigos eficientes. A engine gera o código não muito eficiente e fica verificando se em algum ponto ocorre um prejuizo, ele coleta a informação daquele ponto e gera uma versão otimizada daquele ponto.

Código em JavaScript:

```js
function g () { return 1; }
function f () {
  var ret = 0;
  for (var i = 1; i < 10000000; i++) {
    ret += g ();
  }
  return ret;
}
```

Um pedaço do código gerado em assembly referente a execução do código acima:

```
133  movq rdx,[rdx+0x27] ;; Another redundant load.
137  cmpl rbx,0x989680   ;; 10000000, you see.
143  jge 178             ;; If i >= 10000000, break.
149  movq rdx,rax        ;; tmp = ret
152  addl rdx,0x1        ;; tmp += 1
155  jo 384              ;; On overflow, deoptimize.
161  addl rbx,0x1        ;; i++
164  movq rax,rdx        ;; ret = tmp
167  cmpq rsp,[r13+0x0]  ;; Reload stack limit.
171  jnc 137             ;; Loop if no interrupt,
173  jmp 306             ;; Otherwise bail out.
178  shlq rax,32         ;; Tag rax as a small integer.
182  movq rsp,rbp        ;; Restore stack pointer.
185  pop rbp             ;; Restore frame pointer.
186  ret 0x8             ;; Return, popping receiver.
```

O.o Assembly.  Mas a ideia aqui é que simplesmente ele está rodando o loop da função f. E está sempre checando pra ver se a função deve ser otimizada ou não. Taggear a função com int32 é uma maneira de identificar qual o tipo pra otimizar.

Esse exemplo foi retirado do texto [what does v8 do with that loop?](http://wingolog.org/archives/2011/06/08/what-does-v8-do-with-that-loop). E sobre tag [value representation in javascript implementations](http://wingolog.org/archives/2011/05/18/value-representation-in-javascript-implementations)

![img](http://www.cs.cmu.edu/~ishafer/compilers/figs/fig_crankshaft.png)

Essa imagem é de um artigo chamado [Instrumenting V8 to Measure the Efficacy of Dynamic Optimizations on Production Code](http://www.cs.cmu.edu/~ishafer/compilers/) que analisou essa otimização do código em runtime.

### Referência

[thibaultlaurens](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?

Um sistema single-thread utiliza apenas uma thread para a aplicação toda, as tarefas são executadas uma por vez. Um sistema multi-thread utiliza várias threads para distribuir as tarefas, executando mais de uma tarefa por vez.

Imaginando um cenário onde você tenha uso intensivo de I/O. Um sistema de uma thread por requisicao (multi-thread) a requisição vai passar a maior parte do tempo esperando esse evento de I/O ser completado. E os recursos do computador associados aquela thread ficam presos. Além de ter o cuidado de sincronizar as threads de maneira que não gere problemas como deadlocks.

Numa estratégia `single thread`  o event loop vai gerenciar e direcionar os eventos. A thread vai receber a requisição e repassar para o thread pool que vai executar a função e depois retornar o `callback` para o ciclo do event loop. Ou seja o Node é single thread, mas possui `worker thread` que vai receber os eventos, esperar a resposta e depois devolver a função de callback dessa forma a thread não fica parada esperando a tarefa terminar.

### Referência

[Codingeek](http://www.codingeek.com/tutorials/nodejs/is-nodejs-single-threaded/)

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

Além de poder alterar o tamanho padrão alterando a variável de ambiente `UV_THREADPOOL_SIZE` para até o máximo de 128. As requisições vão sendo enviadas para cada Thread. Se todas as threads estão ocupadas, as requisições seguintes vão para o `Task Queue` até liberar threads.

### Referência

[How Nodejs's internal threadpool works exactly?](http://stackoverflow.com/questions/29404784/how-nodejss-internal-threadpool-works-exactly)
[libuv](http://docs.libuv.org/en/latest/threadpool.html)

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

Eu geralmente uso casos de sucesso como o do walmart que colocaram na Black Friday todo o seu trafico de mobile  pelo Nodejs que não teve mais que 1% da utilização da CPU com mais de 200 milhoes de usuários online.

E o paypal que dobrou o seu números de requisicoes por segundo e reduziu a resposta em 35%.

Além de que utiliza JavaScript. Utilizar apenas uma linguagem tanto no Frontend quando no Backend é um aumento absurdo de produtividade para a equipe e facilita o trabalho do desenvolvedor.

### Referência

[NodeCrunch](http://www.nearform.com/nodecrunch/node-js-becoming-go-technology-enterprise/)

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

```
(aula-01) ➜ () ➜ node -v
v5.8.0
```
## Qual a versão do seu `npm`?

```
(aula-01) ➜ () ➜ npm -v
3.7.3
```


text:
# NodeJS - Aula 01 - Exercício #

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

**Autor**: Dânio Aparecido Mendonça Filho

**Data**: 1450704879520

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

Um processo síncrono dentro do Node bloqueia a execução de qualquer outro processo enquanto o processo atual não for finalizado.

Exemplo, lendo um arquivo de forma síncrona:

~~~ js
var file = readFile()
processFile(file)
~~~

Já um processo assíncrono não bloqueia nenhum outro processo esperando a resposta do atual, ao invés disso ele continua executando os demais processos e, quando houver uma resposta, ai sim ele continua a execução.

Reescrevendo o mesmo exemplo, mas de forma assíncrona:

~~~ js
var fs = require('fs')
fs.readFile('movie.mp4', finishedReading)

function finishedReading(error, movieData) {
  if (error) return console.error(error)
  // faça algo com os dados em movieData
}
~~~
ref: [Node BR - Callbacks em Node](http://nodebr.com/callbacks-em-node/)

Com isso, enquanto o arquivo movie.mp4 está sendo lido, o Node vai executando os demais processos que vierem na sequência e, quando terminar de ler, o Node é avisado e continua a execução daquele processo.

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

O V8 é um interpretador de Javascript que foi criado pela Google para interpretar códigos em Javascript que fossem executados no Google Chrome. O V8 interpreta o código em Javascript e o converte para linguagem da máquina em que está instalado.

A arquitetura do Node com o V8 funciona da seguinte forma.

![Arquitetura Node](http://daniofilho.github.io/assets/media/nodejs-no-pagarme-75-638.jpg)

Retirado de: [Pedro Franceschi - NodeJS no Pagarme](http://pt.slideshare.net/PedroFranceschi/nodejs-no-pagarme)

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

Um sistema Single thread, como o Node JS, roda em apenas uma thread, ou seja, economiza processamento e memória e ganha performance. Já um sistema Multi Thread cria um processo para cada usuário que se conecta, aumentando significativamente o uso do processador.

Em um Sistema Single Thread, em casos onde os processos não são assíncronos, temos a desvantagem de que aquele processo vai ficar "pindurado" no processador e bloqueando qualquer outro novo processo que queira rodar. Já em Sistemas Multi Threads isso é facilmente corrigido com a criação de uma nova Thread para outro processo.

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

Uma quinta requisição em um banco gera uma task que se chama **Idle Thread*. Esta task é uma thread que vai ficar esperando para ser incluida na fila do Thread Pool e em seguida executada.

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

Primeiramente mostrando grandes cases, como por exemplo o Pay Pal e o Netflix. Com resultados concretos e vindos de empresas do porte dessas, já é um grande item para se chamar a atenção de empresários. Depois disso faria uma análise de performance do sistema atual e levantaria os principais problemas dele, e com base nesses problemas,  mostraria onde o Node poderia entrar para resolve-los. Em seguida para concluir, explicaria as vantagens de agilidade de desenvolvimento que teriamos na migração do sistema.

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

~~~
daniofilho$ node -v
v5.3.0
~~~

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

~~~
daniofilho$ npm -v
3.3.12
~~~


text:
# Node.js - Aula 01 - Exercício
**user:** [pedrohills](http://github.com/pedrohills)
**autor:** Pedro Henrique
**date:** 1454517126551

## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
R- Um processo síncrono no NodeJS segue como um garçom de um restaurante que está atendendo um cliente e ele só atende um segundo cliente caso o primeiro já tenha sido totalmente atendido. Em um processo assíncrono no NodeJS, usando o mesmo exemplo do restaurante, o garçom atende os clientes e seus pedidos são entregues assim que eles estão prontos.

## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O V8 na verdade não executa código JavaScript puro, ele primeiramente compila, em tempo de execução, o código que foi escrito em JavaScript em Código de Máquina. Para isso, ele utiliza um compilador JIT (Just-In-Time).

## Qual a diferença entre um sistema single para um multi-thread?
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.

Em hardwares equipados com uma única CPU, cada thread é processada de forma aparentemente simultânea, pois a mudança entre uma thread e outra é feita de forma tão rápida que para o utilizador, isso está acontecendo paralelamente. Em hardwares com múltiplos CPUs ou multi-cores, as threads são realizadas realmente de forma simultânea.

Os sistemas que suportam uma única thread (em real execução) são chamados de monothread enquanto que os sistemas que suportam múltiplas threads são chamados de multithread.

Fonte: https://pt.wikipedia.org/wiki/Thread_(ci%C3%AAncia_da_computa%C3%A7%C3%A3o)

## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Elas serão incluías na Idle-Thread e ficarão aguardando a Thread Pool liberar espaço para poderem irem para lá.

## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Equipe, ao utilizarmos NodeJS em nossos sistemas estaremos resultando em um menor gasto com equipamentos quando formos trabalhar sua escalabilidade.

Trabalharemos com tecnologia de ponta que atendeu grandes corporações que recebem milhares de requisições por minuto. Tenho a certeza de estarmos preparados para o sucesso e o NodeJS será a ferramenta que nos levará até ele mais rápido.

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


text:
# Node.js - Aula 01 - Exercício
**user:** [gkal19](https://github.com/gkal19)
**autor:** Gabriel Kalani
**date:** 1454162282817

## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
**Processo síncrono** é executado apenas uma função por vez e em um **processo assíncrono**, é possível executar várias funções por vez.

![Exemplo](https://blognti.files.wordpress.com/2010/07/requisicoes1.jpg)

## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
Na aula do Tio Suissa, vemos que o V8 é o motor de JavaScript da Google que possui bibliotecas que ajudam no Gerenciamento dos Processos.
Ou seja ele é como um interpretador do JavaScript.
Seu código é compilado para formato nativo de máquina para rodar mais rápido.

![Exemplo](https://github.com/Webschool-io/be-mean-instagram-nodejs-exercises/blob/master/class-01/img/javascript.png)

## Qual a diferença entre um sistema single para um multi-thread?
No **Single Thread** é executado apenas uma tarefa por vez. Já no **Multi Thread** são executadas varias tarefas simultaneamente.

## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Em casos com este, a quinta requisição irá aguardar a liberação de uma das quatros primeiras.
Apos 1 das quatro ser executada, a quinta requisição é mandada 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?
É simples, só dizer que foi o @suissa que mandou hahaha Brincadeira...
Acredito que a melhor forma seria apresentando `cases` de empresas que migraram para o Node.JS

## Qual a versão do seu `node`?
```
gkal19:~/workspace $ node --version
v4.2.4
```

## Qual a versão do seu `npm`?
```
gkal19:~/workspace $ npm --version
n2.14.12
```


text:
# Node.js - Aula 01 - Exercício
**user:** https://github.com/maurienefirmino
**autor:** Mauriene Firmino do Nascimento Júnior
**date:** Qua Ago 31 10:50:54 BRT 2016

## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Síncrono:
	Cada processo requisitado entra em uma fila, e o processamento só passa para outro quando termina este.
	Neste exemplo vemos um código síncrono, o sistema espera o arquivo ser lido para continuar:

	var fs = require("fs");
	fs.readFileSync(‘arquivo.txt’,function(err,data){
    	if(!err) {
       		console.log(data);
    	}
	});
	console.log("Arquivo Lido com sucesso!");

Assíncrono:
	Varios processo são atendidos ao mesmo tempo e media que vão terminando, mandam uma notificação por meio de um callback.
	Neste exemplo vemos um código assíncrono, o sistema não espera o arquivo ser lido para continuar:

	var fs = require("fs");
	fs.readFile(‘arquivo.txt’,function(err,data){
    	if(!err) {
       	console.log(data);
    	}
	});
	console.log("Arquivo Lido com sucesso!");

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

Ele transforma o código em linguagem nativa da maquina antes de executar.

http://i751.photobucket.com/albums/xx160/logiprats/imageaxd-1.png

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

Um sistema single-thread usa apenas uma unica thread para executar seus processos, o que pode ocasionar travamentos caso um processo tenho que esperar outros processos por exemplo. O multi-thread usa tantas threads forem necessárias. O nodeJS usa single, porém de uma forma otimizada para que não ocorra problemas com frequência.

## 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 ficaria em espera, aguardando um das 4 requisições serem completadas para dar espaço a mesma.

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

Uma boa maneira seria mostrar os dados que já vimos na aula sobre as vantagens do nodeJS, tais como ses exemplos. O nodeJS é mais adequado e rapido do que arquiteturas back-end feitas em JAVA ou PHP, um exemplo disso é o Wordpress(arquitetura em PHP) está se mudando para o nodeJS.

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

```
mauriene@mauriene-J1800NH:~$ node -v
v6.4.0
```

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

```
mauriene@mauriene-J1800NH:~$ npm -v
3.10.3
```


text:
# Node.js - Aula 01 - Exercício
**user:** [lucasduarte](https://github.com/lucasduarte/)
**autor:** Lucas Duarte Anício
**date:** 1457312116944

## **Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.**
No Node.js por padrão todos os processão são assíncronos. Quando ele depende de algum processo externo, como por exemplo ler um arquivo no disco, ele "chama" a execução do processo e continua a executar outras requisições enquanto o arquivo é lido no disco. Somente quando a leitura é finalizada é executado um callback de retorno para o Node.js.

**Processo Síncrono**
```js
function foo(){
    console.log("foo");
}
function bar(){
    console.log("bar");
}
function baz(){
    console.log("baz");
}
foo();
bar();
baz();
```

**Processo Assíncrono**
```js
function foo(){
    console.log("Executando algo assíncrono aqui");
}
function bar(){
    setTimeout(foo, 0);
    console.log("Alguma coisa por aqui");
    console.log("...");
}
bar();
```
## **Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.**
O trabalho desse motor é o de compilar código JavaScript para código nativo de máquina e posteriormente executá-lo.

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

## **Qual a diferença entre um sistema single para um multi-thread?**
Em um sistema multi-thread são executados vários processos diferentes, o que muita das vezes requer uma maior quantidade de memória e processamento, já um sistema single-thread é executado em apenas um processo, diminuindo assim a necessidade de recursos.
## **Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?**
Caso isso aconteça uma das threads ficará aguardando na `Task Queue` aguardando até que uma das outras 4 threads sejam finalizadas e liberem espaço na `Thread Pool`
## **Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?**
Utilizaria como exemplo algum estudo de caso de alguma empresa que trocou recentemente por Node.js. E dessa forma demonstrar para o chefe as melhorias que tiveram com diminuição de recursos do servidor, melhoria no tempo de respostas a requisições e diminuição na carga de trabalho e linhas de código para o desenvolvimento.
## **Qual a versão do seu `node`?**
```
lucas@lucas-pc:~/Dropbox/price_bot$ node -v
v5.6.0
```
## **Qual a versão do seu `npm`?**
```
lucas@lucas-pc:~/Dropbox/price_bot$ npm -v
3.6.0
```


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

**user:** [joseasousa](https://github.com/joseasousa/)
**autor:** Jose Alves De Sousa Neto

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

Processos síncronos são processos que executam um passo por vez, um processo só ira começar assim que o anterior for terminado

```js

    for(int i = 0; i<1000; i++){
        console.log(i);
    }
```

Processos assíncronos não dependem do termino do processo anterior, então eles seguem executando, e quando
 uma requisição é terminada ela volta e executa uma fução de resposta(callback)
```js

     Contatos.find().exec()
      .then(
        function (contatos) {
          res.json(contatos);
        },
        function (erro) {
          res.status(500).json(erro);
        }
    );
```

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

V8 que é o motor de JavaScript da Google e que roda no seu Chrome, além disso ele conta
 com outras bibliotecas que o auxiliam no gerenciamento dos processos.

 Ele é nada menos que o interpretador de JavaScript, tipo uma máquina virtual,
 desenvolvido pelo Google e usado no Chrome. Feito em C++ e open-source.

O trabalho dele é basicamente compilar o código de JavaScript para o código nativo de
máquina para depois executá-lo.

Ele levou a velocidade dos códigos compilados para o JavaScript.

 ![node](https://pbs.twimg.com/media/Bt5ywJrIEAAKJQt.jpg)

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

Um Sistema single thread possui apenas um processo (Thread) rodando por vez.

Em Sistemas multi-threads a 2 ou mais 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?

Executaram 4 e uma ira ficar experando pelomenos uma delas terminar, para assim poder executar

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

Mostrando users cases como o do [PayPal](https://www.paypal-engineering.com/2013/11/22/node-js-at-paypal/), demonstrando os ganhos de perfomace e produtividade

## 6- Qual a versão do seu `node`?
v7.2.0
## 7- Qual a versão do seu `npm`?
3.10.9


text:
# Node.js - Aula 01 - Exercício
**user:** [xereda](https://github.com/xereda)
**autor:** Jackson Ricardo Schroeder
**date:** 1464838528755

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

Um processo **síncrono** sofre execução linear e logicamente sequencial, sendo que a próxima iteração somente é executada após a efetiva conclusão da rotina anterior. Trazendo para o mundo real, é como se fossemos levar nossos filhos ao colégio e após deixá-los, no lugar de continuarmos com nossa vida normal, ficassemos os esperando até a aula terminar, lá parados, durante 4 longas horas. Estariamos adotando um processo síncrono de levar e buscar nossos filhos. Durante esse intervalo, nada mais por nós seria feito.

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

```js

// criamos um arquivo com o nome "sincrono.js" e com a seguinte estrutura interna
var fs = require("fs");
var data = fs.readFileSync('/tmp/exemplo.txt');
console.log(data.toString());
console.log("Encerrado!");

// depois no console do sistema operacional,
// executamos o node passando como parametro o script "sincrono.js" criado acima
node sincrono.js
Este eh o conteudo do arquivo txt.
Encerrado!

```
_Você pode observar que o javascript aguardou o leitura do arquivo, depois a conversão para string e somente após esses dois processos ele foi para a próxima iteração que é a impressão, no console, do texto `"Encerrado!"`._

Já uma rotina **assíncrona** é enviada para o _Event Loop_ do NodeJS e o script principal segue sendo executado normalmente. Reutilizando o exemplo no mundo real citado acima, com um processo assíncrono, deixamos nossos filhos no colégio, mas continuamos com nossa vida normal, como por exemplo, indo trabalhar. Durante as 4 horas que nossos filhos estão na escola, podemos realizar outras atividades, preocupando-nos em buscá-los somente no horário de encerramento das aulas.

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

EX:

```js

// criamos outro arquivo, agora chamado de "assincrono.js", com as seguintes linhas internas
var fs = require("fs");
fs.readFile('exemplo.txt', function (err, data) {
    if (err) return console.error(err);
    console.log(data.toString());
});
console.log("Encerrado!");

// agora executamos o node passando como parâmetro este novo script
node assincrono.js
Encerrado!
Este eh o conteudo do arquivo txt.

```

_Observe que agora a string "Encerrado!" veio por primeiro, ignorando a execução pendente anterior. Isso ocorreu, pois executamos a função fs.readFile() de forma assíncrona. A leitura do arquivo exemplo.txt foi enviada para a fila Event Loop, mas a execução do próxima rotina, ou seja, a impressão da string "Encerrado!" foi muito mais rápida._

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

V8 é um motor javascript, desenvolvido pela Google e open source, de alta performance e escrito em linguagem C++. É o motor de javascript padrão do navegador Google Chrome. Ele implementa ECMAScript e pode ser executado nos sistema operacionais Windows, MAC OS X e em diferentes distribuições Linux. O V8 pode ser utilizado de forma independente ou ainda ser incorporado em aplicações C++.

![V8 Javascript Engine e nodeJS](img/v8_xereda.jpg)

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

Um sistema single thread, tem em suas rotinas, uma execução baseada em um único agente de processamento.

Já em sistemas multi thread, para cada requisição de processamento, um novo agenda é consumido para tal finalidade.

No caso do nodeJS, seu single thread é mantida baseando-se numa fila chamada "Event Loop" e esta tem como principal caracaterística ser non-blocking (sem bloqueio de execução) e assíncrona. Tanto o event loop como o tread pool são mantidos pela [Libuv](http://libuv.org/). **Libuv** é uma biblioteca com suporte a multi-platormas e com foco em I/O assíncrono.

## 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 aguardará, na _Event Queue_ (fila de eventos da Libuv), até que uma das 4 requisições que estão consumindo as _Thread Pool_ disponíveis encerre sua rotina de execução. Embora, por padrão, o nodeJS defina 4 tread pools disponíveis, este número pode ser incrementado em até 128 threads (variável de ambiente UV_THREADPOOL_SIZE), inclusive em tempo de execução com o parâmetro `process.env.UV_THREADPOOL_SIZE`.

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

Inicialmente faria um comparativo entre o nodeJS e outros principais servidores de aplicação do mercado, enfatizando as vantagens de adoção. Ressaltaria suas principais caractéricas, como baixo consumo de recursos físicos e a fácil e ampla possibilidade de escalabilidade. Finalizaria citando as principais empresas que usam o nodeJS e focaria num case de sucesso, como por exemplo o caso do Paypal, ou ainda, o da NetFlix.

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

```
xereda@macminixereda:~$ node -v
v6.2.0

```

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

```

xereda@macminixereda:~$ npm -v
3.8.9

```


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

## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Vamos supor que você tem 1000 conexões ao vivo, e um pacote é entrego  a cada milissegundo, e o processamento de cada pacote leva 1 microssegundo. Vamos supor também que cada conexão envia 5 pacotes.

Em um aplicativo single-thread síncrono, cada ligação será tratada em série. O tempo total necessário é (5 + 5 * 1 * 0.001) * 1000 milissegundos, ou ~ 5005 milissegundos.

Em um aplicativo single-thread, assíncrono, cada ligação será tratada em paralelo. Uma vez que cada pacote leva um milésimo de segundo, e processamento de cada pacote leva 0.001 milissegundos, podemos processar pacote de cada ligação entre os pacotes, então a nossa fórmula torna-se: (1000 * 001 * 1) + 5 milissegundos, ou ~ 6 milissegundos.
## Como o V8 executa JavaScript? Demonstre 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)
## 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.

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

## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
> * Com Node.js iríamos trabalhar com javascript no server-side utilizando o Google v8. Assim seria mais fácil manter um projeto de fácil manutenção visto que será a mesma linguagem JavaScript no client-side.
> * Comunidade ativa.
> * Orientado a evento - I/O não bloqueante.
> * Event Loop
> * LinkedIn, Wallmart, Groupon, Microsoft e Paypal são algumas das empresas usando Node.js.

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

    v5.2.0

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

    3.3.12


text:
# NodeJS - Aula 01 - Exercício

**User**: [@marcelohmdias](https://github.com/marcelohmdias)
**Autor**: Marcelo H M Dias
**Date**: Sun Dec 13 2015 21:35:35 GMT-0200 (BRST)

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

- **Síncrono**: Em NodeJS, os processos sincronos são bloqueantes, ou seja, caso exista uma lista de processos a serem executados, o nodejs aguarda o termino do anterior para executar o próximo.

```js
//text_sync.js
var fs = require( 'fs' );

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

//Exemplo retirado do livro - Aplicação web real-time com Node.js - Caio Ribeiro Pereira
```

- **Assíncrono**: Os processos assíncronos por outro lado, realizam os processos de forma paralela.

```js
//text_async.js
var fs = require( 'fs' );

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

//Exemplo retirado do livro - Aplicação web real-time com Node.js - Caio Ribeiro Pereira
```

Se compararmos os dois códigos, podemos ver a diferença na *timeline* de execução de ambos. Enquanto o primeiro levou 1000 milissegundos para executar, o segundo código levou um quinto deste tempo (200 milissegundos). Isso nos mostra as vantagens em relação ao desempenho do nodeJS ao utilizar processos não bloqueantes.

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

O V8 é o motor de renderização do NodeJS, ou seja, ele realiza um bind do código JS para C++, convertendo todo o nosso código para funções do próprio V8. Isso permite a posterior conversão deste código para linguagem de máquina.

![Motor V8](https://github.com/marcelohmdias/curso-be-mean/blob/master/nodejs/_file/v8.jpg)

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

Thread é o fluxo de execução de um processo. Em sistemas sigle threads, existe apenas um fluxo de execução, dessa maneira, os processos são executados em filas, um por vez. Já em sistemas multi threads, existe mais de uma fila de execução dos processos. Em cada fila os processos ainda são executados um por vez, porém com mais filas os processos podem ser executados de forma simultânea.

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

Devido ao fato da Libuv possuir este valor em default a quinta requisição deve aguardar a liberação para a execução.

Porém é possível aumentar o tamanho limite da Thread Pool (até um máximo de 128), alterando o valor da variável de ambiente UV_THREADPOOL_SIZE, o que também exigira um uso maior de mémoria para a execução da aplicação.

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

Para alterarar uma tecnologia adotada em uma empresa, não basta apenas apresentar o que determinada linguagem possui de bom, é necessário realizar um comparativo entre ambas as opções, além de, estudos de Benchmarking (processo ou técnica de gestão através do qual as empresas ou organizações avaliam o desempenho dos seus processos, sistemas e procedimentos de gestão comparando-o com os melhores desempenhos encontrados noutras organizações).

Levando isso em consideração, é possível determinar alguns pontos:

- Demonstrar as principais características do NodeJS e o que elas impactariam nos processos da empresa;
- Apresentar cases em que o Node foi adotado e tornou o fluxo de trabalho mais produtivo;
- Buscar possíveis soluções e alternativas (bibliotecas e frameworks) para atender as demandas da empresa.

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

```bash
marcelohmidas :: ~/ » node -v
	v5.1.1
marcelohmidas :: ~/ »
```

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

```bash
marcelohmidas :: ~/ » node -v
	3.3.12
marcelohmidas :: ~/ »
```


text:
# Node.js - Aula 01 - Exercício
**user:** [Cerezini](https://github.com/Cerezini)
**autor:** Mateus Cerezini Gomes
**date:** 1457365864582

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

Um processo síncrono é executado comando a comando, logo o comando 2 só pode ser executado quando o comando 1 for concluído. Ex:

```js
function init() {
    var html = getHTML();
    var css = getCSS();     //Só executará quando getHTML() finalizar
    var js = getJS();       //Só executará quando getCSS() finalizar
}
```

Um processo assíncrono é executado sem que um comando possa bloquear outro, logo o comando 2 pode ser executado sem que o comando 1 tenha concluído. Ex:

```js
function init() {
    getHTML(setHTML());
    getCSS(setCSS());     //Executará após getHTML() independente se ele finalizou
    getJS(setJS());       //Executará após getCSS() independente se ele finalizou
}
```

Em geral, uma função assíncrona recebe como parâmetro uma função chamada de callback, que será executada quando a função assíncrona for concluída.

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

O V8 é um motor JavaScript escrito em C++ que compila e executa códigos JavaScript, gerando códigos de máquina mais eficientes que um interpretador. Ele compila o código
Javascript durante a execução, não produzindo qualquer código intermediário.

O Javascript é uma linguagem de tipagem dinâmica e não existem classes, logo o V8 cria **hidden classes** para representar os tipos e ter uma forma eficiente de acesso às
propriedades, diferente de outras engines que criam uma estrutura semelhante a um dicionário. Se o layout dessa **hidden class** for semelhante em diferentes objetos, o V8
pode agrupar estes objetos e reutilizar o código. Caso uma propriedade seja adicionada ao objeto depois que ele já foi criado, o V8 criará uma nova **hidden class**.

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

var p1 = new Point(11, 22);
var p2 = new Point(33, 44);
// Neste ponto p1 e p2 compartilham a mesma hidden class
p2.z = 55;
// P1 e p2 possuem diferentes hidden classes
```

V8 também possui eficientes sistemas de geração de código de máquina dinâmico e coletor de lixo. O coletor de lixo interrompe a execução dos programas para sua execução,
processa somente parte da *memória heap* dos objetos o que minimiza o impacto na execução da aplicação, e o V8 sempre tem conhecimento da localização em memória dos objetos
e ponteiros o que evita problemas de vazamento de memória.

Os objetos possuem a *memória heap* divida em duas partes, uma parte para criação de novos objetos, e a outra parte onde ficam os objetos que permanecem após a execução
do coletor de lixo. Se o objeto criado sobrevive ao coletor de lixo, ele é promovido a outra parte da *heap* e o V8 atualiza todos os ponteiros que o referenciam.

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

Um sistema single thread é um processo que executa comando a comando de maneira síncrona. Um sistema multi-thread por sua vez é um processo que divide
sua execução em diferentes threads que executam paralelamente, se o processador possuir mais de um núcleo.

Um sistema multi-thread permite um melhor uso do processador e uma computação mais rápida. Entretanto, o gerenciamento das threads e as trocas de contexto
exigem maior consumo de recursos de memória e computação.

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

As requisições de acesso ao banco serão colocadas numa fila de espera. Como o tamanho da thread pool é 4, se todas estiverem disponíveis, as 4 primeiras requisições
presentes na fila de espera receberão uma thread cada e serão executas, e a 5º aguardará até que uma das threads conclua e esteja novamente disponível.

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

Os sistemas web na sua maioria trabalham com multi-thread, criando uma nova thread para cada requisição, logo quando o número de requisições é maior que o
número de threads disponíveis, essas requisições ficarão numa fila de espera. A execução de uma thread pode levar um longo tempo caso ela tenha que esperar por
algum recurso, como acessar o disco rígido ou a rede, logo maior será o tempo de espera das requisições aguardando pela liberação das threads. A criação e gerenciamento
das threads demanda consumo extra de processamento (CPU) e memória.

O NodeJS utiliza um sistema single thread com event loop, dessa forma consegue escalar de maneira eficiente com o aumento de requisições, consumindo menos recursos do
sistema. Esta eficiência combinada com outros benefícios da linguagem e arquitetura tem feito com que grandes sites/sistemas webs adotem o NodeJs, como: PayPal, Netflix,
New York Times, Uber, Linkdin, além de muitas outras como pode ser checado [aqui](https://github.com/nodejs/node-v0.x-archive/wiki/Projects,-Applications,-and-Companies-Using-Node)

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

```js
>node -v
v5.7.1
```

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

```js
>npm -v
3.6.0
```


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

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

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

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

## Qual a diferença entre um sistema single para um multi-thread?
O single thread como o nome ja diz utiliza um único segmento para executar os processos, ou seja, executa um de cada vez. Já o multi-thread como o nome também descreve, é capaz de ter mais de um segmento sendo capaz de executar alguns processos simultaneamente, porém quanto mais segmentos, mais recursos serão utilizados.

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

## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Explicando que é uma maneira mais fácil, rápida e melhor para o desenvolvimento e mostrando o seu potencial citando algumas empresas que estão utilizando o Nodejs.

## Qual a versão do seu `node`?
➜  NODE_JS git:(master) ✗ node -v
v6.0.0

## Qual a versão do seu `npm`?
➜  NODE_JS git:(master) ✗ npm -v
3.8.6


text:
# Node.js - Aula 01 - Exercício
**user:** gpanassol
**autor:** Gabriel Panassol
**date:**  1449708572443

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

Por padrão qualquer função é assíncrona por esse motivo é necessário uma função que executará após a finalização do processo. Esse função é chamada de callback. Já os processos síncronos não espera seu processo finalizar podendo assim a função continuar com a execução do script. Esse processo continua executando paralelamente.

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

Como vimos na aula e slides o V8 nada mais é que um interpretador de javascript. Ele é como uma JVM do Java. O V8 é usado no Goole Chrome. Foi criado em C++ e é open-source.
No site Developers Google podemos ver um exemplo de como um Hello Word é executado. Veja:

```
// Copyright 2015 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "include/libplatform/libplatform.h"
#include "include/v8.h"

using namespace v8;

class ArrayBufferAllocator : public v8::ArrayBuffer::Allocator {
 public:
  virtual void* Allocate(size_t length) {
    void* data = AllocateUninitialized(length);
    return data == NULL ? data : memset(data, 0, length);
  }
  virtual void* AllocateUninitialized(size_t length) { return malloc(length); }
  virtual void Free(void* data, size_t) { free(data); }
};

int main(int argc, char* argv[]) {
  // Initialize V8.
  V8::InitializeICU();
  V8::InitializeExternalStartupData(argv[0]);
  Platform* platform = platform::CreateDefaultPlatform();
  V8::InitializePlatform(platform);
  V8::Initialize();

  // Create a new Isolate and make it the current one.
  ArrayBufferAllocator allocator;
  Isolate::CreateParams create_params;
  create_params.array_buffer_allocator = &allocator;
  Isolate* isolate = Isolate::New(create_params);
  {
    Isolate::Scope isolate_scope(isolate);

    // Create a stack-allocated handle scope.
    HandleScope handle_scope(isolate);

    // Create a new context.
    Local<Context> context = Context::New(isolate);

    // Enter the context for compiling and running the hello world script.
    Context::Scope context_scope(context);

    // Create a string containing the JavaScript source code.
    Local<String> source =
        String::NewFromUtf8(isolate, "'Hello' + ', World!'",
                            NewStringType::kNormal).ToLocalChecked();

    // Compile the source code.
    Local<Script> script = Script::Compile(context, source).ToLocalChecked();

    // Run the script to get the result.
    Local<Value> result = script->Run(context).ToLocalChecked();

    // Convert the result to an UTF8 string and print it.
    String::Utf8Value utf8(result);
    printf("%s\n", *utf8);
  }

  // Dispose the isolate and tear down V8.
  isolate->Dispose();
  V8::Dispose();
  V8::ShutdownPlatform();
  delete platform;
  return 0;
}
```

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

O Node.js trabalha apenas com uma theard, podendo ser criada outras. Ele é um exemplo claro de um sistema single. Devido o fato dele trabalha com um numero menor de thread suas performance é superior ao sistemas multi-thread. O Node possui um sistema chamado Event Loop que gerencia todas as requisições evitando assim a criação de diversas thread.
Um sistema multi-thread como o próprio nome diz ele trabalha com diversas threads como o apache que cria diversas threads ao longo do seus processo tendo problema de alocação de memória e com isso lentidão no sistema.

## 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 ficará na minha Task Queue e após o ciclo "libera um espaço" ele passa para o meu Thread Pool e consequentemente para o Completed Tasks.

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

O Node.js é muito mais performatico e eu consigo criar um sistema com menos pessoas. Podemos usar o case da PayPal que conseguiu diminuir 30% o número de código e 40% menos arquivos. Ele conseguiu diminuir em 35% a requisição das paginas de testes.

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

```
Gabriel@gabriel MINGW64 ~
$ node -v
v5.0.0
```

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

```
Gabriel@gabriel MINGW64 ~
$ npm -v
3.3.6
```


text:
# Node.js - Aula 01 - Exercício
**user:** [felipelopesrita](https://github.com/felipelopesrita)
**autor:** Felipe José Lopes Rita
**date:** 1455900905381

## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Processos síncronos são processos que seguem uma sincronia, isso é, processos que seguem uma order de execução e que realiza outro processo apenas após o término de um processo. Isso significa que cria-se uma espécie de fila de execução de processos, o que além de consumir uma memórica considerável, pode ocasionar lentidão na execução e resposta, uma vez que funções podem demorar a serem executadas.
Como exemplo de função síncrona, temos:
```js
// Faz a leitura do arquivo e escreve no console de maneira sequencial
var oi = fs.readFileSync('./oi.txt', 'utf8');
console.log(oi);
```
Funções assíncronas, por sua vez, executam processos simultaneamente, executando funções e processos paralelos ao mesmo tempo. Isso significa que numa fila com 4 processos a serem executados, por exemplo, meu motor executaria os 4 processos ao mesmo tempo, o que garante uma agilidade redução do consumo da memória.
Como os processos são rodados em paralelo, para definir o que será feito depois que o processo é concluído, utilizam-se callbacks, ou seja, funções que fazem alguma coisa depois que o processo terminou.
Abaixo, segue um exemplo que função assíncrona em javascript:
```js
/* Define um callback  a ser executado depois que a função é executada */
fs.readFile('./oi.txt', (err, result) => {
  // Caso ocorra algum erro escreve ele no console
  if (err) console.log(err);
  console.log(result.toString());
});

```

## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O V8 é um motor desenvolvido pelo Google e também utilizado no Chrome que interpreta códigos de javascript e os compila para códigos nativos da máquina (instruções e comandos) para só depois executá-los.
Open source e escrito em C++, é um dos principais fatores que possibilitam a existência do Node.Js
Como demonstra a imagem abaixo, o V8 é responsável pelo eventloop, trabalhando de forma assíncrona e traduzindo o código javascript para as threads.
!['Imagem V8'](http://blog.gopivotal.com/wp-content/uploads/2012/04/NodeJS-EventedIOAsyncIO_latest.png)

## Qual a diferença entre um sistema single para um multi-thread?
Em aplicações multi-thread, diversas threads são criadas para cada processo que deseja-se executar, o que demanda considerável quantidade de memória e processamento. Visando agilizar e reduzir o consume de memória, foram criadas as aplicações single thread, que utilizam apenas uma thread para executar seus processos de maneira assíncrona.

## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Antes de serem enviadas à Thread Pool, as requisições ficam "presas" em um event-loop. Com isso, dado esse exemplo, enquanto as 4 requisições são executadas na Thread Pool, a requisição restante aguarda no event loop até que um "espaço" seja liberado para que sua requisição possa ser atendida.

## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Acredito que a principal maneira de convencer um chefe é apresentando números e casos distintos sobre empresas que utilizam node em seus sistemas (como Netflix e Paypal, citados na aula), além de gráficos comparativos com as linguagens utilizadas na empresa em que me encontro.

## Qual a versão do seu `node`?
`v5.5.0 `
## Qual a versão do seu `npm`?
`3.6.0`


text:
# Node.js - Aula 01 - Exercício
**user:** [filipe1309](https://github.com/filipe1309)
**autor:** Filipe Leuch Bonfim
**date:** 1455935357730

## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
O Node utiliza um mecanismo interno chamado **Event Loop**, que é a parte responsável pela característica de I/O assíncrono do Node. Mas nem sempre é desejado que uma determinada tarefa seja executada de forma assíncrona. Por isso existem diversas funções nativas do Node que possuem uma contra-parte síncrona da mesma.

### processo síncrono
Quando um processo síncrono ocorre, o próximo processo terá de esperar o atual terminar, para poder então ser executado.
```js
console.log(“Olá ”);
var fs = require('fs');
fs.readFileSync('/etc/passwd');
console.log(“Arquivo lido!”);
console.log(“mundo!!!”);

// Saída
Olá
Arquivo lido!
mundo!!!
```

### processo assíncrono
Neste caso, quando um processo é executado, o próximo já pode ser executado em seguida, não necessitando esperar o atual terminar. Desta maneira, os processos terminam não necessariamente de forma linear. Assim que um processo termina, ele executa a sua respectiva função de ``callback`` , que foi passada como parâmetro.
```js
console.log(“Olá ”);
var fs = require('fs');
fs.readFile('/etc/passwd', (err, data) => {
  if (err) throw err;
  console.log(“Arquivo lido!”);
});
console.log(“mundo!!!”);

// Saída
Olá mundo!!!
Arquivo lido!
```

## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O V8 interpreta o código JavaScript, e o converte em linguagem de máquina para que o mesmo possa ser executado.

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

Fora isto existem diversos mecanismos que foram implementados no V8 com o intuito de melhorar a *performance*, como é o caso das **hidden classes**, que são classes ocultas, contendo otimizações de código, criadas internamente para os objetos em tempo de execução, e podem ser compartilhadas entre vários objetos com a mesma estrutura.

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

#### Single-Thread
Um sistema *single-threaded* roda em apenas um processo no sistema operacional.

Geralmente sistemas deste tipo são mais fáceis de programar e debugar, além de terem um menor **overhead** (carga, em português) de processamento em comparação a outro *multi-threaded*, pois realizam menos trocas de contexto para executar o mesmo sistema.

#### Multi-Thread
Um sistema *multi-threaded* roda em vários processos no sistema operacional.

Neste tipo de sistema há um ganho de performance, se este for executado em uma máquina com múltiplos núcleos, pois cada thread pode ser executada em um núcleo diferente, ou seja, de maneira paralela.

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

Neste caso, uma das requisições ficará em uma fila de requisições, aguardando terminar a primeira das 4 requisições, que conseguiram entrar na `Thread Pool`.

Mas este limite de quantidade de `threads` pode ser alterado, através da variável de ambiente UV_THREADPOOL_SIZE, bantando alterar seu valor antes que a `Thread Pool` seja criada e utilizada.

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

Primeiramente eu destacaria o Ganho de performance, com alguns exemplos, apresentando isto em números, e depois mostraria algum caso de uso (como o do Paypal), e destacaria as empresas que já adotam esta tecnologia, como por exemplo Netflix, Linkedin, Soundcloud, Uber, Cloud9, Yahoo, Microsoft, Trello, Pagar.me, Walmart, Rdio, etc.

Então, abordaria que o foco das aplicações desenvolvidas com Node.js é de obter alta concorrência, alta escalabilidade e de criar aplicações `real-time`. E que no Node.js o
Backend e Frontend possuem mesma linguagem, permitindo uma integração total do sistema, e facilitando o desenvolvimento.

E por fim, faria um comparativo entre as linguagens já adotas na empresa, com o Node.js, apontando as vantagens e desvantagens entre estas tecnologias.

## Qual a versão do seu `node`?
```
node -v
v5.4.0
```
## Qual a versão do seu `npm`?
```
npm -v
3.3.12
```


text:
# Node.js - Aula 01 - Exercício
**user:** [hc3](https://github.com/hc3)
**autor:** Eliel das Virgens
**date:** 20/03/2016

##01.Explique como um processo síncrono e assíncrono roda no Node.js e dê uma exemplo
para cada .
-O processo síncrono ele aguarda o fim do processo para poder iniciar outro processo , enquanto
o processo assíncrono não ele consegue receber outras requisiçoes e quando terminar ele chama um callback e com isso temos uma alta escalabilidade com Node.js

##02.como o v8 executa javascript? demonstre 1 exemplo com código ou imagem.
-Quando fazemos uma chamada de função ela entra no event loop já registra um callback que interage com o servidor e quando a operação está completa o event loop retorna o callback para a
função que o chamou.

##03.qual a diferença entre um sistema single para um multi-thread
-um sistema single thread tem apenas uma thread que quando é feita uma solicição fica bloqueada
até que a tarefa que a thread está executando termine para que seja feita outra solicitaçãço
o multi thread depois de feita uma solicitação pode-se fazer outra sendo assim criada uma nova thread.

##04.como a thread pool tem um tamanho padrão de 4 , o que acontece se você enviar 5 requisições ao banco.
-a quinta requisição fica aguardando alguma das 4 terminarem.

##05.como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção
-explicaria os benefícios iria começar com projetos pequenos , mostrar como a comunidade está inclinada ao javascript , dar exemplos de grandes coorporaçoes que adotaram a tecnologia.

##06.qual a versão do seu node?
```
hc3@darkSide:~/Bemean/Repositorios/be-mean-instagram-nodejs-exercises/class-01$ node -v
v5.6.0
```
##07.qual a versão do seu npm?
```
hc3@darkSide:~/Bemean/Repositorios/be-mean-instagram-nodejs-exercises/class-01$ npm -v
3.6.0
```