Conheça o Callback Hell e como evitá-lo

Conheça o Callback Hell

JavaScript assíncrono, ou JavaScript que usa callbacks, é complicado de acertar intuitivamente. A causa do call-back hell é quando as pessoas escrevem JavaScript de uma maneira que ocorre a execução de cima para baixo, visualmente falando. Em algumas outras linguagens, como C, Python, existe a expectativa de que o que quer que aconteça na linha 1, tenha que terminar antes que o código da linha 2 execute, e assim por diante. Mas no JavaScript, isso funciona de uma maneira diferente.

O que são Callbacks?

São apenas o nome de uma convenção para o uso de funções JavaScript. Não existe nada chamado “callback” no JavaScript, sendo apenas uma convenção. Em vez de utilizar retorno imediato como a maioria das funções. As funções call-back demoram algum tempo para produzir resultados. A palavra “assincronismo”, conhecida no JavaScript como “async”, significa “demora algum tempo / acontece no futuro”.

Quando você chama uma função normal, pode usar seu valor de retorno:

let resultado = multiplicarDoisNumeros(5, 10);

console.log(resultado);

No entanto, funções assíncronas e que usam call-backs não retornam nada imediatamente:

let foto = downloadFoto('http://coolcats.com/cat.gif')

// foto é 'undefined'!

Nesse caso, o gif pode demorar muito para ser baixado e você não deseja que seu programa seja pausado enquanto aguarda a conclusão do download. Em vez disso, você armazena o código que deve ser executado logo após a conclusão do download em uma função. Este é o callback. Você executa a função downloadFoto e ele executará seu callback, quando o download estiver concluído e passará a foto (ou um erro se algo der errado).

downloadFoto('http://coolcats.com/cat.gif', lidarComFoto)

function lidarComFoto (error, foto) {
  if (error) console.error('Erro de Download!', error)
  else console.log('Download finished', foto)
}

console.log('Download iniciado')

Como podemos evitar o callback hell?

  1. Mantenha seu código limpo:

Callback hell geralmente é causado por más práticas de codificação. Escreva melhor o seu código e não passará trabalho.

let form = document.querySelector('form');
form.onsubmit = function formSubmit (submitEvent) {
    let name = document.querySelector('input').value;
    request({
        uri: "http://example.com/upload",
  body: name,
        method: "POST"
        }, function postResponse (err, response, body) {
        let statusMessage = document.querySelector('.status');
  if (err) return statusMessage.value = err;
  statusMessage.value = body;
    })
}

Nomear funções é uma prática benéfica e facilita a leitura do código.

Agora podemos mover as funções para o nível superior do nosso programa:

document.querySelector('form').onsubmit = formSubmit;

function formSubmit (submitEvent) {
  let name = document.querySelector('input').value;
  request({
    uri: "http://example.com/upload",
    body: name,
    method: "POST"
  }, postResponse)
}

function postResponse (err, response, body) {
  let statusMessage = document.querySelector('.status');
  if (err) return statusMessage.value = err;
  statusMessage.value = body
}
  1. Modularize:

Segundo Isaac Schlueter (do projeto Node.js): “Escreva pequenos módulos que cada um faz uma coisa e monte-os em outros módulos que fazem uma coisa maior. Você não terá um callback hell se não for lá”.

Criando um módulo, ficaria assim:

module.exports.submit = formSubmit

function formSubmit (submitEvent) {
  let name = document.querySelector('input').value;
  request({
    uri: "http://example.com/upload",
    body: name,
    method: "POST"
  }, postResponse)
}

function postResponse (err, response, body) {
  let statusMessage = document.querySelector('.status');
  if (err) return statusMessage.value = err;
  statusMessage.value = body;
}
  1. Lide com todos os erros:

Existem diferentes tipos de erros: de sintaxe, de runtime, erro de permissões, falha no disco rígido, entre outros. Ao lidar com callbacks, você, por definição, está lidando com tarefas despachadas, executa algo em segundo plano e, em seguida, conclui com êxito ou aborta devido a alguma falha. Podemos manipular isso deixando o primeiro argumento da função callback reservada ao erro.

function lidarComFoto (error, foto) {
  if (error) console.error('Erro de Download!', error)
  else console.log('Download finished', foto)
}

Dito isto, sempre lide com todos os erros e mantenha seu código simples e limpo.

Para maiores informações, acesse o site: http://callbackhell.com/

Referências: http://callbackhell.com/

O que são e como criar Promises:

Você sabe o que são promises?

Promises vem do termo “promessa”, que representa um valor que pode estar disponível em algum momento no futuro, no presente, ou nunca estar disponível. Ele é um objeto utilizado em processamento assíncrono. Um promise representa um proxy para um valor não necessariamente conhecido, permitindo uma associação de métodos de tratamento para eventos em uma ação assíncrona na hipótese de sucesso ou falha, permitindo que o método assíncrono retorne uma “promessa” ao valor em algum momento no futuro.

Quais são os estados de um promise?

  • pending (estado: pendente): O promise ainda não foi rejeitada, nem realizada. É o estado inicial;
  •  fulfilled (estado: realizado): O promise obteve sucesso na operação;
  • rejected (estado: rejeitado): O promise falhou na operação;
  • settled (estado: estabelecido): O promise foi estabelecido. Significa que o promise foi realizado ou rejeitado.

Sintaxe:

new Promise (/* executor */ function (resolve, reject) { … });

O executor é uma função que recebe os argumentos resolve e reject. O executor é chamado antes que o construtor de Promise retorne o objeto criado. As funções resolve e reject, quando chamadas, resolvem ou rejeitam (respectivamente) a promessa. Quando estiver concluído o trabalho assíncrono, o executor chama as funções resolve ou reject para definir o estado da promise.

Uma promise pode se tornar realizada ou rejeitada. Com a ocorrência de algum desses estados, o método them do Promise é chamado, e ele chama o método associado ao estado (resolved ou rejected).

O que é composição?

São métodos encadeados. Isso pode ocorrer com os métodos Promise.prototype.then e Promise.prototype.catch, já que ambos retornam promises que podem ser encadeadas.

Métodos:

  • Promise.all(lista): Retorna uma promise que é resolvida quando todas as promises no argumento forem resolvidas ou rejeitada quando uma das promises do argumento for rejeitada. É um método útil para agregar resultados de múltiplas promises.
  • Promise.race(lista): Retorna uma promise que resolve ou rejeita assim que uma das promises do argumento resolve ou rejeita.
  • Promise.reject(motivo): Retorna um promise que foi rejeitado por algum motivo.
  • Promise.resolve(valor): Retorna um promise que foi resolvido com dado valor. Se o valor for thenable (possuindo um método then), a promise retornada seguirá este metodo. Caso contrário, a promise será realizada com o valor.

Criando uma promise:

// Vejamos se a mãe está feliz. Utilize true para sim e false para não
let maeEstaFeliz = false;

// primeira promise que criaremos
let ganharTelefoneNovo = new Promise(
    (resolve, reject) => {
        if (maeEstaFeliz) {
            let telefone = {
                marca: 'iPhone',
                cor: 'Branco'
            };
            resolve(telefone);
        } else {
            let razao = new Error('Mãe não está feliz');
            reject(razao);
        }

    }
);

// Agora criaremos a segunda promise
async function mostrarTelefoneNovo(telefone) {
    return new Promise(
        (resolve, reject) => {
            var message = 'Hey cara, eu tenho um novo ' +
                telefone.marca + ' ' + telefone.cor;

            resolve(message);
        }
    );
};

// chamando nossa promise
async function perguntarParaMae() {
    try {
        console.log('Antes de perguntar para a mãe');

        let telefone = await ganharTelefoneNovo;
        let message = await mostrarTelefoneNovo(telefone);

        console.log(message);
        console.log('Depois de perguntar para a mãe');
    }
    catch (error) {
        console.log(error.message);
    }
}

(async () => {
    await perguntarParaMae();
})();

Gostou deste artigo? Comente abaixo!

Referências:

 

Como criar eventos ao pressionar CTRL, ALT e SHIFT

Neste post rápido será visto como criar eventos para capturar quando o usuário pressiona CTRL, ALT ou SHIFT na tela do navegador. Aproveitando que isso já está sendo visto, também vamos testar algumas combinações de teclas.

A primeira parte que você precisa fazer é o evento. Você precisa dizer onde que deverá estar o foco na hora que foi apertado o botão, no nosso exemplo usaremos o document pois mais amplo que isso não tem como. Você pode usar o body ou até uma “zona” menor caso prefira.

 

JavaScript

document.addEventListener("keydown", function(event){});

 

JQuery

$(document).bind('keydown', function(event){ });

Note que estamos usando o evento “keydown”, isso é importante pois keypress e keyup não captura as teclas que queremos.


 

Agora vejamos sobre como saber o que foi clicado, você já deve ter tentado o key, keycode e which, mas nada aconteceu. Isso acontece pois precisamos acessar outras propriedades para saber se o CTRL, ALT ou SHIFT foram pressionados. Veja abaixo:

event.ctrlKey // CTRL

event.altKey // ALT

event.shiftKey // SHIFT

Simples assim? Sim, simples assim….

Então se quisermos saber quem foi pressionado, podemos fazer o seguinte:

 

JavaScript

document.addEventListener("keydown", function(event){

    if(event.ctrlKey) {
        console.log('ctrl');
    }

    if(event.altKey) {
        console.log('alt');
    }

    if(event.shiftKey) {
        console.log('shift');
    }
});

 

Para JQuery basta alterar a primeira linha por 

$(document).bind('keydown', function(event){

 

Por último, você pode estar querendo uma combinação, como por exemplo um CTRL + A. Agora que sabemos como pegar o CTRL, ficou fácil

document.addEventListener("keydown", function(event){

    if(event.ctrlKey && event.key == "a") {
        console.log('ctrl + a');
    }

});

 

É isso ai, espero que com esse post eu tenha ajudado outros que tiveram o mesmo problema para descobrir como criar estes eventos que combinam pressionar várias teclas. Até a próxima

Como quebrar um vetor grande em vários menores

Neste artigo veremos duas funções que leem um vetor e devolvem um outro dividido em pedaços menores. O exemplo será bem simples pois a aplicação é a mesma para 5 o para 5 bilhões de registros. 

A primeira função será genérica e você provavelmente poderá utilizá-la em outras linguagens com pouca ou nenhuma adaptação. Já a segunda é utilizando mais das funções do JavaScript para reduzir o código

Em resumo queremos que um vetor linear seja quebrado em vários pequenos vetores. No meu caso, eu precisava que uma lista de contatos fosse quebrada em diversas listas menores para facilitar o controle e atualização das mesmas.

Iremos de algo assim:

let vetor = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14];

Para algo assim:

let vetor = [[0, 1, 2], 
             [3, 4, 5], 
             [6, 7, 8], 
             [9, 10, 11], 
             [12, 13, 14], 
             [15, 16]];

Como podemos fazer isso? Bom, a primeira forma é a seguinte:

Algoritmo Genérico

  1. Criar a função e inicializar as variáveis. Observe que novoVetor é um vetor com um vetor vazio dentro dele.
    function converterVetor(vetor, tamanho) {
        let novoVetor = [[]];
        let novoIndice = 0;
        let novoIndiceSub = 0;
    }
  2. Criar um laço FOR para adicionar os elementos no novoVetor. Observe que:
    1. Precisamos de um IF para testar a hora de avançar de um sub-vetor para outro.
    2. Dentro deste IF é necessário criar um vetor em branco para que o Javascript saiba o tipo do dado.
    3. No final, você está adicionando o valor dentro de um vetor que está dentro de outro vetor, então é preciso usar [x][y] para adicionar na posição correta.
    for(let indice = 0; indice < vetor.length; indice++){
    
        if(indice % tamanho == 0 && indice != 0){
            novoIndice++;
            novoVetor[novoIndice] = [];
            novoIndiceSub = 0;
        }
    
        novoVetor[novoIndice][novoIndiceSub] = vetor[indice];
        novoIndiceSub++;
    }
  3. Por ultimo, basta retornar o resultado. Veja abaixo o código completo.
    function converterVetor(vetor, tamanho) {
        let novoVetor = [[]];
        let novoIndice = 0;
        let novoIndiceSub = 0;
    
    
        for (let indice = 0; indice < vetor.length; indice++) {
    
            if (indice % tamanho == 0 && indice != 0) {
                novoIndice++;
                novoVetor[novoIndice] = [];
                novoIndiceSub = 0;
            }
    
            novoVetor[novoIndice][novoIndiceSub] = vetor[indice];
            novoIndiceSub++;
        }
    
        return novoVetor;
    }

Usando mais recursos JavaScript

Agora vejamos a mesma função, mas usando mais recursos JavaScript para reduzir um pouco o trabalho.

  1. Iniciaremos de forma muito parecida, mas precisaremos de uma variável a menos
    function converterVetor2(vetor, tamanho) {
        let index = 0;
        let novoVetor = [];
    }
  2. Agora faremos o loop for, mas ao invés de percorremos o loop original de 1 em 1, percorreremos o tamanho que já queremos colocar no sub-vetor.
    1. Dentro do loop, usaremos a função slice() que nos retornará um pedaço do vetor. Sendo ele o tamanho exato do sub-vetor.
    2. Após, adicionamos o subVetor ao novo com o método push() que adiciona um elemento na ultima posição.
    for (index = 0; index < vetor.length; index += tamanho) {
        let subVetor = vetor.slice(index, index + tamanho);
        novoVetor.push(subVetor);
    }
  3. Pronto!! Basta retornar o objeto com o resultado. Segue abaixo o código completo.
    function converterVetor2(vetor, tamanho) {
        let index = 0;
        let novoVetor = [];
    
        for (index = 0; index < vetor.length; index += tamanho) {
            let subVetor = vetor.slice(index, index + tamanho);
            novoVetor.push(subVetor);
        }
    
        return novoVetor;
    }

Conclusão

Como você pode ver, o segundo formato é um pouco menos detalhado, mas utilizando os recursos do JavaScript é possível escrever menos código que ainda é fácil de entender. Por isso que, quando você estuda uma linguagem, é importante conhecer as funções nativas e formas mais inteligentes de trabalhar com seus objetos.

Mapa de Calor com AmCharts

Neste tutorial simples e rápido estarei mostrando como criar um gráfico de mapa de calor (heat map) com a biblioteca AmCharts.

Então vamos começar. Primeiro você precisará criar um arquivo HTML com as seguintes tags.

<html>
<head>
  <!-- Setar para utf-8 para evitar problemas nos caracteres especiais -->
  <meta charset="utf-8"/>
</head>
<body>

  <!-- Buscando bibliotecas direto do site da AmCharts -->
  <script src="https://www.amcharts.com/lib/4/core.js"></script>
  <script src="https://www.amcharts.com/lib/4/maps.js"></script>
  <script src="https://www.amcharts.com/lib/4/geodata/brazilLow.js"></script>

  <!-- Onde nosso gráfico será criado -->
  <div id="chartdiv"></div>
</body>
</html>

A explicação já esta inclusa nos comentários, mas resumidamente precisamos do utf-8 para não dar problema com estados que possuem acento no nome. As bibliotecas são chamadas do site para não precisar baixar nada.

Agora você pode criar uma tag script no final do HTML e colocar o código inline ou apontar para um arquivo JS externo. A escolha é sua.

Feito isso, precisaremos de uma fonte de dados. Para o nosso exemplo e de referência futura, você pode usar a lista abaixo. E ja peço desculpas pelo tamanho da lista, mas não quis minificar para ser fácil de entender.

let dados = [
  {
    "id" : "BR-AC",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-AL",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-AP",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-AM",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-BA",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-CE",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-DF",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-ES",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-GO",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-MA",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-MT",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-MS",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-MG",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-PA",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-PB",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-PR",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-PE",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-PI",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-RJ",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-RN",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-RS",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-RO",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-RR",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-SC",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-SP",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-SE",
    "value" : Math.floor(Math.random()*10000)
  },
  {
    "id" : "BR-TO",
    "value" : Math.floor(Math.random()*10000)
  }
];

Como você pode ver, a lista precisa de um ID com a abreviação BR-UF. Porque não apenas o UF? Porque deus quis assim…. kkkk… Eles provavelmente fazem uma separação de paises pois esta biblioteca permite criar mapas de qualquer pais do mundo. A segunda parte pode ser um número qualquer fixo, mas para nosso exemplo eu quis fazer com que fossem valores aleatórios até 10000.

Feito isso, adicione o código abaixo. É importante ler os cometários para entender o que e por que está acontecendo.

// Define o local e tipo de gráfico
let chart = am4core.create("chartdiv", am4maps.MapChart);


// Atribui o 'brazilLow' como o mapa
// Você pode optar pelo 'brazilHigh', basta alterar aqui e src do script no html
// Também define que as partes que montam o mapa serão com base no MapPolygonSeries
chart.geodata = am4geodata_brazilLow;
let polygonSeries = chart.series.push(new am4maps.MapPolygonSeries());
polygonSeries.data = dados;
polygonSeries.useGeodata = true;


// Preenche os dados para fazer o mapa de calor
// Faremos com que os menores valores sejam verdes e maiores sejam vermelhos
polygonSeries.heatRules.push({
  property: "fill",
  target: polygonSeries.mapPolygons.template,
  min: am4core.color("green"),
  max: am4core.color("red")
});


// Define as legendas, posição e cores.
let heatLegend = chart.createChild(am4maps.HeatLegend);
heatLegend.series = polygonSeries;
heatLegend.align = "right";
heatLegend.width = am4core.percent(25);
heatLegend.marginRight = am4core.percent(4);
heatLegend.minValue = 0;
heatLegend.maxValue = 10000;
heatLegend.valign = "bottom";


// Configuras os tooltips (texto ao passar o mouse)
let polygonTemplate = polygonSeries.mapPolygons.template;
polygonTemplate.tooltipText = "{name}: {value}";
polygonTemplate.nonScalingStroke = true;
polygonTemplate.strokeWidth = 0.5;


// Muda a cor do estado ao passar o mouse
let hs = polygonTemplate.states.create("hover");
hs.properties.fill = am4core.color("green").brighten(-0.5);

Isso ai, com isso você terá um mapa mais ou menos (pois muda a cada atualização) assim:

CheerpJ 2.0: Converta apps Java em JavaScript

Foi lançado o CheerpJ 2.0(https://leaningtech.com/pages/cheerpj.html) da Learning Techonologies (https://leaningtech.com). Com ele é possível converter aplicações web client em código HTML5/WebAssembly/JavaScript.

Como funciona?

  1. Compilação antecipada:
    • O compilador do CheerpJ processa o bytecode antecipadamente, gerando um código JavaScript otimizado que pode rodar em qualquer browser.
  2. Runtime CheerpJ:
    • Em paralelo com a aplicação convertida, ele executa um runtime altamente otimizado utilizando JavaScript e WebAssembly. Isso mantém a execução 100% no lado do cliente.
  3. Compilador Java online:
    • Sempre que uma nova classe for gerada, o CheerpJ a converte na hora.

O legal da tecnologia é que ela permite converter com o bytecode do Java, então você nem precisa ter o código fonte. Outra coisa importante é que ela é 100% compatível com o Java 8(incluindo reflections e classes dinâmicas). Isso torna possível trabalhar com client Swing, applets e bibliotecas.

Se você quiser ver alguns exemplos, acesse a página de demo do CheerpJ (https://leaningtech.com/pages/cheerpj_demos.html) . Se você preferir testar na prática, vale a pena acessar o code playground (https://javafiddle.leaningtech.com) e criar algumas aplicações para ver os resultados.

Nossos Cursos na Udemy

Precisando aprender JavaScript? Confira então nossos cursos na Udemy

Introdução ao JavaScript

Grátis!!
Curso para inicantes que desejam aprender os fundamentos da programação JavaScript
O que você aprenderá:
  • Variáveis
  • Condicionais
  • Loops
  • Funções
  • Tipos de Dados
O curso inclui
  • Vídeo sob demanda de 2 horas
  • 4 recursos para download
  • 8 exercícios de programação
  • Acesso total vitalício
  • Acesso no dispositivo móvel e na TV

 

JavaScript Básico

R$39,99

Aprenda JavaScript do zero, descubra como manipular websites e faça 2 projetos práticos

O que você aprenderá
  • Será ensinado dos fundamentos de JavaScript
  • Será capaz de manipular websites e apps
  • Conseguirá criar eventos para ações em para elementos HTML
O curso inclui
  • Vídeo sob demanda de 6,5 horas
  • 11 recursos para download
  • 28 exercícios de programação
  • Acesso total vitalício
  • Acesso no dispositivo móvel e na TV
  • Certificado de Conclusão

 

Atualização JavaScript: ES2019 e ES2020

R$39,99
Aprenda sobre as atualizações do ECMAScript 2019 e 2020
O que você aprenderá
  • Implementações do ECMAScript 2019
  • Implementações do ECMAScript 2020
O curso inclui
  • Vídeo sob demanda de 1 hora
  • 4 artigos
  • 2 recursos para download
  • Acesso total vitalício
  • Acesso no dispositivo móvel e na TV
  • Certificado de Conclusão

 

Introdução ao jQuery

Grátis!!

Aprenda do zero sobre as funcionalidades essenciais do jQuery
O que você aprenderá
  • Fundamentos de jQuery
  • Criação de eventos
  • Manipulação do DOM
  • Animações simples
O curso inclui
  • Vídeo sob demanda de 1,5 horas
  • Acesso total vitalício
  • Acesso no dispositivo móvel e na TV

 

JQuery Prático

R$39,99

Aprenda sobre os métodos mais comuns do JQuery e JQuery UI que você encontrará na vida real

O que você aprenderá
  • Fundamentos de JQuery
  • Os métodos do JQuery mais utilizados em websites
  • Jquery UI
Este curso inclui
  • Vídeo sob demanda de 3,5 horas
  • 2 artigos
  • 1 recurso para download
  • 14 exercícios de programação
  • Acesso total vitalício
  • Acesso no dispositivo móvel e na TV
  • Certificado de Conclusão

JavaScript é a linguagem mais demandada

JavaScript é a linguagem mais exigida em 2020, segundo um relatório da DevSkiller, o JavaScript substitui o Java na comparação com o relatório do ano anterior. Sendo que agora o SQL está em segundo lugar e ele caiu de primeiro para terceiro.

O crescimento na popularidade do JavaScript mostra que existe uma grande necessidades dos desenvolvedores de criar aplicativos web em contraste com o declínio de grandes sistemas focados no back-end.

Segue abaixo as 5 linguagens mais procuradas:

  1. JavaScript
  2. SQL
  3. Java
  4. HTML/CSS
  5. .NET/C#

Outras observações que são importantes destacar:

  • 72% das empresas procurando estão procurando por desenvolvedores com conhecimento de JavaScript. Seguido por 55% que estão procurando profissionais com conhecimentos de SQL e 53% de desenvolvedores Java.
  • React, Spring, ASP.NET, MySQL e HTML são as tecnologias mais populares para as linguagens mais populares.
  • Para desenvolvedores Python, análise de dados é o termo mais comum sendo procurado. Seguido por Django e NumPy.

Dicas para iniciar como Desenvolvedor

Neste artigo vou listar coisas que, na minha experiência, foram importantes para iniciar no mundo do desenvolvimento de sistemas. O que estou falando não é uma regra universal, mas apenas dicas de coisas que me aprendi nos últimos 10 anos atuando na área. 

Você vai notar que eu não vou falar muito de tecnologia, pois isso seria ensinar o padre a rezar a missa. E sei lá, enquanto você estiver lendo isso pode ser que elas mudem, então acredito que vale a pena ser mais genérico nesta parte. Muito bem, vamos lá

 

1) Gostar de programar

Esse parece ser meio óbvio, mas tem gente que quer o salário de tal desenvolvedor, quer ser o próximo Steve Jobs ou quer ser um nerd cientista. Nenhuma das razões acima é gostar de programar. Se você estiver na dúvida se gosta ou não, pense no seguinte:

  • Você monta apps por conta própria (sem alguém mandar ou pagar)?
  • Você fica feliz quando aprende ou entende um código?
  • Você perde a noção do tempo programando?
  • Você vai atrás do conhecimento porque gosta?

 

Se pelo menos um dos acima for sim é porque você provavelmente gosta de programar. Agora, se:

  • Você só programa se for obrigado ou pago.
  • Você não tem vontade de terminar qualquer projeto.
  • Rodou em algoritmos, estrutura de dados, lógica de programação por falta de interesse.
  • No tempo livre, entre programar e fazer qualquer outra coisa, você faz outra coisa.

Cara, ta na hora de pensar bem se é isso que você quer para o resto da sua vida.

2) Iniciativa

Se você se encaixou nos itens positivos acima, isso aqui pode ser repetição do que falei no item 1. Não espere os outros pedirem projetos nas áreas que você gosta, comece a fazê-los, mesmo que simples. Ninguém começa com o melhor e mais avançado projeto que fará em sua vida.

  • Quer ser um desenvolvedor front end? Faça projetos de sites e mini apps mobile.
  • Quer ser um desenvolvedor back end? Cruds, um site com login que não faz mais nada.
  • Quer ser um desenvolvedor de banco? Você é louco, mas todo mundo é um pouco. Crie bancos e monte as triggers, constraints, etc… para testar seus conhecimentos.

O que quero dizer aqui, não espere alguém sentar com você e pedir para que você faça o básico. Estude, teste, quebre, xingue que amanhã o problema parecerá tão simples.

 

3) Escolhendo a empresa 

Este item é tão importante (ou mais) que conseguir a vaga. Você já deve ter visto, ou verá, que existem empresas com vagas de estágio pedindo experiência ou conhecimentos de alguma coisa. Neste caso, existem 2 situações:

  1. O conhecimento é aquele que se aprende em 1 mês de curso online, na faculdade ou até com vídeo aulas do youtube. Essas empresas querem alguém que goste de programar e que vá atrás da informação. Se você atende ao “Gostar de programar” não deveria ser problema e sim um filtro para reduzir a sua concorrência.
  2. A empresa quer um desenvolvedor pelo salário de estagiário, pois não tem dinheiro para pagar um dev ou não quer pagar o valor correto. Essa pessoa normalmente já terá que produzir muito. Cara “ALERTA VERMELHO”
    1. Eles não valorizam o seu trabalho.
    2. Se tem dinheiro para pagar mais, não vão. Por isso a vaga de estagiário. Se não tem, como que vão te promover um dia? Pagando do bolso?

 

4) Entrevista

Nem tenha vergonha por estar começando, se esse não der certo, o outro vai. Mostre muito dos itens 1 e 2 que isso certamente fará diferença entre você e o carinha que quer receber para aprender o crud básico com alguém sentado do lado explicando.

Novamente, não estou dizendo que você não deve aprender no ambiente de trabalho e que o trabalho não deve ensinar você. Mas, se você chegar dizendo:

  •  “isso eu sei pois fiz um projeto e subi para o git, como que eu faço a próxima parte?”

é bem melhor que:

  •  “Certo, abrir a IDE, como que eu abro um projeto?”.

Você consegue ver a diferença?

 

Terminando

Então era isso, espero que alguém se beneficie lendo este post. Seja para entrar no ramo ou descobrir que outros são mais interessantes. Boa sorte.

Phaser.js #7 – Criando jogo Final!

Estamos chegando ao final de nosso projeto com Phaser pessoal! Lembrando que vocês podem acessar o projeto original em inglês na documentação diretamente no site do Phaser (deixarei o link no final do post).

Pontuação

O que é um jogo sem uma pontuação, não é mesmo? Como saberemos quantas estrelas coletamos?

Para isso, precisamos criar um objeto de jogo de texto. Vamos criar duas variáveis para conter uma pontuação e o objeto de texto:

var score = 0;
var scoreText;

O scoreText será configurado na função create():

scoreText = this.add.text(16, 16, 'score: 0', { fontSize: '32px', fill: '#000' });

A coordenada que exibiremos o texto score: 0 é na 16×16. A fonte padrão de textos do Phaser é a Courier.

Agora, precisamos modificar a função collectStar para que, quando o player coletar uma estrela, o contador seja aumentado, adicionando o nosso score:

function collectStar (player, star)
{
    star.disableBody(true, true);

    score += 10;
    scoreText.setText('Score: ' + score);
}

Deste modo, cada vez que coletamos uma estrela, o nosso contador, que é a variável score, é incrementada em 10, ou seja, a cada estrela coletada, +10 pontos para você 🙂

Você pode verificar isso no seu arquivo part9.html!

Continue lendo “Phaser.js #7 – Criando jogo Final!”