<repo_name>Lucas-Souza-Santos/Avanade<file_sep>/Introducao_JavaScript/JavaScript_ES6_essicial/script/Aula04-Parte1/1-array.js
// Criação de um array
const arr1 = [1, 2, 3]
const arr2 = new Array(1, 2, 4);
const arr3 = Array.of(1, 2, 5);

console.log(`Array1 = (${arr1}) Array2 = (${arr2}) Array3 = (${arr3})`)

const arr4 = Array(3);

const arr5 = Array(3, 2);

const divs = document.querySelectorAll('div');

const arr = Array.from(divs);

const cafaDaManha = ['Frutas', 'cafe puro', 'pão', 'mateiga'];
const almoco = ['feijão', 'arroz', 'carne'];

const refeicoes1 = cafaDaManha.concat(almoco);
const refeicoes2 = almoco.concat(cafaDaManha);

arr1.push(4, 5);

// forEach
arr1.forEach((value, index) => {
    console.log(`${index + 1}º = ${value}`);
});

// map
console.log(arr1.map(value => value * 2));

console.log(arr1);

// flat
const novo_array = [56, 78, [34, 57], [90, 98, 100]];
console.log(novo_array);
console.log(novo_array.flat());

// flatMap
console.log(novo_array.flatMap(value => [value * 2]));

// keys
const arrIterator = arr1.keys();

console.log("Keys: ")
console.log(arrIterator.next());
console.log(arrIterator.next());
console.log(arrIterator.next());
console.log(arrIterator.next());
console.log(arrIterator.next());
console.log(arrIterator.next());

// values 
const arrInterator2 = arr1.values();

console.log("valores: ");
console.log(arrInterator2.next());
console.log(arrInterator2.next());
console.log(arrInterator2.next());
console.log(arrInterator2.next());
console.log(arrInterator2.next());
console.log(arrInterator2.next());

// entries
const arrInterator3 = arr1.entries();

console.log("Entries: ");

console.log(arrInterator3.next());
console.log(arrInterator3.next());
console.log(arrInterator3.next());
console.log(arrInterator3.next());
console.log(arrInterator3.next());
console.log(arrInterator3.next());

// find
const firstGreaterThanTwo = arr1.find(value => value > 2);

console.log("Find: ");

console.log(firstGreaterThanTwo);

// findIndex
const firstIndexGreaterThanTwo = arr1.findIndex(value => value > 2);

console.log("Index: ");
console.log(firstIndexGreaterThanTwo + 1);

// filter
const allValuesGreaterThanTwo = arr1.filter(value => value % 2 === 0);

console.log("Retorna Array sobre um condição: ");
console.log(allValuesGreaterThanTwo)

// indexOf
const firstIndexOfItem = arr1.indexOf(3);

console.log("IndexOf: ");
console.log(firstIndexOfItem);

// lastIndexOf

const lastIndexOfItem = arr1.lastIndexOf(3);

console.log("lastIndexOf: ");
console.log(lastIndexOfItem);

// includes
const hasItemOne = arr1.includes(1);
const hasItem1000 = arr1.includes(1000);

console.log("includes: ");
console.log(hasItemOne);
console.log(hasItem1000);

// some
const hasSomeEvenNumber = arr1.some(v => v % 2 === 0)

console.log("some: ");
console.log(hasSomeEvenNumber);

// every
const allEvenNumbers = arr1.every(value => value % 2 === 0);

console.log("every: ");
console.log(allEvenNumbers);

// sort

const sortValues = arr1.sort();

console.log("Sort: ");
console.log(sortValues);

// reverse
const reverteValues = arr1.reverse();

console.log("reverte: ");
console.log(arr1);

// join
const joinValue = arr1.join('-');

console.log("join: ");
console.log(joinValue);

// reduce 
const reduceValue = arr1.reduce((total, value) => total += value, 0);

console.log("reduce: ");
console.log(reduceValue);
<file_sep>/Arquitetura_Sistema/Aula04/2-parte.md
## Banco de Dados Relacional
    * SGDBR(br) - RDBMS(en) sistema que gerenciam esse tipo
    de arquitetura.
    * Composto de entidade que agrupa nossas informações
    * Tabela
    * Linha - Registro - Tupla
    * Coluna - Definição o que significa cada informação
    * chaves 
        -> primary keys
        -> for in keys cria nosso relacionamento

### Modelo
    * Modelo conceitual - MER
    * Modelo Lógico - Implementação
    
    O MER pode ser representar por um DER: que é o nosso 
    diagrama de entidade de relacionamento. Esse diagrama 
    facilita a compreensão de como o modelo deve se comportar 
    e também podemos aplicar conceitos de normalização. O DER,
    ele é um diagrama grafico, aonde podemos representar as 
    nossas entidade como o nome, o relacionamento e também 
    possui cliente que é uma outra entidade. O relacionamento
    se dar de uma forma direta ou indireta, nossa entidade 
    tem um força de existência.
#### Entidade
        -> Entidade Forte não dependente de nenhuma outra 
        informação para existir
        -> Entidade fraca que depende de outra informação para
        existir
####  Relacionamento
    Produto M(1...N) |------ venda -------|N(0...N) Venda
    Da direita para esquerda dizemos que Venda possui 1 ou N
    Produtos
    Da esquerda para a direita dizemos que Produto tem 0 ou N
    Venda.
    Cliente 1(1...1) |------- Possui -----| N(0...N)

    Uma relação do tipo M para N é uma relação associativa.
##### entidade item

    Associativa é preciso criar uma nova entidade, que será 
    chamada de entidade associativa
    Vai possuir uma chave estrangeira da entidade Produto e 
    uma estrangeira da entidade Venda.

    Ter uma nova entidade no meio vai resultar em um novo 
    relacionamento entre eles.

## Normalização
    * 1 ... 5 - Forma normal
    * 1,2 e 3 - Mais comum
    para ajeitar um cadastro que errei é criando uma nova 
    tabela, ou uma nova coluna.
<file_sep>/Projeto_Netflix/ANOTACOES/Aula.md
# NETFLIX CLONE

    - Tudo no html5 é feito com divs

## Tags Semânica 
    - Header
    - Futter
    - Aside
    Elas são como se fosse divs caixas

    Dentro do header vamos definicar nosso menu de 
    navegação ou navbar, além como nosso navbar 
    teremos um texto que servirar como log

    o html não cuida da formação e sim o css.

    cada navegador joga um valor de padding e margin e isso não 
    pode ser padronizado

    resert css vai usar o * e colocar
        - margin = 0 
        - padding = 0
        - box-sizing = border-box
            pq: Se a gente colocar um contéudo maior que o tamanho da 
            caixa, esse elemento vai esborrar e não é isso que queremos
            Por isso colocamos o box-sizing: border-box, para que tudo 
            fique no tamanho da caixa.

    Como declarar uma variável
        - tem que declarada dentro do elemento raiz ou root

    displex tipo flex tende a jogar todos os elementos 
    para a linha

    classe wrappe(envelope) ela guarda várias outros 
    elementos. 
        - fica mais fácil manipular elementos filhos
        - 

    Para quem deseja continuar
        - ter um objetivo claro aonde quer chegar
        - Desafios: 
            -> Dar vida aos botões
            -> Criar uma nova página para outro contéudo
            -> Colocar algo que não está dentro do projeto 
            -> linkedin.com/in/felipe-aguiar-047/

<file_sep>/Introducao_JavaScript/JavaScript_ES6_essicial/Anotaçoes/Aula01.md
# Introdução Ao JavaScript

## História e Conceitos
### Historico
    * Lançado em setembro de 1995
    * Criado por <NAME>
    * ECMAScript - É uma especificação da linguagem de programaçao, que é
    padronizada pela ECMA62, da ECMA International. Serve como base para 
    implementação de outras linguagem script.
        - JavaScript
        - JScript
        - ActionScript
    * TC39 - Comitê que cuida da evolução da linguagem
        - https://github.com/tc39
        - https://github.com/tc39/proposals
    * Fluxo de Proposta
        - Stage 0: strawman -> submeter um formulário com a ideia para 
        evoluir o ECMAScript, deve ser feita por um membro ou alguém 
        registrado
        - Stage 1: proposal -> surgi a proposta formal, surgi um campeão,
        proposta bem definida com exemplo, pode ter varias alterações
        - Stage 2: draft -> primeira versão que vai entrar na 
        especificação, é obrigatório:
            -> descrição formal da sintaxe e semâtica da funcionalidade
            -> duas implementação são exigida
        - Stage 3: candidate -> a proposta tá quase finalizada, precisa 
        de feed back de implementação, especificação completa nessa etapa
        - Stage 4: finished -> tem que passar na suiter de teste, 
        esperiência prática
        * ES.NEXT 
            -> É uma especificação que possui futura implementações
            -> Não está disponivel mas pode ser testada no babel
        * BABEL is JavaScript Compiler
            -> 
### Conceitos da Linguagem
    * Linguagem interpretada: o código é executado de cima para baixo e 
    são execultado na msm horas.
    * Linguagem de tipagem fraca e dinâmica
    * Typescript é um superset da linguagem javascript 
        - ele consegui adicionar tipos no javascript
        - ele adiciona funcionalidade que o javascript não tem por padrão
            -> interface
            -> enum
            -> tipo generic
        - https://www.typescriptland.org/
    * Flow
        - não é considerado um superset javascript
        - consegui adicionar tipos
        - https://flow.org/en/
    * Funções de primeira classe e ordem maior
    * Closure a capacidade da variável lembrar aonde foi criada
    * Currying -> tecnica para gente transformar uma função com n 
    paramentro em apenas um parâmetro, e para cada parâmetro agente
    retorna uma função.
    * Hoisting -> levantar ou suspender algo
    * Imutabilidade

    Todas vez que passamos um array ou um object ele é passado por 
    referência.

### Tipos e variáveis
    * existe tres escopo dentro do javascript 
        - Escopo global 
        - Escopo de função
        - Escopo de bloco
    * var
        Var não respeita o escopo de bloco
    * let
    * const 
        - A ideia dele é pra criar constante
        - Ele não deixa trocar o valor de tipo primitivo
        - Se for criado um objeto, ele permiti mudar as própriedades
        - Não pode ser mudado pra aonde o ponteiro dele está apontando
    




<file_sep>/Introducao_JavaScript/JavaScript_ES6_essicial/script/Aula02-Parte3/1-repeticao.js
// Estrutura de repetição

// for

const array = [1, 2, 3];
for (let index = 0; index < array.length; index++){
    console.log(array[index]);
}

// while
var n = 0;
var x = 0;
while (n < 3){
    n++;
    x += n;
}

console.log(x);
// do - while
let i = 0;
do{
    i += 1;
    console.log(i);
}while(i < 5);

// for in
for(let i in array){
    console.log(i);
}
// for of
for(let i of array){
    console.log(i);
}

<file_sep>/Introducao_JavaScript/JavaScript_ES6_essicial/Anotaçoes/Aula04-Parte1.md
# Manipulação e iteração de arrays  Parte-1

## criar um array

const arr = [1, 2, 3]
const arr2 = new Array(1, 2, 3);

### Array.of
    cria uma nova instância de array a partir do número de 
parâmetro informados

### Array
    Cria uma nova instância de array de acordo com os 
parâmetros informados.

obs.: se for passado um elemento, o vetor é criado com a 
quantidade de posições do elemento.

### Array.from
    Cria uma nova instância de array a partir de um parâmetro
array-like ou iterable object

#### Array-like
    O comando abaixo não é um array e sim um node list. Então 
não vou ter funções de array, como: pop, forEach e etc...
    const divs = document.querySelectorAll('div');
    
    Se eu quiser ultilizar o node list, é só usar o comando 
abaixo, que ele vai me dar um array.
    const arr = Array.from(divs)

## Inserir e remover elementos
### push
    Adiciona um ou mais elementos no final do array e retorna
o tamanho do novo array.

### pop
    Remove o ultimo item
### unshift 
    Adicionar um ou mais elementos no início do array e 
retorna o tamanho do novo array
### shift 
    Remove o primeiro elemento de um array e retorna o 
elemento que ele removeu
### concat 
    Concatena um ou mais array e retonrnando um novo array.
### slice
    Retorna um novo array "fatiando" o array de acordo com 
ínicio e fim.
### splice
    Altera um array adicionando novos elementos enquanto 
remove elementos antigos


<file_sep>/Introducao_JavaScript/JavaScript_ES6_essicial/script/Aula02-Parte1/Aula02-Symbol.js
const symbol1 = Symbol();
const symbol2 = Symbol();

// Symbols são únicos
console.log('symbol1 é igual a symbol2: ', symbol1 === symbol2);

// Previnir conflito entre nomes de propriedades
const nameSymbol1 = Symbol('name');
const nameSymbol2 = symbol2('name');

const user = {
    [nameSymbol1]: 'Guilherme',
    [nameSymbol2]: 'Outro nome',
    lastName: '<NAME>'
};

console.log(user);

// Symbols criam propriedade que não são enumnberables
for (const key in user){
    if (user.hasOwnProperty(key)){
        console.log(`\nValor da chave ${key}: ${user[key]}`)
    }
}

// Acessando todas as propriedades do objeto 
console.log('Todas propriedades do objeto user: ', Reflect.ownKeys(user));

// Criar um enum
const directions = {
    UP      : Symbol(   'UP'    ),
    DOWN    : Symbol(   'DOWN'  ),
    LEFT    : Symbol(   'LEFT'  ),
    RIGHT   : Symbol(   'RIGHT' )
};
<file_sep>/Arquitetura_Sistema/Aula04/4-parte.md
## Transactions


    * Um banco de dados deve permitir que várias pessoas deva
    acessar ao mesmo tempo.
    * cada usuário é tratado como uma transactions diferente.
    * impedir que eu altere um transactions e outro depois 
    altere a mesma transactions e sobreponha a mim... quem 
    inicio primeiro tem prioridade...
    * Inicio, Resolução e Fim
    * ACID - Transactions
        -> Atomicidade:
            Todas operações executadas com sucesso. Commit ou 
            Rollback
        -> Consistência:
            Unicidade da chaves, restriçoes de integridade 
            lógica, etc
        -> Isolamento:
            Várias transações podem acontecer simultaneamente
            o mesmo registro(ou parte do registro)
        -> Durabilidade:
            Depois do Commit, mesmo com erros, queda de
            energia, etc. As alterações devem ser aplicadas.








<file_sep>/Arquitetura_Sistema/Aula01/2-parte.md
## O que é SOAP
    * SOAP - Simple Object Access Protocol
    * É um protocolo baseado em XML para acessar serviços web
      principalmente HTTP.
    * Pode-se dizer que SOAP é uma definição de como serviços 
      web se comunicam
    * Foi desenvolvido para facilitar integrações entre 
      aplicações.
    * Permite integrações entre aplicações, independente de 
      linguagem, pois usa como linguagem comum o XML.
    * É independente de plataforma e software.
    * Meio de transporte genérico, ou seja, pode ser usado por
      outros protocolos além do HTTP

## XML
    * XML - Extensible Markup Language
    * É uma linguagem de marcação criada na década de 90 pela 
      W3C.
    * Facilita a separação de conteúdo
    * Não tem limitação de criação de tags
    * Linguagem comum para integrações entre aplicações.

## Estrutura do SOAP
    * O "SOAP Message" possui uma estrutura única que deve 
      sempre ser seguida.
      
                +---------------------------+
                |       SOAP Envolope       |
                |   +-------------------+   |
                |   |   SOAP Header     |   |
                |   +-------------------+   |
                |                           |
                |   +-------------------+   |
                |   |   SOAP Body       |   |
                |   |                   |   |
                |   |                   |   |
                |   +-------------------+   |
                +---------------------------+

    * SOAP Envelope é o primeiro elemento do documento e é 
      usado para encapsular toda a mensagem SOAP.
    * SOAP Header é o elemento onde possui informações de
      atributos e metadados da requisição.
    * SOAP Body é o elemento que contém os detalhes da 
      mensagem.






<file_sep>/Arquitetura_Sistema/Aula03/1-parte.md
# Introdução a internet das Coisas

## ARPANET 
    * começo da internet
    * conectar os computadores

Com o objetivo de conectar computadores, a ARPANET cresceu e 
hoje ela deu inicio o que chamamos de rede mundial de 
computadores
    * surgimento dos aplicativos(email, browser e etc)
    * chegada dos iphone
    * A internet é uma rede de pessoas conectadas e trocando 
    informações
    * A internet das coisas surgiu para conecetar as coisas

### Por que conectar as coisas ?
    * Embutir sensores em objetos do dia-a-dia
    * COletar dados dos sensores
    * Usar o dado para tomar decisão

### Conceitos Báiscos de IoT
    * Things 
        as coisas aonde queremos colocar os sensores, aonde 
        queremos coletar dados.
    * Cloud
        aonde a gente quer processar e armazenar os dados
    * Intelligence
        o processo de usar os dados gerados, se beneficiar do
        poder dessa rede e ultilizar esses dados de forma 
        inteligente.

### Exemplos de onde posso usar o IoT
    * Smart Building: é a capacidade de coletar dados e
    ultilizar esses dados de forma inteligente para poder 
    melhorar algo.
    um exemplo um prédio
    * Smart Home: coletar dados para melhora os processos que 
    ocorrem dentro da casa.
    * Wearables: componentes que colocamos no nosso corpo e 
    ele acaba coletando dados.
    * Agriculture: componente usados na agricultura para 
    diversos fins.
    * Smart Transportation: componente usados no transito 
    coletando dados.
    * RFID Supply Chain: aonde o IoT nasceu
    * Energy Efficiency: 
### Computação Ubíqua
    É quando a computação faz parte da gente que esquecemos 
    dela.
### Desafios da Internet das Coisas
    1. Privacidade e Segurança
    2. Quantidade exponencial de dispositivos conectadas na 
    rede.
    3. Ser capaz de precessar e armazenar uma enorme 
    quantidade de informações
    4. Gerar valor a partir dos dados coletados.
<file_sep>/Arquitetura_Sistema/Aula02/1-parte.md
# Conceito de Arquitetura em aplicações para internet

## Tipos de Arquiteturas
### Monolito
    * web app ou Mobile app
    Ela vai passar por um proxy HTTP, esse proxi vai 
    redirecionar para qual instância, e essas instâncias 
    vão está conectadas ao um banco de dados
    * A ideia dele é ter uma aplicação,  o problema é que com 
    o aumentou da demanda esse instância teria problema para 
    aguentar a quantidade de demanda.
    * É preciso ter várias instâncias para não ter problemas 
    com muitas requisições.
    * Mais simples

+--------------------------------------------+
|                   Sevidor                  |
|               +--------------+    +------+ |
|               |Aplicação     |    |Proxi | |  +-----+
|+-----+        |(instância #1)|    |      | |  |Web  |  
||banco|        +--------------+    |      | |  |App  |
|| de  |        +--------------+    |HTTP  | |  +-----+
||Dados|        |Aplicação     |    |      | |
|+-----+        |(instância #2)|    |      | |  +------+
|               +--------------+    |      | |  |Mobile|
|               +--------------+    |      | |  |App   | 
|               |Aplicação     |    |      | |  +------+
|               |(instância #3)|    |      | |
|               +--------------+    +------+ |
+--------------------------------------------+


### Microserviços #1
    * Vantagens de ter microserviços ou serviços menores
    * Vantagens de serviços que fazem coisas menores
    * Não está preso a uma certa tecnologia
    * cada caixa pequena do NODO, serve como servia o 
    monolito
    * Vou ter vários serviços e esses serviços tem que 
    conversar entre eles.
    * cada serviço pode chamar outros serviços, pode ser 
    por http ou outro tipo de requisição.

### Microserviços #2
    * não temos a comunicação entre os NODOS
    * temos agora um Message Broker
    * A vantagem é que um serviço não vai está conectado
    no outro, e tudo vai passar pro um menssage broker
    * Se o serviço 1 precisa se comunicar com o serviço 2,
    ele vai até o menssage broker e deixa uma mensagem;
    se caso o serviço 2 não estiver online, e depois quando
    for restabelecida a comunição, e vai até o menssage broker
    e verifica as mensagens que tem pra ele.
    * fica mais fácil trocar os serviços, se for necessário.

#### desvantage
    * Toda plataforma fica refem do message broker, se der 
    algum problema, toda plataforma sofre com isso.

### Microserviços #3
    * Ao invés do proxy http se comunicar com um determinado
    serviço, ele vai se comunicar com um gerenciador de 
    pipeline.
    * tem aplicações separadas, cada serviço com sua 
    dependência diferente, ter o menor código possível, 
    evitar bugs, melhor perfomace, usar a melhor tecnologia.

<file_sep>/testes/Program.cs
﻿using System;

namespace testes
{
    class Program
    {
        
        static void Main()
        {
            nivelTartaruta();
            nivelTartaruta();
            nivelTartaruta();
            
        }

        public void nivelTartaruta()
        {
            int num = int.Parse(Console.ReadLine());
            string[] velocidades = Console.ReadLine().Split(" ");
            int maior = 0;
            
            for(int i = 0; i < num; i++){
                velocidades[i] = int.Parse(velocidades[i]);
                if(i == 0){
                    maior = velocidades[i];
                }
                else{
                if(velocidades[i] > maior){
                    maior = velocidades[i];
                }
                }
                Console.WriteLine(maior);
        }
    }



}<file_sep>/JogoCobra/script.js
/**
 * linha 1: 
 * linha 2: o contexto ele rederizar o desenho que vai 
 * entrar dentro do canvas, colancando "2d", ele vai passar
 * tratar o arquivo em dois d. 
 */

 /**
  * A função criarBG, cria o nosso canvas: desenha e cor
  * começando com o contexto e criando a cor
  * o fillreact vai desenha o retangulo aonde vai acontecer
  * o jogo, trabalhando com 4 parametro
  */

let canvas = document.getElementById("snake");  // linha 1
let context = canvas.getContext("2d");          // linha 2
let box = 32;                                   // linha 3
let snake = [];                                 // linha 4
snake[0] = {                                    // linha 5
    x: 8 * box,                                 // linha 6
    y: 8 * box                                  // linha 7
}                                               // linha 8

/**
 * Precisamos criar uma variável para dominar a direção da
 * cobrinha
 * 
 * Nosso próxio passo é criar uma condição que o jogo fique
 * sempre atualizado
 * setInterval - funçao de tempo 
 */
let direction = "right";
let food = {
    x: Math.floor(Math.random() * 15 + 1) * box,
    y: Math.floor(Math.random() * 15 + 1) * box
}

function criarBG(){
    context.fillStyle = "lightgreen";
    // fillstyle trabalha com a cor do nosso elemento
    context.fillRect(0, 0, 16 * box, 16 * box);
    // o fillrect trab 4 param (x, y, altura, largura)
    // cada quadrado do canvas vai ter 32 pixes  que foi
    // definido na variável box
}



// função criarCobra
function criarCobrinha(){
    /**
     * O for vai percorre todo o tamanho do nosso array e
     * vai incrementar. Quando ele tiver a incrementação, 
     * ele vai pintar o corpo da nossa cobrinha de verde e 
     * vai setar o tamanho dela certinho.
     */
    for(let i = 0; i < snake.length; i++){
        /**
         * vamos passar o context novamente, só que ele 
         * estará ligado  a nossa cobrinha
         */
        context.fillStyle = "green";
        context.fillRect(snake[i].x, snake[i].y, box, box);
    }
}

function drawFood(){
    context.fillStyle = "red";
    context.fillRect(food.x, food.y, box, box);
}


document.addEventListener('keydown', update);

function update(event){
    if(event.keyCode == 37 && direction != "right")  direction = "left";
    if(event.keyCode == 38 && direction != "down" )  direction = "up";
    if(event.keyCode == 39 && direction != "left" )  direction = "right";
    if(event.keyCode == 40 && direction != "up"   )  direction = "down";
    
}


/**
 * 1- A cobrinha vai ser um array de coordenadas, agente vai
 * 2- Adicionar um elemento e ritrar o ultimo;
 * 3- Criar as coordenadas da nossa cobrinha
 */

function iniciarJogo(){

    for(let i = 1; i < snake.length; i++){
        if(snake[0].x == snake[i].x && snake[0].y == snake[i].y){
            clearInterval(jogo);
            alert("Game Over");
        }
    }

    if(snake[0].x > 15 * box && direction == "right") snake[0].x = 0;
    if(snake[0].x < 0 * box && direction == "left") snake[0].x = 16 * box;
    if(snake[0].y > 15 * box && direction == "down") snake[0].y = 0;
    if(snake[0].y < 0 * box && direction == "up") snake[0].y = 16 * box;


    criarBG();
    criarCobrinha();
    drawFood();

    let snakeX = snake[0].x;
    let snakeY = snake[0].y;

    if(direction == "right") snakeX += box;
    if(direction == "left") snakeX -= box;
    if(direction == "up") snakeY -= box;
    if(direction == "down") snakeY += box;

    if(snakeX != food.x || snakeY != food.y){
        snake.pop()
    }else{
        food.x = Math.floor(Math.random() * 15 + 1) * box;
        food.y = Math.floor(Math.random() * 15 + 1) * box;
    }

    let newHead = {
        x: snakeX,
        y: snakeY
    };
    snake.unshift(newHead);
 }

let jogo = setInterval(iniciarJogo, 100);

/**
 * mexer agora com os controle para a cobrinha não 
 * desaparecer na tela
 */

<file_sep>/Introducao_JavaScript/JavaScript_ES6_essicial/HTML/index.html
<!DOCTYPE html>
<html lang="pt-br">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet"  href="../CSS/style.css">
    <title>JavaScript</title>
</head>
<body>
    <div class="body-central">
        <div class="corpo-texto">
            <p class="texto">Mozila is Cool, Lucas</p>
        </div>
        <div class="imagem-mozila">
            <img src="../image/mozila-foto.png" alt="Logo da Mozila">
        </div>
        <div class="texto-restante">
            <p>At Mozilla, we're global community of</p>
        <div class="ordenar">
            <ul>
                <li>technologists</li>
                <li>thinkers</li>
                <li>builders</li>
            </ul>
        </div>
            <p>
                working together to keep the internet alive ande acessible, so people<br>
                worldwide can be informed contributors ande creators of the web. we <br>
                believe this act of human collaboration across an open platform is <br>
                essential to individual growth and our collective future.
            </p>
            <p>
                Read the <a href="#">Mozilla Manifesto</a> to learn even more about the values and <br>
                principles that guide the pursuit of our mission.
            </p>
        </div>
        <div class="btn-click">
            <a href="#">Change Useer</a>
        </div>
    </div>
</body>
</html><file_sep>/Introducao_JavaScript/Programacao-Para-Internet-com-JavaScript/JS/main2.js
/*function soma(n1, n2){
    return n1 + n2
}

console.log(soma(5, 3))

function setReplace(frase, nome, novo_nome){
    console.log("Frase antiga: \nVai " + nome);
    console.log("Frase nova: ");
    return frase.replace(nome, novo_nome);
}


console.log(setReplace("Vai Angola", "Angola", "Dinamarca"))
*/

function apertou(){
    var texto = document.getElementById("elemento").innerHTML
    console.log(texto)    
}

function redirecionar1(){
    window.open("https://www.google.com");
}

function redirecionar2(){
    window.location.href = "https://www.google.com";
}

function mouseMover(elemento){
    elemento.style.color = "#00f";
    elemento.innerHTML = "Não conseguir fazer o que eu quiz";
}

function voltar(elemento){
    elemento.style.color = "#f00";
    elemento.innerHTML = "Teste";
}

function load(){
    console.log("Página carregada");
}

function pegar(elemento){
    var ele = elemento.value
    var valor = parseInt(ele)
    console.log(valor + 10);
}
<file_sep>/Arquitetura_Sistema/Aula02/3-parte.md
# Gerenciamento de erros e volume de acesso
## Gerenciamento de erros
### Onde é mais complexo:
    * Processos assíncronos (Microsserviços #2)
    * Pipeline

### Solução:
    * Dead letter queue
    * Filas de re-tentativas

https://github.com/jeffhsta/fundamentos_arquitetura




<file_sep>/Arquitetura_Sistema/Aula01/3-parte.md
## WSDL
    * WSDL - Web Services Description Language.
    * Usado para descrever Web Services, funciona como um 
      contrato do serviço.
    * A descrição é feito em um documento XML, onde é 
      descrito o serviço, especificações de acesso, operações 
      e métodos.

## XSD
    * XSD - XML Schema Definition
    * É um shema no formato XML usado para definir a estrutura
      de dados que será validade no XML.
    * O XSD funciona como uma documentação de como deve ser 
      motando o SOAP Message (XML) que será envidao através de
      Web Service.

    VAMOS À PRÁTICA..

www.soapclient.com/xml/soapresponder.wsdl

<file_sep>/Introducao_JavaScript/JavaScript_ES6_essicial/script/Aula02-Parte1/Aula02-Object2.js
const user = {
    name: 'Lucas',
    lastName: '<NAME>'
};

// Recupera as chaves do objeto
console.log('Propriedade do objeto user: ', Object.keys(user));

// Recupera os valores das chaves do objeto 
console.log('\nValores das propriedades do objeto user: ', Object.values(user));

// Retorna um array de arrays contendo [nome_prop, valor_prop]
console.log('\nLista de propriedades e valores: ', Object.entries(user));

// Margear propriedades de objetos
Object.assign(user, {fullName: '<NAME>'});

console.log('\nAdiciona a propriedade fullName no objeto user', user);
// Pensando em imutabilidade o comando de cima não é recomendado

/**
 * Não é recomendado alterar o objeto ou array principal, a ideia é que seja gerado um novo.
 * Toda vez que formo mergiar um array ou objeto é passar o primeiro parâmetro um objeto ou array
 * vázio, ai assim faz o margi. mergi é o comando acima e abaixo está a maneira recomendada,
 * que foi descrita nesse texto.
 */
console.log('\nRetorna um novo objeto margeando dois ou mais objetos', Object.assign({}, user, {age: 28}));

/**
 * Quando é criado um objeto const, agente não consegui mudar o local 
 * para aonde ele está apontando; mas suas propriedades podem ser trocadas.
 * 
 */
// Previne todas as alterações em um objeto
const newObj = {fod: 'bar'};
Object.freeze(newObj);
/**
 * Com o comando .freeze não deixa ou não é possivel trocar as
 *  propriedades do objeto e nem o objeto
 */

newObj.fod = 'changes';
delete newObj.fod;

const person= {name: '<NAME>'};
Object.seal(person);

person.name = '<NAME>';
delete person.name;
person.age = 26;

console.log('\nVariável person após as alterações ', person);

/**
 * metodo seal
 * Não permite que vc ou delete nenhuma propriedade do objeto
 * É possivel trocar o valor de uma propriedade que já existe 
 * dentro dele.
 */



<file_sep>/Arquitetura_Sistema/Aula03/4-parte.md
#### Arquitetura é escolha

        MQTT            MQTT
GPS     ->      Broker  ->      Worker     ->    Data store  

Eu preciso escolher o vou ultilizar como broker

App     ->      Eclipse  ->      Node.js     ->    Banco de 
Android         Mosquitto                          Dados MySQL

#### Mínimo Produto Viável

GPS     ->      HiveMQ  ->      Akka     ->    Banco de 
Embarcado                       Scala          Dados noSQL
                                JVM     

#### Solução

GPS     ->      AWS IoT ->      AWS     ->    AWS S3 
Embarcado       Core            Kinesis       
                                Firehose     


#### IoT na prática

GPS Embarcado
AWS IoT Core
AWS Data Stream
AWS Lambda
AWS ElasticCache Redis
AWS EC2
FeathersJS Backend 
Dashboard








<file_sep>/Arquitetura_Sistema/Aula03/2-parte.md
# Arquitetura da Internet das Coisas

### Conectando as coisas...
    * Como conectar as coisas ?

### Considere esses atributos na escolha 
    * Baixo consumo de energia
    * Rede de dados limitado
    * Resiliencia
        Armazenar os dados localmente, enquanto eu não tenho 
        rede(Buffer).  
    * Segurança
    * Customização
        o que vc estar desenvolvendo vai sempre encontrar um 
        ambiente heterogeneo.
    * Baixo Custo

### Arduino
    * Plataforma de Prototipagem
    * Com entradas/saídas
    * Desenvolvedor escreve em C/C++
    * Interface serial ou USB
    * Shields são componentes que vc agrega para poder acessar
    a rede

### Embarcados
#### MCUs
    * Microcontrolador de chip único
    * Sistema operacional real time
    * Embarcado
    * Uso industrial, médico, militar, transporte
### Minicomputadores
#### Raspberry Pi
    * Computador completo
    * Hardware inteegrado em uma única placa
    * Roda SO Linux ou Windows
    * Uso doméstico e comercial

## O protocolo de comunicação
### O protocolo MQTT
    Gps Tracker
    free RTOS
    * Base na pilha do TCP/IP
    * Protoolo de mensagem assíncrona (M2M)
    * Criado pela IBM para conectar sensores de pipelines de 
    petróleo a satétiles
    * Padrão OASIS suportado pelas linguagens de programação
    mais populares.
###### (modelo cliente servidor)
    * modelo sincrono
###### (Modelo Pushish/Subscribe)
    * Separação de quem manda a mensagem de quem é o receptor 
    da mensagem
    * Capacidade de escalabilidade maior que o client-server
#### Publish
    * ter um endereço desse broker
    * topico um endereço aonde vai ser entregue a informação







<file_sep>/Arquitetura_Sistema/Aula04/3-parte.md
# SGDBR - SQL
    * Linguagem
    * DDL - Data Definition Language
    * DML - Data Manitulation Language
    * DQL - Data Query Language

### DDL
    * comando que cria uma tabela
    create table Cliente{
        Codigo number(10) not null primaty key
        Nome varchar(50) not null,
        Telefone varchar(15)
    }

### DML
    insert into Cliente(Codigo, Nome, Telefone)
    values (1, "<NAME>", "(88) 999 9999")

    delete from cliente where Codigo = 1

    Update Cliente set Nome = "<NAME>" where
    Codigo = 1

### DQL
    Select Codigo, Nome from Cliente
    <where> Codigo = 1
    <Group by> Profissao
    <Having> Count(1) > 0
    <Order by> Nome, Codigo

    Select Codigo, Nome from Cliente
    where Codigo = 1
    Union
    Select Codigo, Nome from Cliente
    where Nome = "<NAME>"

    Select Quantidade, valor, Descricao from item_venda
    join Produto 
    on Codigo = Cod_Produto
    where valor > 4

### Funções de Conjunto
    Select Sum(ven.Quantidade) as QTotal,
           Sum(ven.Valor) as VTotal,
            pro.Descricao
    from Item_venda ven
    Join Produto pro
    on pro.Codigo = ven.Cod_produto
    where ven.Valor > 5
    Group by pro.Descricao
    Having Sum(ven.Valor) >= 10

### Index
    Select ...
    where Profissao = 1 and Genero = "M"

    index é uma pequena tabela extraida da tabela original
    com as coluna que eu desejo







<file_sep>/Linux/Aula02.md
# Instalação e Configuração



























<file_sep>/Introducao_JavaScript/Programacao-Para-Internet-com-JavaScript/Aula02.md
# Desenvolva Páginas web

# Maniplando elementos da página
    - evento onclick
    - pegando elemento atravéz de getElementById
    - usando innerHTML
    - usando o objeto window com método open, permitindo redirecionar para
    uma página html externa, mas abre em outra janela
    - window.location.href para redirecionar para uma página html externa,
    mas abre na mesma janela
    - onmouseover dispara quando o mouse está se movendo em cima do objeto
    - onmousemove dispara quando o mouse está se movendo
    - onmouseout dispara quando o mouse estar fora do objeto
    - this passa o próprio objeto como parâmetro
    - onload dispara quando a página é carregada


















<file_sep>/Arquitetura_Sistema/Aula04/1-parte.md
### Conceito de Dados
    * Dados de uma maneira geral é um conjunto de valores e
    ocorrencias que descrevem alguma instância, algumas 
    ocorrencia ou alguma caracteristica.

### importância
    * De DADOS nós podemos extrair: informações, e com a 
    informação, nós temos o conhecimento; o conhecimento nos 
    ajuda a tormar decisões, a evoluir sistemas de coisas, a
    uma empresa gerenciar e uma infinidade de coisas.

### Dados Digitais
    Lorem Ipsum (00)99999-1111 120,19
    * Um arquivo texto é um formato de dado digital
    * Os dados não tem uma explicação por se só

    Velit Esse Cillum (55)99999-2222 1.300,19

### Modelo Sustentável
#### Estruturação
#### Durabilidade
#### Velocidade
#### Controle de Acesso
#### Isolamento

### Exercício Final
    1 - O que podemos extrair de dados brutos
    a) Apenas atributos
    b) Uma descrição de como aconteceram
    c) Informações e com ela o conhecimento
    d) Nenhuma das anteriores

# O que é um Banco de Dados
    * Sistema ou conjunto de sistemas que gerencia esses 
    dados, permite que nós tenhamos acesso, controle, 
    redudância e segurança sobre esses dados.

### Abstração
    * Pegar os dados que está no meio físico e abstratir
    esses dados numa visão que seja pratica que traga 
    informação.

### SGDBs
    * Esses sistemas são chamados de SGDBs ou Sistemas 
    Gerenciadores de Banco de Dados.
    * No nível de abstração foram criados linguagens e
    ferramentas que controlam todos esses mecanismo
        -> Linguagem de Definição: Aonde posso definir como 
        é a estrutura dos meus dados.
        -> Linguagem de Manipulação: AOnde eu recupera essa 
        informação ou minipulo esses dados.
        -> Dicionário de Dados: que é um banco de dados dentro
        do banco de dados que guarda toda essa estrutura.

### Modelos de Banco de Dados
#### Modelo Flat
                    Nome        Telefone         Profissão
    * Registro 1    Lorem       (99) 11111 1111  Vendedor
                    Ipsum

#### Modelo Hierárquico
                    Administrativo
                    /       |     \
Vendedor                Analista                Manutenção
    * Armazenado em arvores
    * Não mais ultilzado
    * tem redudância de informaçõa

#### Modelo Relacional
    * Modelo mais ultilizado no momento

#### Modelo Redes - Grafo
#### Modelo Orientado a Objetos
#### Modelo Objeto-Relacional
#### Modelo Big Data


1- O que é um SGDB ?
    a) Varios Arquivos com informações
    b) Um sistema de Abstração
    c) Um sistema que gerencia banco de dados x
    d) Uma biblioteca de tabelas
<file_sep>/Introducao_JavaScript/JavaScript_ES6_essicial/Anotaçoes/Aula04-Parte2.md
# Manipulação e iterações de arrays Parte-2

### forEach
    Iteração de cada item dentro de um array
### map
    Retorna um novo array, de mesmo tamanho, iterando cada 
item de um array

### flat
    Retorna um novo array com todos os elementos de um sub-
array concatenados de forma recursiva de acordo com a 
profundidade especificada(depth)

### flatMap
    Retorna um novo array assim como a função map e execulta 
um flat de profundidade 1.
### Keys
    Retorna um *Array* *Iterator* que contém as chaves para 
cada elemento do array.
### values
    Retorna um *Array* *Iterator* que contém os valores para 
cada elemento do array.
### Entries
    Retorna um *Array* *Iterator* que contém os pares chaves/
valor para cada elemento do array.
### Find
    Retorna o primeiro item de um array que satisfaz a 
condição.
### FindIndex
    Retorna o índece do primeiro item de um array que satifaz
a condição.
### filter
    Retorna um novo array com todos os elementos que 
satisfazem a condição.
### indexOf
    Retorna o primeiro índice em que um elemento pode ser
encontrado no array.
### lastIndexOf
    Retorna o último índice em que um elemento pode ser 
encontrado no array
### includes
    Retorna um booleano verificando se determinado elemento
existe no array.
### some
    Retorna um booleano verificando se pelo menos um item de 
um array satisfaz a condição.
### every
    Retorna um booleano verificando se todos os itens de um 
array satisfazem a condição.
### sort 
    Ordena os elementos de um array de acordo com a condição
### reverse
    Inverte os elementos de um array
### join
    Junta todos os elementos de um array, separados por um 
delimitador e retorna uma string
### reduce
    Retorna um novo tipo de dado iterando cada posição de um 
array


<file_sep>/Introducao_JavaScript/JavaScript_ES6_essicial/script/Aula02-Parte1/Aula02-number.js
const myNumber = 12.4032;

// Transforma número para string
const numberAsString = myNumber.toString();
console.log('Número transformado em String: ', typeof(numberAsString));

// Retorna número com um número de casas decimais 
const fixedTwoDecimals = myNumber.toFixed(2);
console.log('\nNúmero com duas casas decimais: ', fixedTwoDecimals);

// transfoma uma string em float
console.log('\nString parseada para float: ', parseFloat('13.20'));

// Transforma uma string em int
console.log('\nString passado para int: ', parseInt('15'));



<file_sep>/Introducao_JavaScript/JavaScript_ES6_essicial/Anotaçoes/Aula03-Parte1.md
# Orientação a objetos

## Herança
    -> Baseada em protótipos
    -> prototype é uma variável que armazena as definições
    do nosso objeto
    -> __proto__ aponta para o prototype do tipo que foi 
    criado.
    -> constructor

'use strict'

const myText = 'Hello prototype';

myText.split('');


A declaração de acima é a mesma dessa

const myText = String('Hello prototype!');
console.log(myText.__proto__.split);

Ele está usando a função construtora string; então, a função 
construtora já carregada um prototype.

Toda função construtora tem um prototype atrelada a ela e toda
vez que eu crio uma variável, a parti da função construtora, eu vou ter essa referencia do proto atrelada a ela.

__proto__ -> prototype -> constructor
Um proto aponta para um prototype, e esse prototype é criado 
apartir de um constructor.

myText.constructor -> String
myText.__proto__ -> String.prototype

function Animal() {}

console.log(Animal.constructor);

f Animal.constructor -> Function -> Function.prototype.
constructor -> Object.prototype = null


O que ocorre ?
1 - Um novo objeto é criado, herdando Foo.prototype
2 - A função construtora Foo é chamad com os argumentos 
especificados e com o `this` vinculado ao novo objeto 
criado.
3- Caso a função construtora tenha uma retorno explicito, 
será respeitado o seu `return`, senão, será retornado o 
objeto criado no passo 1.

    Classes 
        -> ES6
        -> Simplificação da herança de prototipes
        -> palavra chave class

    Modificadores de acesso (Atualmente não existe <br>
    modificadores de acesso no JS)
        -> privado/público
        -> criação de atributos privados com o #
    Encapsulamento
        -. Ocultar detalhe dos funcionamento interno
    Static
        -> Ele permite que agente acesse métodos ou atributos
        sem instanciar determinada classe
<file_sep>/Arquitetura_Sistema/Aula01/4-parte.md
## Rest
    * REST -  Representational State Tranfer
    * É um estilo de arquitetura de software que define a 
    implementçaõ de um serviço web.
    * Podem trabalhar com os formatos XML, JSON ou outros.

    Não importa como ele é, mas sim como ele estar.

## Vantagens do REST
    * Permite integrações entre aplicações e também entre
    cliente e servidor em página web e aplicações.
    * Utiliza dos métodos HTTP para definir a operação que
    está sendo efetuada.
    * Arquitetura de fácil compreensão.

## Estrutura do REST
    cliente     -> -> -> -> -> -> -> -> -> ->   Servidor
    O cliente está tentando uma requisão com o servidor usando
    HTTP (GET, POST, PUT, DELETE...), o servidor responde com
    um código de operação, retorna uma mensagem (Texto, JSON, 
    XML...);

    Quando uma aplicação web disponibiliza um conjuto de 
rotinas e padrões através de serviços web podemos chamar esse 
conjunto de API.

## API
    * API - Application Programming Interface.
    * São conjuntos de rotinas documentados e disponibilizados
    por uma aplicação para que outras aplicações possam 
    consumir suas funcionalidades.
    * Ficou popular com o aumento dos serviços web.
    * As maiores plataformas de tecnologia disponibilizam APIs
    para acessos de sua funcionalidades, algumas delas são: 
    Facebook, Twitter, Telegram, Whatapp, GitHub...

## Principais métodos
    * GET - solicita a representação de um recurso.
    * POST - solicita a criação de um recurso
    * DELETE - Solicita a excluão de um recurso.
    * PUT - Solicita a atualizaão de um recurso.

## JSON
    * JSON - JavaScript Object Notation.
    * Formatação leve utilizada para troca de mensagens entre
    sistemas.
    * Usa-se de uma estrutra de chave e valor e também de 
    listas ordenadas.
    * um dos formatods mais populares e mais utilizados para 
    troca de mensagens entre sistemas.

    {
        "nome": "<NAME>",
        "ano_lancamento": "2019",
        "personagens":[
            {
                "nome: "Thanos"
            },
            {
                "nome: "<NAME>"
            },
            {
                "nome: "Thor"
            }
        ]
    }






<file_sep>/Introducao_JavaScript/JavaScript_ES6_essicial/script/Aula02-Parte3/1-condicionais.js
const array = [0, 1, 2, 3, 4, 5];


array.forEach( item => {
    if(item % 2 === 0){
    console.log(`O número ${item} é par.`);
    }else{
        console.log(`O número ${item} é impar`);
    }
});


array.forEach(item => {
    if(item % 2 == 0){
        console.log("Dividido por 2");
    }else if(item % 3 === 0){
        console.log("Dividido por 3");
    }else{
        console.log("Dividido por outro número");
    }
})

// switch - case

const fruit = 'banana';

switch(fruit){
    case 'banana':
        console.log("R$ 3,00/ Kg");
        break;
    case  'goiaba':
        console.log("R$ 4,00/ Kg");
        break;
    default:
        console.log("Não tem sua fruta.");
}

<file_sep>/Introducao_JavaScript/JavaScript_ES6_essicial/script/Aula02-Parte2/1-logicos.js
// ANd logico (&&)
exp1 && epx2

var a1 = true && true; // retorna ture 
var a2 = true && false; // retorna false
var a3 = false && true; // retorna false
var a4 = false && (3 == 4); // retorna false
var a5 = "Gato" && "Cao"; // retorna cao
var a6 = false && "Gato"; // retorna false
var a7 = "Gato" && false; // retorna false

// OU logico (||)
exp1 || exp2

var a1 = true && true; // retorna true 
var a2 = true && false; // retorna true
var a3 = false && true; // retorna true
var a4 = false && (3 == 4); // retorna false
var a5 = "Gato" && "Cao"; // retorna Gato
var a6 = false && "Gato"; // retorna Gato
var a7 = "Gato" && false; // retorna Gato

// NOT logico (!)
!exp1

var n1 = !true; // retorna false
var n2 = !false; // retorna true
var n3 = !"Gato"; // retorna false

// o que retorna true
" "
1 
['teste']

// o que retorna false
""
0
//[]

//!!
<file_sep>/Introducao_JavaScript/JavaScript_ES6_essicial/Anotaçoes/Aula02.md
# Tipos, Variáveis, Operadores, condicionais e repetição

## Tipos e Variáveis
    * String 
        - Para textos
    * number
        - Numeros
    * boolean
        - Verdadeiro ou Falso
    * null
        - 
    * undefinded
        - A variável existe mais não foi definida
    * symbol
        - Permite criar valores únicos
    * Object
        - 
    * Function
        - É um objeto que permite que o objeto seja chamado
    * Array

## Operadores
    * Aritméticos
    * Atribuição
    * Comparação
    * Condicional
    * Lógicos
    * Spread
 
<file_sep>/Arquitetura_Sistema/Aula02/2-parte.md
## Pros e contra Monolito 
### Pros
    * Baixa complexidade 
    * Monitoramento simplificado

### Contra 
    * Stack única
    * Compartilhamento de recursos
    * Acoplamento
    * Mais complexo o escalabilidade

## Pros e Contra Microserviços #1
### Pros
    * Stack dinâmica
    * Simples escalabilidade
### Contra
    * Acoplamento
    * Monitoramento mais complexo
    * Provisionamento mais complexo

## Pros e Contra Microserviços #2
### Pros
    * Stack dinâmica 
    * Simples escalabilidade 
    * Desacoplamento
### Contra
    * Monitoramento mais complexo
    * Provisionamento mais complexo

## Pros e Contra Microserviços #3
### Pos
    * Stack dinâmica
    * Simples escalabilidade
    * Desacoplamento
    * Menor complexidade
### Contra
    * Provisionamento mais complexo
    * Plataforma inteira depende do gerenciador de pipeline

<file_sep>/Introducao_JavaScript/JavaScript_ES6_essicial/script/Aula03/1-Parte/exemplo.js
'use strict';

console.log(String.prototype.split);

const myText = String('Hello prototype!');


console.log(myText.__proto__.split);


console.log(myText.__proto__.split === String.prototype.split);


new Foo()

class Animal{
    constructor(qtdePatas){
        this.qtdePatas = 4;
    }
    
}

<file_sep>/Arquitetura_Sistema/Aula04/5-parte.md
# SGDBs - R
    * Oracle
    * Microsolt SQL Server
    * IBM DB2
    * PostgreSQL
    * MySQL
    * SQLite

    https://www.postgresql.org/download/windows/





<file_sep>/Introducao_JavaScript/JavaScript_ES6_essicial/script/Aula02-Parte1/Aula02-booleano.js
/**
 * 
*/
const isActive = true;

const isAuthenticated = false;

console.log('Tipo da virávlel: ', typeof isActive);
<file_sep>/Introducao_JavaScript/Programacao-Para-Internet-com-JavaScript/Aula01.md
# Introdução ao JavaScript

## JavaScript

    * Linguagem de script e multiplataforma
    * Client Side - É executado do lado do cliente(usuário)
    * Tem capacidade de interagir com elementos de uma página HTML
    * Muito usado no desenvolvimento de página e tarefas de aplicativos mobile híbridos

## DOM (Document Objecti Model)
    * JavaScript pode alterar todos elementos do HTML
    * JavaScript pode alterar todos os atributos e estilos de CSS de uma página

## Como fazer o javascript Interagir com o HTML

    - Abrir uma tag scrip e dar comandos javascript
    dentro dessa tag
    - Ou criar um arquivo externo e usar o tag link 
    para link o javascript e o Html

## Caracteristicas do JavaScript
    - Tipagem dinâmica

## Comandos
    - alert -> apresenta uma mensagem na pela quando a página é carregada
    - console.log imprimi uma mensagem no console do navegador
    - var -> criar uma variável que pode ter qualquer tipo, o navegador 
    vai traduzir o tipo da variável quando for imprimir
    - string.toUperCase -> joga todas as letras da strings para maiusculas
    - string.toLowerCase -> joga tudo para minusculas
    - pop() -> retira o ultimo elemento da lista
    - push() -> acrescenta um elemento na minha lista
    - tostring() -> transforma a lista em um string separada por virgula
    - .join() -> voce consegue alterar o separador , por outra coisa
    
<file_sep>/Arquitetura_Sistema/Aula01/1-parte.md
# Fundamentos de Arquitetura de sistemas

## Serviços Web
    - Serviços Web ou  Web Services são soluções para
aplicações se cominicarem independente de linguagem,software 
e hardwares utilizados.

    - Inicialmente Serviços Web foram criados para troca de
mensagens utilizando a linguagem XML(Extensible Markup 
Languagem) sobre o protocolo HTPP sendo identificado por URI
(Uniform Resource Identifier).

    - Podemos dizer que Serviços Web são API's que se 
comunicam por meio de redes sobre o protrocolo HTPP.

#### ilustração
    - Aplicação x
    - Banco de dados x

    - Aplicação y
    - Banco de dados y

    Essas aplicações precisando se comunicar, mas elas são 
feitas com tecnologias diferentes: uma usa python, a outra usa
java; o banco de dados, é feita em oracle e o da outra 
em postgree: como fazer elas se comunicarem ?


    - web service vai ter o acesso a banco de dados, da 
aplicação x; a diferença é que ele vai expor uma URI, para que
a aplicação y tenha acesso. O web service vai fazer uma troca
de mensagem, através de:
        * XML, JSON e outras linguagens.

Exemplo de XML:
    <endereco>
        <cep>9999-99</cep>
        <bairro>Jardim Paulista</bairro>
        <logradouro>Av. Paulista</logradouro>
        <cidade>São Paulo</cidade>
        <numero>99</numero>    
    </endereco>

Exemplo: 
    {
        "endereco":{
            "cep"       : "99999-99",
            "logradouro": "Av. Paulista",
            "bairro"    : "<NAME>",
            "cidade"    : "São Paulo",
            "numero"    : 99
        }
    }

## Vantagens
    * Linguagem comum
    * Integração
    * Reutilização de implementação
    * Segurança
    * Custos

## Principais Tecnologias
    * SOAP
    * REST
    * XML
    * JSON
<file_sep>/Arquitetura_Sistema/Aula01/5-parte.md
## Código de Estado

    * Usado pelo servidor para avisar o cliente sobre o 
    estado da operação solicitada
    * 1xx - Informativo
    * 2xx - Sucesso
    * 3xx - Redirecionamento
    * 4xx - Erro do Cliente
    * 5xx - Erro do Servidor



<file_sep>/Introducao_JavaScript/JavaScript_ES6_essicial/script/Aula02-Parte2/1-comparacao.js
// Igual (== )
// Retorna verdadeiro caso os opernados sejam iguais. -3 == var1
'3' == var1
3 == '3'

// Não igual (!=)
// Retorna verdadeiro caso os operandos não sejam iguais. -var1 != 4 
var2 != '3'

// Estritamente igual (===)
// Retorna verdadeiro caso os oerando sem iguais e do mesmo tipo. Vejam tambem objct. is e igualdade
3 === var1

// Estritamente não igual (!==)
// Retorna verdadeiro aso os operandos não sejam iguais e/ou não sejam do mesmo tipo
var1 !== 3
3 !== '3'

// Maior que (>)
// retorna verdadeiro caso o operando da esquerda seja maior que o da direitia
var2 > var1
"12" > 2

// Maior que ou igual (>=)
// Retorna verdadeiro caso o operando da esquerda seja maior ou igual ao da direita
var2 = var1
var1 >= 3

// Menor que (<)
// Retonra vverdaeiro caso o operando da esquerda seja menor que o da deireita
var1 < var2
'12' < '2'

// Menor que ou igual (<=)
// Retorna verdadeiro caso o operando da esquerda seja menor ou igual ao da direita
var1 <= var2
<file_sep>/Introducao_JavaScript/JavaScript_ES6_essicial/script/Aula03/2-Parte/factory.js
// Exemplo de uma função que não é factory
function FakeUser1(){
    this.name = 'Lucas';
    this.lastName = 'Santos';
}

const user = new FakeUser1();

// exemplo de factory
function FakeUser2(){
    return {
        name: 'Lucas',
        lastName: 'Santos'
    }
}

const user2 = FakeUser2();

<file_sep>/Linux/Aula01.md
# Requisitos Básicos

    Processador dual core de 2 GHz ou Superior
    2 GB de memória RAM
    40 GB de espaço livre no disco rígido

## Parte 1 - Historico
### Fundamentos de Linux
    Criado em 1991 por Linux Torvalds
    O Linux é o Kernel Ou Núcleo do Sistema Operacional

    HardWare --> Kernel(Linux) --> Shell(linha de comandos)

    O Linux não é o sistema operacional, ele é o Kernel, quem dá a vida pro sistema operacional

    É desenvolvido por diversas pessas e empresas ao 
    redor do mundo

    Multitarefa/Multiusuário

    Existe várias versões do kernel linux e existe 
    vários sistemas operacionais criado no linux

## Fundamentos de Linux Distribuições
    O Linux pode ser "distribuído" por empresas 
organizações ou mesmo pessoas, que podem colocar 
características próprias no S.O, como configurações,
aplicações, sistema de instalação entre outras 
peculiaridades, assim damos o nome de distribuição, 
sua escolha é pessoal e depende da aplicação.

## Distribuições mais conhecidas:
    - Ubuntu
    - Debian 
    - Suse
    - fedora
    - Red Hat
    - Kali
## O Sistema Operacional Ubuntu
    O Ubuntu é um S.O de código aberto que é 
desenvolvido pela Canonical com base no Kernel Linux,
tem bases non Debian e Hoje é muito aceito por muitas
comunidades de usuários.





























<file_sep>/Introducao_JavaScript/JavaScript_ES6_essicial/Anotaçoes/Aula03-Parte2.md
# Design patterns

### Definição
    Design Patterns ou padrões de projetos são soluções 
generalistas para problemas recorrentes durante o 
desenvolvimento de um software. Não se trata de um framework 
ou um código pronto, mas de uma definição de alto nível de 
como um problema comum pode ser solucionado.

### A Pattern Language 
    - 1978
    - <NAME>, <NAME> e <NAME>
    - 253 tipos de problemas/desafios de projetos
### Formato de um pattern
    - Nome
    - Exemplo
    - Contexto
    - Problema
    - Solução

### Using Pattern Languages for Object-Oriented Programs
    - 1987
    - <NAME> e <NAME>
    - 5 padrões de projetos

### Design Patterns: Elements of Reusable Object-Oriented Software
    - 1994
    - Gang of Four(GoF)
    - <NAME>, <NAME>, <NAME> e <NAME>

### Tipos
    - Criação
    - Estruturais
    - Comportamentais

#### Padrões de criação
    Os padrões de criação são aqueles que abstraem e/ou adiam
o processo criação dos objetos. Eles ajudam a tornar um 
sistema independente de como seus objetos são criados, 
compostos e representados.
    - Abstrat Factory
    - Builder
    - Factory Method 
    - Prototype 
    - Singleton

#### Padroes estruturais
    Os padrões estruturais se preocupam com a forma como 
classes e objetos são compostos para formar estruturas 
maiores.
   - Adapter
   - Bridge
   - Composite
   - Decorator
   - Facade
   - Business Delegate
   - Flyweight
   - Proxy 
#### Padrões comportamentais
    Os padrões de comportamento se concentram nos algoritmos e
atribuições de responsabilidades entre os objetos. Eles não 
descrevem apenas padrões de objetos ou de classses, mas 
também os padrões de comunicação entre os objetos.
    - Charin of Responsibility
    - Command 
    - Interpreter 
    - Iterator
    - Mediator
    - Observer
    - State
    - Strategy
    - Template Method
    - Visitor

### Patterns mais utilizados
    - Factory
    - Singleton
    - Decorator
    - Observeer 
    - Module

#### Factory
    Todas as funções que retornam um objeto, sem anecessidade 
de chamá-las com o new, são consideradas funções Factory
(fabrica).
    - Exemplo do que não é uma função factory
    function FakeUser(){
        this.name: 'Lucas';
        this.lastName: 'Santos'
    }
    const user = new FakeUser();
    - Exemplo de factory
    Function FakeUser(){
        return{
            name: 'Lucas',
            lastName: 'Santos'
        }
    }
    // Factory
    const user = FakeUser();
#### Singleton
    O objetivo desse patterns é criar uma única instância de
uma função construtora e retorná-la toda vez em que for 
necessário utilizá-la.
    Exemplos:
        var SETTINGS = {
            api: 'http://localhost',
            trackJsToken: '<PASSWORD>'
        }
        function MyApp(){
            if(!MyApp.instance){
                MyApp.instance = this;
            }
            return MyApp.instance;
        }
#### Decorator
    Uma função decorator recebe uma outra função como 
parâmetro e estende o seu comportamento sem modificá-la 
explicitamente.

#### Observeer 
    É um pattrn muito popular em aplicações javascript. A
instância(subscriber) mantém uma coleção de objetos 
(observers) e notifica todas eles quando ocorrem mudanças 
no estado.

#### Module
    É um pattern que possibilita organizarmos melhor o nosso
código, sem a necessidade de expor variáveis globais.

<file_sep>/Projeto_Netflix/js/owl/teste.js
let x = 500.0;
let y = 35.0

const precisao = 1000;
let valor = x / y;



console.log(((valor * precisao)/precisao).toFixed(3));
<file_sep>/Arquitetura_Sistema/Aula03/3-parte.md
## A flexibilidade dos tópicos
    * protocolo: mqtt
    * ://
    * broker: broker.io
    * / 
    * user identifier: a6g319
    * /
    * sensor: gps
    * /
    * Information Type: position

#### publish
    * pub mqtt://broker/a6fb45/gps/position

#### subscribe
    * mqtt://broker/user/gps/position

Temos que ter alguns níveis de garantia que esse protocolo vai
funcionar

#### QoS 0
                    Publish
    MQTT Client     --->        MQTT Broker

    * Nível mínimo de menor esforço
    * Sem garantia de entrega
    * Mensagem não é retransmitida
#### QoS 1
                    Publish
    MQTT Client     --->        MQTT Broker
                    Puback
    * Garante que a mensagem foi entregue no mínimo uma vez 
    ao recebedor
    * Mensagem pode ser retransmitida se não houver 
    confirmação de entrega

#### QoS 2
   +-----------+     Publish ->       +-------------+
   |MQTT Client|     Pubrec  <-       | MQTT Broker |
   +-----------+     Pubrel  ->       +-------------+
                     Pubcamp <-
    * Garante que a mensagem foi entregue no minimo uma vez 
    ao recebedor
    * Mensagem pode ser retransmitida se não houver 
    confirmação de entrega.

## Cloud
    * Grande e cada vez maior número de devices conectados
    * TBs ou PBs de informações
    * Potencial de escala global


         worker -> Data store
        /
broker 
        \
         worker -> cache -> tela

worker é a minha aplicação, meu codigo
