Em uma das reuniões dessa última semana na empresa onde trabalho surgiu uma necessidade simples de comunicação: Precisamos que toda a equipe saiba quando um novo release de algum dos nossos repositórios for criado no Github.
Como usamos o Slack como ferramenta de comunicação interna, na hora já pensei:
“Esta é a minha chance de criar um bot para o Slack!”
Sempre tive vontade de fazer algo para o Slack, mas não tinha conseguido achar um tempo e nem um motivo específico para isso. Eu já imaginava que para esse objetivo, avisar sobre um novo release, não seria algo complicado.
Realmente não foi. Em apenas algumas linhas deu pra criar um bot que conecta os webhooks do Github e do Slack utilizando o Flask como meio-campo.
Abaixo o código final da primeira versão.
# coding: utf-8
import os
import requests
from flask import Flask
from flask import request
app = Flask(__name__)
slack_webhook_url = os.getenv('SLACK_WEBHOOK_URL')
@app.route("/", methods=['POST', ])
def webhook():
action = request.json['action']
release = request.json['release']
repository = request.json['repository']
slack_data = {
"text": "A new release from *{repo_name}* was {action}!\n"
"Click <{release_url}|Release {tag_name}> for more details".format(action=action,
repo_name=repository['name'],
release_url=release['url'],
tag_name=release['tag_name'])
}
response = requests.post(slack_webhook_url, json=slack_data)
if response.status_code != 200:
raise ValueError(
'Request to slack returned an error {}, the response is:\n{}'.format(response.status_code,
response.text)
)
return ""
Pelo pouco tempo que passei lendo sobre como fazer um bot para o Slack eu entendi que você cadastra um Incoming Webhook e eles geram uma URL a qual você irá executar um request do tipo POST enviando a mensagem que você quer que um canal específico receba.
É realmente muito simples, porque a própria URL já carrega os tokens que são gerados para você.
Existem diversas outras funcionalidades que podem ser criadas em um bot para o Slack e a documentação deles cobre tudo. Mas vou falar apenas desse pequeno release-alert que criei.
Explicando linha por linha
Antes de começar a escrever o código vou precisar do Flask e de alguns outros pacotes. Então começo ainda na linha de comando do shell.
$ pip install Flask
$ pip install requests
Depois eu coloco a URL que gerei no Incoming Webhooks do Slack em uma variável de ambiente que chamo de SLACK_WEBHOOK_URL. Depois basta importá-la para dentro do código.
$ export SLACK_WEBHOOK_URL=<aqui vai a url do webhook do slack>
Agora crio meu arquivo Python chamado bot.py. Como estou usando o Flask, só vou precisar desse arquivo e praticamente nada mais.
Nas primeiras linhas começo importando o que vou utilizar e criando o app do Flask.
import os
import requests
from flask import Flask
from flask import request
app = Flask(__name__)
Trago para dentro do código a variável de ambiente que criei antes.
Agora vou começar a montar o meu endpoint. Ele receberá um evento POST enviado pelo webhook do Github. Para que isso aconteça você precisa cadastrar uma URL de webhook no settings do seu projeto no Github.
No meu caso, eu cadastrei a webhook no settings da organização, já que queria que todos os projetos da empresa disparassem o aviso. Mas funciona do mesmo jeito em qualquer um dos casos.
Quando cadastrei o meu webhook no Github especifiquei que gostaria de receber apenas os eventos relacionados ao release dos projetos.
Para testar o código localmente eu utilizei o ngrok. Explico como usar o ngrok em outra publicação.
O Flask facilita recuperar informações de um corpo de um request JSON com o seu objeto request nativo. Basta chamar request.json e ele retorna um dicionário.
Agora eu vou montar o corpo da mensagem que enviarei para o Slack. O formato pedido é muito simples: um JSON com um campo ‘text’.
slack_data = {
"text": "A new release from *{repo_name}* was {action}!\n"
"Click <{release_url}|Release {tag_name}> for more details".format(action=action,
repo_name=repository['name'],
release_url=release['url'],
tag_name=release['tag_name'])
}
Esse dicionário será transformado em um JSON pela próxima linha. O pacote requests já resolve isso para mim através do argumento json.
response = requests.post(slack_webhook_url, json=slack_data)
if response.status_code != 200:
raise ValueError(
'Request to slack returned an error {}, the response is:\n{}'.format(response.status_code,
response.text)
)
return ""
No final do arquivo estou apenas tratando algum possível erro. Caso o requests retorne um status_code diferente de 200 eu levanto uma exceção.
No final retorno uma string vazia, porque cada endpoint do Flask precisa retornar alguma coisa para não levantar erros.
Para que meu bot fique disponível o tempo todo, fiz um deploy na minha conta gratuita do Heroku. E voilá!
Essa é para quem está começando ou quer começar na área de desenvolvimento de software
Existe uma visão distorcida da realidade desse profissional de tecnologia da informação que escreve códigos e desenvolve sistemas.
Um Analista de Sistemas em início de carreira, por exemplo, tem salário médio de R$ 4,2 mil. Em três anos, sua média salarial pode chegar a R$ 7 mil. Com mais de dez anos de experiência, sua remuneração alcança R$ 17 mil. Isso sem falar nas possibilidades de especialização: um profissional de TI no Brasil com mestrado recebe o piso salarial médio de R$ 9,2 mil e um Diretor Técnico e de Operações do mercado de tecnologia pode ganhar até R$ 50 mil. Fonte: Terra em 22/12/2016
Início de carreira com mais de quatro mil reais e em apenas três anos já estar ganhando sete mil… essa não é a realidade da maioria dos profissionais de TI que conheço. Eu tenho mais de 10 anos de carreira e ainda não cheguei perto dos 17 mil… o que é uma pena!
Quem sabe essa matéria levou em conta apenas aqueles que trabalham em regime PJ e não os que tem carteira assinada… de qualquer forma, não me parece algo tão realista.
Pessoalmente me preocupa que essa visão seja disseminada e possa levar pessoas a buscar essa área apenas pela possibilidade de ganhar muito dinheiro, algo que não acontece com tanta frequência.
Vamos começar pelo começo: Não existe apenas “o programador”, assim como não há apenas “o médico” e “o advogado”.
Existem diversas áreas de programação como desenvolvimento mobile, backend, frontend, o faz-tudo (chamado de full stack por quem quer ser chique), etc.
Além das áreas, ainda existem as tecnologias específicas. As linguagens de programação, os sistemas operacionais, os frameworks, as metodologias de desenvolvimento… tudo isso conta para saber quanto vai faturar um desenvolvedor.
Outro ponto importante é em qual cidade você vai trabalhar. Existe uma probabilidade maior para o programador ganhar mais se morar em alguns polos de tecnologia do país, principalmente em São Paulo, graças à lei da oferta/demanda. Muitas empresas precisando de profissionais e nem tantos disponíveis. Isso não quer dizer que não existam programadores ganhando pouco nessas cidades…
Para finalizar, mas não se limitando a isso, o tipo de empresa em que o programador trabalha também influencia, e muito, no seu salário. Startups, fábricas de software, pequenas empresas de desenvolvimento, agências, grandes bancos, etc.
Que tal alguns “estudos de caso” para exemplificar. Começando pelo mais comum…
Um programador júnior trabalhando em uma startup, provavelmente um full-stack, ganha um salário mediano ou até abaixo do mercado.
E um de quem pode estar faturando legal.
Uma empresa em que o produto é um aplicativo, por exemplo, que tem uma VC investindo milhões. Sendo um sênior em uma equipe de desenvolvimento iOS… Sim, esse daí deve estar ganhando muito bem, para os padrões brasileiros.
Esses são alguns pontos que gosto de levantar toda vez que alguém me pergunta quanto ganha um desenvolvedor de software.
Obviamente estes são pontos de vista que obtive durante anos como andarilho nesse mercado e podem diferir de outros profissionais tão ou mais experientes.
Eu adoro ler sobre tecnologia e sua indústria pela internet a fora. É muito bom para descobrir algumas tendências e aprender sobre minha área de atuação.
Mas eu tenho notado um certo exagero em algumas publicações de nicho.
Alguns autores parecem querer reforçar que você precisa aprender essa ou aquela tecnologia porque é a única coisa que vai existir no futuro!
“Essa é a tecnologia que irá acabar com/substituir o que você usa hoje. Esteja pronto!”
Para ilustrar melhor o que quero dizer vou dar alguns exemplos.
Quando comecei a me informar sobre chatbots a primeira coisa que li nos textos do pessoal que já estava envolvido com isso é que os bots tomariam o lugar dos aplicativos mobile e até mesmo dos sites.
Afirmam isso com base em informações relevantes mesmo, como pesquisas que mostram que nos EUA as pessoas não estão mais baixando novos apps. Não é uma invenção, me parece apenas uma interpretação exagerada dessas informações.
Um tempo depois eu achei uma publicação que falava sobre arquitetura serverless. Lá o discurso era que em cinco anos ninguém mais estaria usando servidores.
Quando você faz parte de um nicho é muito fácil se deixar levar por opiniões exageradas em favor do que você está envolvido. Entretanto é preciso ser mais objetivo.
É claro que os chatbots podem assumir uma boa fatia de mercado dos aplicativos nativos (e vão, afinal eu sou um entusiasta ;D), mas não vão simplesmente acabar com eles do dia para a noite.
A mesma coisa para a arquitetura serverless… ninguém mais usando servidores em cinco anos? Um pouco exagerado, não acha?
Esses são apenas alguns exemplos, mas ainda podemos voltar um pouco no tempo e lembrar de algumas ondas que diziam que os aplicativos nativos seriam totalmente substituídos pelos híbridos e, já hoje em dia, substituídos pelos progressive webapps ou chatbots…
Que tal voltar ainda mais, lá no começo da minha carreira nos grupos de Software Livre, onde achávamos que em breve os computadores com Windows seriam minoria perto dos usuários Linux… E quinze anos depois:
Market share de sistemas operacionais
Mesmo que a tecnologia seja muito rápida em sua evolução, dificilmente uma coisa mata outra tão rápido quanto as postagens que geram o hype afirmam.
Isso acontece porque cada negócio tem uma necessidade diferente, então cada tecnologia pode ser a melhor opção para cada tipo de necessidade. Uma não necessariamente mata outra. E não precisa matar!
Para que uma coisa seja boa ela não tem que destruir outra. Existe espaço, e até a necessidade, para tudo!
Eu escrevi o rascunho deste texto dentro de um Cabify, uso Uber com frequência e adivinha só: ainda existem muitos táxis por aí.
Se você gosta de algo e participa de um grupo sobre isso, como eu com chatbots por exemplo, seja um entusiasta sim! Discuta sobre, aposte nisso, mas mantenha os pés no chão. Entenda que o que você faz/gosta pode ser um ótimo martelo, mas nem tudo é prego.
Nem Machine Learning e Processamento de Linguagem Natural
Todo mundo que trabalha com desenvolvimento de software sabe que, cada vez mais, existem as “expressões do momento” no mercado. É por isso que eu adoro o texto Hype Driven Development…
Uma das mais faladas “expressões do momento” é a inteligência artificial. Ela está em todo lugar, em todas as matérias nas mídias e diversos artigos acadêmicos e começou a ficar extremamente popular no último ano.
Cuidado! Inteligência artificial vai roubar seu emprego!
Depois que o Facebook resolveu liberar os chatbots para sua plataforma de mensagens, chatbot também virou uma expressão do momento. Eu mesmo gostava do assunto antes, mas a partir do ano passado comecei a estudar e aprender ainda mais sobre esse tipo de software.
A partir daí todo lugar onde se vê a palavra chatbot também se vê inteligência artificial. É uma questão bem óbvia, afinal para um robô falar com um humano, ele precisa ter o mínimo de inteligência…
Mas será mesmo que preciso saber criar inteligência artificial para criar um chatbot?
Chatbots são serviços baseados em regras e (às vezes) inteligência artificial, onde você pode conversar e interagir através de aplicações/aplicativos de mensagens.
A parte importante dessa citação são as palavras entre parênteses: às vezes.
Como ele explica no texto, existem dois tipos de chatbots. Os baseados em regras e os baseados em inteligência artificial. A maioria dos bots que encontramos por aí é puramente baseado em regras e eles não são ruins por causa disso.
As plataformas de mensagens oferecem diversas maneiras para que o usuário posso interagir com o bot. São botões, listas com links, webviews que abrem uma página externa, etc. Utilizando essas interações fica muito fácil saber o que o usuário quer fazer, sem necessidade de inteligência artificial.
Você não precisa fazer com que o bot tenha um entendimento profundo da lingua portuguesa e entenda cada detalhe de tudo que o usuário está falando para que ele cumpra o que propõe.
Um bot tem que ter uma naturalidade na interação, mas isso depende muito mais do design da conversação do que de inteligência artificial.
Um chatbot é um software. A tecnologia que você vai usar no seu desenvolvimento precisa ser compatível com as necessidades das funcionalidades dele.
Machine Learning, Processamento de Linguagem Natural (NLP) e Inteligência Artificial (AI) são importantes para os mais diversos tipos de aplicações, mas para aquelas que realmente necessitam dessas tecnologias.
Se o bot precisa aprender com dados e interações para melhor atender o usuário e cumprir o objetivo proposto, então Machine Learning é necessário. Se ele precisa classificar textos que o usuário venha a enviar, você vai precisar de NLP… e assim por diante.
Agora se ele fala informações sobre o clima, não precisa ser “inteligente” para bater papo com o usuário ou aprender com as interações. Afinal o objetivo dele é previsão do tempo! Ele só precisa saber onde o usuário está ou de onde ele quer saber a previsão.
Outro grande problema desse hype todo é que essas expressões técnicas assustam quem não conhece e podem acabar afastando pessoas interessadas na construção de chatbots por acharem que é um impeditivo não saber essas tecnologias.
O hype é algo que sempre existirá, mas não devemos nos guiar por ele. Pense no objetivo que o seu chatbot terá e nas funcionalidades que serão necessárias para atingí-lo. Se ele realmente precisar de Inteligência Artificial, então pare de ler e vá estudar matemática agora!
Um tempo atrás eu quis falar sobre chatbots na empresa onde trabalho. Temos um evento interno para compartilhar conhecimento, que começou há pouco tempo por aqui, e aproveitei a chance para mostrar para meus colegas como desenvolver e quais eram as ferramentas que o Messenger do Facebook oferece para a criação de um robô de conversa. Para meu lightning talk resolvi criar um chatbot experimental chamado Climão.
O Climão é um bot bem simples e apenas recebe a localização da pessoa e informa como está o clima no local.
Para isso eu usei um dos templates do Facebook Messenger que cria um botão para o usuário enviar a localização e fiz uma busca em uma API aberta de informações meteorológicas.
Publiquei o bot no Facebook Messenger e aproveitei o que apresentei na empresa para escrever um tutorial.
Após a publicação, algumas pessoas começaram a usá-lo, provavelmente porque leram o tutorial e resolveram testar o bot para ver como funcionava.
Foi aí que comecei a perceber que o Climão precisava de algumas melhorias…
Aprendendo com a experiência do usuário
A primeira pessoa que usou o meu chatbot acessou através de um link que enviei no WhatsApp. Esse link abriu o navegador no celular dela e a primeira coisa que ela me disse foi que o bot não estava funcionando.
Eu dei uma olhada no que ela estava fazendo e vi que ela não usou o botão de enviar localização e sim escreveu o nome da cidade. Pedi para que usasse o botão, mas ela reportou que ele não aparecia para ela.
Fiquei sem entender nada… mas pedi para que abrisse no aplicativo do Messenger e a partir daí tudo funcionou normalmente.
Acessando o histórico de mensagens da página do Climão percebi que mais algumas pessoas estavam tentando escrever o nome da cidade e não usando o botão de enviar localização. Isso era algo que eu não tinha previsto e portanto o bot não entendia e acabava reenviando o botão o tempo todo.
A primeira coisa que pensei foi que as pessoas não estão acostumadas a usar botões em chats, deve ser esse o problema.
Mas a realidade era outra.
Quando montei o bot para a apresentação, não dei atenção alguma para o texto que convidava o usuário à escolher a sua localização. Ele dizia: “De qual cidade você quer saber o clima?”. Isso fazia com que a pessoa pensasse que tinha que responder à pergunta.
Esse feedback veio da mesma pessoa que citei a cima. Algo que não havia me passado pela cabeça!
Isso podia mesmo ser um motivo, mas os dias passavam e eu via mais gente usando o Climão e escrevendo repetidamente o nome da cidade em vez de usar o botão.
Será mesmo que apenas a pergunta estava levando tanta gente à escrever a cidade? Por acaso, acabei descobrindo que não.
Lendo outro texto do Medium que falava sobre um chatbot, resolvi clicar no link para experimentá-lo. Foi então que o mistério se resolveu.
As pessoas estavam acessando o Climão pelo texto do Medium, assim como eu, provavelmente pelo celular, assim com eu, e estavam caindo direto no navegador, assim como eu.
Abrindo a página do Facebook pelo navegador do celular e clicando em “Enviar mensagem” você entra em uma página terrível de mensagem que não tem nenhuma das funcionalidades dos bots do Messenger. Nela você pode interagir com o bot apenas por texto!
No lado esquerdo a versão do navegador mobile e na direita o aplicativo do Facebook Messenger.
Isso poderia ser mais um motivo, além do “texto-pergunta”, que estava fazendo as pessoas digitarem ao invés de enviarem sua localização pelo botão.
Foi então que resolvi melhorar o bot, mesmo ele sendo apenas um experimento para um tutorial, achei que valia a pena a experiência de aprender com a interação de usuários.
Gastei um tempinho nele e fiz com que também aceitasse o nome da cidade escrita. Mudei a frase que pede a localização. Agora ele escolhe aleatoriamente entre algumas opções de texto que indicam ao usuário que pode digitar uma cidade ou apertar o botão de envio de localização.
Aproveitei para dar um tapa no visual da apresentação dos dados também. Ao invés de enviar apenas um texto, resolvi utilizar o template de lista que a API de envio do Messenger proporciona.
Interações “fora do contexto”
Um outro fato que me chamou a atenção quando analisei as mensagens enviadas pelos usuários foram as mensagens que estavam “fora do contexto” das funcionalidades do Climão.
Com “fora do contexto” eu quero dizer interações que eu não previ.
Coisas simples como um “Olá” e um “Obrigado” não eram tratadas, deixando o bot muito “robótico” e pouco natural na conversação. O Climão era antipático!
Dei uma atenção para o tratamento desse tipo de interação, mas não gastei muito tempo com isso ainda, afinal ele é apenas um experimento. Podemos dizer agora que ele não é muito simpático, mas pelo menos já é educado.
Algumas coisas ele responde, mas não chega a ser tão esperto assim…
Conclusão
Esse bot tem sido um experimento incrível. Além de ter aprendido muita coisa com um chatbot tão simples, ainda tenho ganhado uma experiência importante sobre como evoluí-lo para melhor se adaptar às interações com os usuários.
O feedback é a melhor maneira de se aprender. Saber onde você errou ou o que deixou passar depende muito dessa interação com diferentes pessoas. Por isso foi tão importante tirar esse bot do “desenvolvimento” e deixá-lo disponível para o público em geral.
Se você leitor tiver alguma sugestão para melhorar o Climão, deixe sua resposta abaixo. E se quiser ver o código-fonte, acesse o repositório no Github. Quer saber o clima atual em algum lugar? Mande uma mensagem pro Climão!
Este é um tutorial no estilo passo-a-passo para a criação de um chatbot simples para o Facebook Messenger. Ele foi escrito como conteúdo para uma pequena apresentação que farei em um evento interno de compartilhamento de conhecimento da TIKAL TECH, empresa em que trabalho.
Existem diversas maneiras de se criar um bot para o Messenger, mas neste tutorial eu utilizarei apenas o microframework para web escrito em Python chamado Flask e nada mais.
Esse tutorial resume algumas das coisas que aprendi durante o desenvolvimento de um outro projeto.
Passo 1
Criando um aplicativo e vinculando com uma fanpage
Acesse o dashboard do Facebook Developers e crie um aplicativo. No tipo de aplicativo escolha “Aplicativos para o Facebook Messenger”. Se você não tiver uma página para vincular o aplicativo, crie uma também.
Com a página criada, entre novamente no dashboard e gere um token para o aplicativo ser vinculado à página.
Passo 2
Começando a programar o backend
Vamos utilizar o microframework Flask para facilitar esse desenvolvimento, mas qualquer outro framework web pode ser utilizado.
Se você está acostumado a trabalhar com Python você pode pular alguns dos passos abaixo.
Vamos começar criando um ambiente virtual na linha de comando e instalando o Flask, o requests e o gunicorn. Precisaremos dos dois primeiros para nosso chatbot e o último será para o deploy.
Escolha o diretório que você vai utilizar e digite os seguintes comandos.
Agora temos um arquivo index.py no nosso diretório chatbot. É nele que faremos os próximos passos do nosso tutorial.
Começamos com o básico do Flask.
import os
from flask import Flask, request
token = os.environ.get('FB_ACCESS_TOKEN')
app = Flask(__name__)
@app.route('/', methods=['GET', 'POST'])
def webhook():
return 'Nothing'
if __name__ == '__main__':
app.run(debug=True)
Esse arquivo tem o básico do que precisamos para rodar um app no Flask.
O token que estamos pegando de uma variável de ambiente é o token que geramos no dashboard do Facebook.
Para adicioná-lo como variável de ambiente execute na linha de comando:
$ export FB_ACCESS_TOKEN=<cole o token gerado>
Passo 3
Configurando os Webhooks
Temos que configurar um webhook para que o Facebook saiba para onde enviar as requisições do chat.
Para isso utilizaremos o ngrok para “tunelar” nosso localhost. Para saber como funciona, veja esta publicação.
Vamos rodar nosso servidor local com o Flask. Na linha de comando com o virtualenv ativado, digite:
(chatbot)$ python index.py
Abra outra janela de terminal para iniciar o ngrok.
./ngrok http 5000
Agora temos um endereço web com HTTPS para cadastrar no dashboard do Facebook. Basta ir até o painel Webhooks e clicar em Configurar Webhooks.
Antes de cadastrar o endereço, é preciso adicionar uma parte a mais no nosso index.py. O bloco em negrito tem o que é preciso para que o Facebook aceite esse link como elegível para webhook.
def webhook():
if request.method == 'POST':
pass
elif request.method == 'GET': # Para a verificação inicial
if request.args.get('hub.verify_token') == os.environ.get('FB_VERIFY_TOKEN'):
return request.args.get('hub.challenge')
return "Wrong Verify Token"
return "Nothing"
Coloque o endereço gerado pelo ngrok, por exemplo https://7f3o6bd7.ngrok.io, e crie uma frase de segurança. Essa frase colocamos na variável de ambiente FB_VERIFY_TOKEN que você pode ver no código acima.
(chatbot)$ export FB_VERIFY_TOKEN=<digite qualquer frase aqui>
Com isso já somos capazes de registrar nosso endereço do chatbot no Facebook.
Para finalizar, no mesmo painel de webhooks você deve “inscrever” sua página criada ao webhook adicionado. Essa parte é bem autoexplicativa.
Passo 4
Lendo a mensagem e respondendo
Agora vamos adicionar uma maneira de lermos o que o usuário nos enviou pelo Messenger. Isso é feito verificando os dados enviados na requisição que o chat nos envia via POST.
Então vamos adicionar ao nosso código o seguinte trecho:
import os
import requests
import traceback
import json
(...)
def webhook():
if request.method == 'POST':
try:
data = json.loads(request.data.decode())
text = data['entry'][0]['messaging'][0]['message']['text']
sender = data['entry'][0]['messaging'][0]['sender']['id']
payload = {'recipient': {'id': sender}, 'message': {'text': "Hello World"}}
r = requests.post('https://graph.facebook.com/v2.6/me/messages/?access_token=' + token, json=payload)
except Exception as e:
print(traceback.format_exc())
elif request.method == 'GET': # Para a verificação inicial
(...)
Explicando o que estamos fazendo. Adicionamos os imports necessários no topo do arquivo index.py e dentro do nosso método webhook verificamos se a requisição chegou como POST.
Com o data = json.loads(request.data.decode()) nós capturamos o corpo da mensagem que nos foi enviado pelo Messenger.
Com o trecho text = data['entry'][0]['messaging'][0]['message']['text']conseguimos pegar o texto que o usuário enviou via chat.
Pra saber quem enviou, usamos o trecho sender = data['entry'][0]['messaging'][0]['sender']['id']. Essa informação é necessária para que possamos enviar uma resposta para o usuário correto.
No trecho payload = {'recipient': {'id': sender}, 'message': {'text: "Hello World"}} nós montamos o corpo da nossa resposta ao usuário.
Para finalizar, respondemos enviando uma requisição para o endereço da API do Facebook Messenger com o corpo criado anteriormente. O trecho referente ao envio segue abaixo.
r = requests.post('https://graph.facebook.com/v2.6/me/messages/?access_token=' + token, json=payload)
Colocamos tudo isso dentro de um try/except para capturar um possível erro que imprimiremos no console. Isso fazemos com o trecho final do código que acabamos de adicionar.
except Exception as e:
print(traceback.format_exc())
Com isso, respondemos um Hello World para cada entrada que o usuário nos enviar.
Passo 5
Tornando o chatbot em algo útil
Como responder Hello World para cada mensagem é algo totalmente inútil para um bot fazer, vamos colocar uma funcionalidade aproveitando a documentação do Messenger, que é bem completa.
Vamos pegar a localização do usuário e enviar informações sobre o clima atual em sua localidade.
Primeiro criamos uma função que monta um payload com formatoQuick Reply do Messenger. O formato que precisamos enviar para ter esse resultado é facilmente encontrado na documentação do Messenger. Nela definiremos que queremos um tipo location.
Agora, quando formos enviar uma mensagem para nosso usuário, utilizamos essa função no lugar do antigo payload.
payload = location_quick_reply(sender)
Isso vai enviar uma opção para o usuário nos enviar sua localização. Como mostra a imagem abaixo.
Vamos receber essa localização de maneira diferente do que um texto comum, ela virá como um anexo. Dessa forma mudamos nossa verificação de texto para o bloco abaixo.
if request.method == 'POST':
try:
data = json.loads(request.data.decode())
print(data)
message = data['entry'][0]['messaging'][0]['message']
sender = data['entry'][0]['messaging'][0]['sender']['id'] # Sender ID
if 'attachments' in message:
if 'payload' in message['attachments'][0]:
if 'coordinates' in message['attachments'][0]['payload']:
location = message['attachments'][0]['payload']['coordinates']
latitude = location['lat']
longitude = location['long']
else:
text = message['text']
payload = location_quick_reply(sender)
r = requests.post('https://graph.facebook.com/v2.6/me/messages/?access_token=' + token,
json=payload)
Nesse bloco verificamos se o corpo da requisição que o Messenger nos enviou possui uma chave attachments e se possui uma chave payload com as coordenadas da localização.
Se não vier nesse formato é porque ele enviou uma mensagem normal de texto, então reenviamos o botão que pede sua localização.
Agora que pegamos a latitude e longitude, podemos utilizar uma API aberta de clima para enviar as informações para nosso usuário.
Eu escolhi a OpenWeatherMap para isso. Basta se inscrever e gerar uma chave de API no site deles e você já pode começar a fazer requisições variadas para receber informações de clima do mundo inteiro.
Adicionei a chave de API deles numa variável de ambiente para utilizar nas requisições que farei dentro do código e pronto.
(chatbot)$ export WEATHER_API_KEY=<digite a api key>
Agora podemos acessar o endpoint que eles fornecem para current weathere pegar a temperatura e outros dados climáticos do local do usuário.
Logo após o trecho do código onde pegamos a latitude e longitude, adicionamos uma requisição para a API do OpenWeatherMap para montar a resposta que daremos ao nosso usuário.
Basicamente analisei a resposta da API do OpenWeatherMap e peguei as informações que gostaria de exibir ao usuário. Depois disso montei um bloco de texto simples exibindo algumas das informações.
Pronto! Agora temos uma funcionalidade para nosso bot experimental.
Passo 6
Fazendo o deploy
Vamos colocar nosso novo bot em um servidor para que ele fique disponível constantemente. Como eu falei anteriormente é preciso uma conexão segura (HTTPS) para que o Facebook aceite a URL do chatbot.
Com o Heroku é muito simples fazer o deploy. Basta que o seu código esteja no github, por exemplo, e com um clique ele fica online.
Para fazê-lo funcionar no Heroku é preciso adicionar dois novos arquivos ao nosso projeto. O Procfile e o runtime.txt. O primeiro configura o servidor web e o segundo define que estamos usando o Python 3.
Se você estiver utilizando a versão 2 do Python, o segundo arquivo é desnecessário.
O arquivo Procfile ficará assim:
web: gunicorn index:app
E o runtime.txt assim:
python-3.5.2
Criamos uma conta no Heroku e adicionamos um novo app. Em seguida vamos na aba Deploy e conectamos com o Github. Com isso basta escolher o seu repositório e clicar em Deploy Branch.
Abas do Dashboard do Heroku
Precisamos adicionar nossas variáveis de ambiente. Para isso devemos ir à aba Settings e adicionar manualmente por lá. É simples e autoexplicativo.
Agora testamos nossa URL, que será algo como https://<nome_do_app>.herokuapp.com.
Voltamos ao dashboard de developers do Facebook para mudar nosso webhook configurado. Lembra que fizemos isso com o endereço que o ngrok nos forneceu no passo três? Agora vamos mudar a URL para a nova que o Heroku nos forneceu.
Aprovação do Facebook
Com nosso bot funcional e online, agora temos que deixá-lo em aprovação no dashboard de developers do Facebook.
Basta preencher o que eles pedem por lá e aguardar até cinco dias para que seu bot possa ser usado por qualquer usuário do Facebook.
Conclusão
O Facebook aprovou rapidamente o chatbot que chamei de Climão. Isso porque utilizamos apenas a permissão de messages do Webhook, que é a mais simples.
Para utilizar esse bot acesse a Página do Facebook e envie uma mensagem para o Climão. =)
O código que criamos durante esse tutorial está disponível no Github.
Qualquer dúvida, entre em contato pelas respostas abaixo.
Quando desenvolvemos um serviço web, que alimentará com dados algum cliente (aplicativos, webapps ou qualquer outro sistema), precisamos prestar muita atenção no modelo de interface que utilizaremos.
Isso é importante para que os desenvolvedores que utilizarem seu serviço web tenham fácil compreensão do que cada endpoint faz, de acordo com o verbo HTTP utilizado para a requisição.
A maneira mais comum para modelar uma interface como essas nos dias de hoje é a arquitetura REST.
Antes de continuar, vamos para algumas definições importantes para seguirmos o assunto sem que tudo fique incompreensível para quem não é familiarizado com as expressões utilizadas nos primeiros parágrafos.
O que é API?
Interface de Programação de Aplicação, cujo acrônimo API provém do Inglês Application Programming Interface, é um conjunto de rotinas e padrões estabelecidos por um software para a utilização das suas funcionalidades por aplicativos que não pretendem envolver-se em detalhes da implementação do software, mas apenas usar seus serviços. (fonte Wikipedia)
No caso desse texto estamos falando especificamente sobre as APIs de serviço web, ou web services APIs, que são interfaces de programação para troca de dados via web, utilizando protocolo HTTP.
Isso é feito através de endpoints.
Os endpoints são os endereços web que executam as ações e são acessados diretamente pelos clientes.
O que é REST?
Representational state transfer (REST) or RESTful web services são uma forma de proporcionar interoperabilidade entre sistemas de computadores na Internet. Os serviços da Web compatíveis com REST permitem que os sistemas solicitantes acessem e manipulem representações textuais de recursos da Web usando um conjunto uniforme e predefinido de operações sem estado (stateless). (fonte Wikipedia)
Quando a arquitetura REST é aplicada à APIs de serviços web, chamamos de RESTful APIs.
E os verbos HTTP?
O protocolo HTTP define métodos (às vezes referidos como verbos) para indicar a ação desejada a ser realizada no recurso identificado. O que este recurso representa, se são dados pré-existentes ou dados gerados dinamicamente, depende da implementação do servidor. Muitas vezes, o recurso corresponde a um arquivo ou a saída de um executável residente no servidor. (fonte Wikipedia)
Em resumo, os verbos HTTP são os métodos de requisição que utilizamos para acessar os endpoints de uma RESTful API.
Uma das primeiras coisas que deve ser feita ao iniciar um projeto de API é planejar os endpoints que existirão para o acesso aos dados e para as ações específicas.
Segue um exemplo bem simples desse planejamento feito em uma planilha qualquer.
Vendo esse exemplo fica bem explícito o que cada verbo HTTP significa, certo?
Qualquer um que conheça essa arquitetura vai saber que o endpoint /users tem, no mínimo, essas opções de ação. Por isso é tão importante respeitar os verbos para facilitar o entendimento da sua API.
Vamos detalhar melhor cada um deles.
POST
O verbo POST é mais frequentemente utilizado para criar novos recursos. Na criação bem-sucedida, retornar o status HTTP 201.
Ele não é um método seguro, pois altera o estado do recurso no servidor. Ele também não é idempotente, o que quer dizer que se ele for executado duas vezes de forma idêntica serão criados dois itens diferentes com o mesmo conjunto de dados.
GET
O método HTTP GET é usado para ler ou recuperar uma representação de um recurso. Em caso de sucesso, retorna uma representação em JSON e um código de resposta HTTP de 200 (OK). Em caso de erro, ele geralmente retorna um 404 (NOT FOUND) ou 400 (BAD REQUEST).
De acordo com o design da especificação HTTP, requisições GET (juntamente com HEAD) são usadas apenas para ler dados e jamais alterá-los. Portanto, quando usados dessa forma, são considerados seguros.
Além disso, GET (e HEAD) é idempotente, o que significa que fazer várias solicitações idênticas acaba tendo o mesmo resultado de uma única solicitação.
PUT
PUT é mais utilizado para substituir (ou atualizar) recursos, executando a requisição para uma URI de recurso conhecido, com o corpo da requisição contendo a representação recém-atualizada do recurso original.
Na atualização bem-sucedida, retorna 200 (ou 204 se não retornar qualquer conteúdo no corpo). Retornar os dados do recurso no corpo é opcional, lembrando que fazer isso causa maior consumo de banda.
PUT não é uma operação segura, pois modifica estado no servidor, mas é idempotente. Em outras palavras, se você atualizar um recurso usando PUT e, em seguida, fazer essa mesma chamada novamente, o recurso ainda está lá e ainda tem o mesmo estado.
Obs: Se, por exemplo, executar uma requisição PUT em um recurso incrementar um contador (dentro do recurso), a chamada não é mais idempotente. É recomendado manter as solicitações PUT idempotentes. Use o POST para solicitações não idempotentes.
PATCH
PATCH é usado para modificar parcialmente os recursos. A requisição só precisa conter as alterações específicas para o recurso, não o recurso completo.
Se parece com PUT, mas o corpo contém um conjunto de instruções descrevendo como um recurso no servidor deve ser modificado para produzir uma nova versão.
PATCH não é nem seguro, nem idempotente.
DELETE
DELETE é bastante fácil de entender. Ele é usado para excluir um recurso identificado por um URI.
Na exclusão bem-sucedida, devolve o status HTTP 200 (OK) ou o status HTTP 204 (NO CONTENT) sem corpo de resposta.
Operações DELETE são idempotentes.
Há uma advertência sobre idempotência no DELETE. Chamar DELETE em um recurso uma segunda vez geralmente retornará um 404 (NOT FOUND) já que ele já foi removido e, portanto, não é mais encontrável. Isso, por algumas opiniões, faz operações DELETE não mais idempotente, no entanto, o estado final do recurso é o mesmo. Retornar um 404 é aceitável e comunica com precisão o status da chamada.
Obs: Se a requisição DELETE decrementa um contador (dentro do recurso), a chamada DELETE não é mais idempotente. É recomendável usar o POST para solicitações de recursos não idempotentes.
Os códigos de resposta (status codes) HTTP
Nas descrições dos verbos HTTP foram citados diversas vezes os status code do protocolo HTTP.
Esse é outro item importante para a arquitetura de uma API REST, porque, da mesma maneira que acontece como os verbos HTTP, elas formam um padrão facilmente reconhecido por quem for consumir o web service.
Os principais códigos utilizados para as respostas de um endpoint são o 200 (OK), o 201 (CREATED), o 204 (NO CONTENT), o 404 (NOT FOUND) e o 400 (BAD REQUEST).
Todos os códigos tem nomes autoexplicativos, portanto é muito simples lembrar o que utilizar em cada situação.
Existe uma lista enorme de códigos de resposta do protocolo HTTP que podem ser utilizados, como o 301 (MOVED PERMANETLY) e o 304 (NOT MODIFIED). Sendo o segundo para conteúdos em cache, por exemplo.
Os códigos de sucesso tem o padrão 20x, os de redirecionamento 30x, os de erro do cliente 40x e os de erro de servidor 50x.
Lembrando mais uma vez, os padrões facilitam qualquer desenvolvedor de entender facilmente o que aconteceu com o retorno da requisição que ele executou.
No caso de erros, mesmo tendo esses padrões, é importante devolver ao cliente uma mensagem clara do que aconteceu com a requisição e qual o motivo do erro.
Para ver mais detalhes sobre os códigos HTTP e também a lista completa deles, acesse o link https://httpstatuses.com/.
Concluindo
Este foi uma publicação mais teórica sobre a arquitetura, os padrões e algumas boas práticas no desenvolvimento de uma RESTful API.
Ainda existem muitos assuntos a serem abordados para quem quer se aprofundar mais nesse tipo de desenvolvimento, mas essa publicação ajuda a dar os primeiros passos.
Mas a melhor maneira de aprender de verdade é passando pela experiência de desenvolver uma API que seja consumida por alguns clientes, ou até criar um cliente que consuma uma API pública já existente.
Veja como expor seu servidor local para a internet e para que serve isso
O tunelamento do localhost é uma maneira de ter um “link externo” que aponte para alguma aplicação que você esteja rodando localmente. Dessa forma podemos “expor” nosso servidor local de forma segura.
Mas por que eu iria querer isso? Podemos usar essa solução para diversas situações, principalmente no desenvolvimento web. Vou mostrar alguns exemplos de uso nessa publicação.
Para os exemplos a seguir eu estou usando o ngrok, um software que facilita muito isso e ainda mantém essa exposição totalmente segura.
Mostrar um desenvolvimento em andamento para o cliente
Digamos que você esteja desenvolvendo um site ou um sistema web para um cliente e quer mostrar o que você desenvolveu até o momento. O mais comum seria fazer o deploy do trabalho em andamento em um servidor web e disponibilizar o link para seu cliente.
Mas existe uma outra opção, podemos deixar o site rodando localmente e tunelar com o ngrok.
Você pode iniciar um servidor local com o SimpleHTTPServer do Python, por exemplo, e rodar o ngrok na linha de comando, como no exemplo abaixo.
$ python -m SimpleHTTPServer 8000
Serving HTTP on 0.0.0.0 port 8000 ...
Em outra aba do terminal você inicia o tunelamento.
./ngrok http 8000
Agora ele irá exibir o endereço que ficará disponível para seu cliente pela internet. Será algo como http://36096fff.ngrok.io.
Ao rodar, o ngrok vai aparecer assim no seu terminal…
Estamos iniciando um servidor HTTP local na porta 8000. Perceba que o comando de tunelamento recebeu os parâmetros http e 8000, indicando que é um servidor http e que está usando a porta 8000.
Testar um chatbot durante o desenvolvimento
Durante o desenvolvimento de um chatbot para o Facebook Messenger, por exemplo, não é possível testar sem um “endereço web”. É preciso que seja registrada uma URL nas configurações do seu chatbot do Messenger para que ele receba os eventos de mensagem.
Para entender melhor sobre isso, veja este artigo.
Para que você não precise fazer deploy de cada pequena alteração em um servidor web para testar no seu chatbot, crie um tunelamento, como no exemplo anterior, e registre o endereço gerado na seção webhook nas configurações do chatbot no Messenger.
Obs: Nem todos os aplicativos de mensagem se utilizam de webhooks para receber os eventos. No caso do Telegram, como neste link, não é necessário utilizar o tunelamento.
Testar endpoints de webhooks
Eu falei em webhooks no item anterior. Pra quem não sabe o que é, segue uma tradução livre de uma parte do artigo da Wikipedia:
Webhooks são “retornos de chamada HTTP definidos pelo usuário”. Normalmente eles são ativados por algum evento, como o push de código para um repositório ou um novo comentário postado em um blog. Quando ele acontece, o site origem faz uma requisição HTTP para a URI configurada para o webhook, enviando os dados do evento.
Existem diversos serviços que utilizam esse formato para enviar dados de eventos. Um bom exemplo é o Sendgrid ou o Mandrill, que usam webhooks para enviar os eventos de email (lido, marcado como spam, link clicado, etc.) para um sistema de terceiros que esteja usando sua API.
Outro bom exemplo são integrações com gateways de pagamento, como Iugu, PagSeguro ou PayPal, onde, mesmo durante o desenvolvimento, você precisa de um “endereço web aberto” para receber os eventos relacionados aos pagamentos, alterando o status de uma compra, por exemplo.
Para isso, abra um tunelamento com o ngrok e registre o novo endereço gerado por ele com o seu endpoint para receber os eventos webhook do serviço que você está utilizando.
Painel do ngrok
Uma funcionalidade interessante do ngrok é o seu painel, ou interface web.
Screenshot da interface web
Com ela você vê todas as requisições que foram feitas ao seu endereço web aberto. Com isso você pode verificar os dados que estão vindo com as requisições e ainda dar um “replay” na mesma, para testar novamente.
Para acessar, veja o endereço listado no terminal do ngrok como Web Interface e abra no seu navegador. Vai ser algo como http://127.0.0.1:4040.
Concluindo
Esses são alguns casos de uso para o tunelamento de localhost. Alguns deles eu já utilizei, como o teste de webhooks e a demonstração de desenvolvimento em andamento para cliente. Mas eu descobri mesmo que isso era possível ao ler um tutorial de criação de chatbot para o Facebook Messenger, então resolvi dar esse exemplo também.
Essa publicação é baseada na minha primeira experiência criando um chatbot para o Telegram usando Python. O código fonte dessa experiência pode ser encontrado no meu Github.
The Botfather
O Telegram facilita muito a criação de bots para seu sistema. Além de uma documentação muito boa e uma API muito simples de usar, ele possui o BotFather, um bot que ajuda qualquer um a criar seu próprio bot.
Segundo a documentação do Telegram:
BotFather is the one bot to rule them all. It will help you create new bots and change settings for existing ones.
Então vamos lá. Para começar é preciso acessar o @BotFather e fazer o registro do seu novo chatbot.
Para qualquer criação ou configuração de bot é preciso acessá-lo. E como vamos criar um novo bot, acessamos o link @BotFather.
Lá você terá acesso a diversos comandos, dentre eles o /start, que irá apresentar a lista desses comandos e o /newbot, que serve para a criação de um novo bot.
Quando executarmos o /newbot ele pede algumas configurações, como o nome e o username que serão utilizados pelo bot. Nada complicado.
Seu bot será como um usuário comum do Telegram, com um “nome para exibição” e um “nome de usuário” (username) para controle.
Assim que forem preenchidos os dados necessários ele irá gerar um token para ser utilizado no seu script. Esse token é único e serve como uma “senha” para seu bot, portanto deve ser mantido em sigilo.
Para saber mais sobre o @BotFather, acesse a documentação do Telegram que fala sobre bots para desenvolvedores.
Armazenando e acessando o token
Agora que já temos o token do nosso bot, devemos guardá-lo em uma variável de ambiente para que possamos acessá-lo posteriormente no nosso script Python.
Na linha de comando, execute o seguinte:
$ export BOT_API_TOKEN="<aqui vai o token gerado pelo botfather>"
Agora você poderá recuperá-lo facilmente em seu script Python com apenas duas linhas de código.
import os
token = os.environ['BOT_API_TOKEN']
Obs: Esta é apenas uma sugestão de como armazenar essa informação. Você pode guardar seu token da maneira que achar melhor.
Implementando os comandos
Um pacote que facilita muito a vida de quem está desenvolvendo um bot para o Telegram é o pyTelegramBotAPI. Com ele basta adicionar decorators nas suas funções e elas passarão a atender aos comandos recebidos.
Podemos usar o seguinte comando para instalar o pacote via pip:
$ pip install pyTelegramBotAPI
Agora chegou a hora de implementar os comandos que controlarão o bot.
Vou abordar somente um tipo de decorator e de resposta a caráter de exemplo. Através da documentação do pyTelegramBotAPI você consegue facilmente implementar diversas outras formas de input e output para o seu bot.
Começamos o script em Python fazendo nossos imports e iniciando o telebot com o token do Telegram gerado pelo @BotFather, como no exemplo de código abaixo.
import os
import telebot
bot = telebot.TeleBot(os.environ['BOT_API_TOKEN'])
Agora é só começar a implementar os comandos. No exemplo abaixo eu estou implementando uma mensagem de boas vindas para os comandos /start e /help.
@bot.message_handler(commands=['start', 'help'])
def send_welcome(message):
bot.reply_to(message, u"Olá, bem-vindo ao bot!")
No final do script adicionamos o método bot.polling() para inicializar o nosso novíssimo bot.
bot.polling()
Basta executar o script em linha de comando e o seu bot está pronto para começar a ser testado.
$ python bot.py
Para executar o teste, basta acessar seu Telegram e seguir o usuário com o username que você deu para seu bot lá no começo do processo, com o @BotFather.
E voilá!
Simples, não é? Veja como nosso script em Python ficou bem pequeno.
import os
import telebot
bot = telebot.TeleBot(os.environ['BOT_API_TOKEN'])
@bot.message_handler(commands=['start', 'help'])
def send_welcome(message):
bot.reply_to(message, u"Olá, bem-vindo ao bot!")
Na área de desenvolvimento de software sempre somos bombardeados por notícias de novas tecnologias que estão dominando o mercado. E que, para ficar na “crista da onda” (e ser bem pago), é preciso trabalhar com essa ou aquela nova tecnologia.
Essa é a hora que o desespero bate e você pensa:
“Tenho que aprender esse novo framework senão vou ficar para trás!”
Tenho certeza que isso já aconteceu com muitos programadores por aí.
Aí é só aprender que ficará tudo bem, certo? Mas não é tão simples assim.
Para aprender uma coisa pra valer não basta seguir aquele tutorial maneiro do blog do especialista. Envolve muito mais do que isso.
Aprendendo Python
Em 2012 eu fiz minhas primeiras tentativas de aprender Python e Django, porque eu achava que o PHP não me daria futuro. Leia-se grana.
Em 2012 eu achava que Python me deixaria assim… Doce ilusão.
Objetivo bobo para aprender algo, na verdade. Em 2010 eu tinha tentado a mesma coisa com Java… Não rolou.
Eu fiz uns projetos pessoais como um portfólio e um controle financeiro seguindo alguns tutoriais e a documentação do Django, mas somente a caráter de teste. Não cheguei nem a arranhar a superfície do que o Python ou o Django poderiam me proporcionar como soluções.
Não existia um problema real ao qual eu precisava do Python para resolver.
Eu continuava conseguindo trabalhos somente com PHP, por causa da minha experiência profissional. Com isso acabei não aprendendo nada relacionado a Python na época.
Como não gostar de Python, não é?
Depois de um bom tempo, eu continuava com PHP nas empresas em que trabalhava, mas não queria desistir do Python porque tinha gostado de programar na linguagem.
Aí o objetivo era outro. Aprender porque eu gostava. Mas como?
Foi então que resolvi fazer alguns projetos freelance com o Flask, outro framework em Python. A partir daí comecei a entender e a dominar um pouco mais essa linguagem.
Foi uma tática muito mais inteligente.
Depois de um tempo fazendo esses freelances, acabei conseguindo um emprego para desenvolvedor em Python e hoje trabalho diariamente com ele.
Não-aprendendo AngularJS
Outra experiência parecida foi com o desenvolvimento de frontend.
Durante um período em que fiquei desempregado, comecei a procurar vagas e percebi que existia muita procura por desenvolvedor frontend. Como sempre tive conhecimento sólido com HTML/CSS e JavaScript (e jQuery), pensei que poderia conseguir alguma coisa.
O problema é que a maioria das vagas exigia conhecimentos em AngularJS ou outro framework JavaScript. Me candidatei para várias delas e apesar de chegar à fase final de quase todas, não consegui ser contratado.
Eu tenho certeza que, mesmo tendo bom domínio de HTML/CSS/Javascript, não fui contratado porque não tinha familiaridade com nenhum dos (na época novos) frameworks de frontend.
Durante esse tempo eu fiz alguns tutoriais de AngularJS para tentar melhorar essa deficiência e até para fazer testes para algumas das vagas de emprego. Mas confesso que tudo me parecia meio confuso… No final não aprendi nada. Nem sequer entendi a base do framework.
Acabei por desistir na época.
Um tempo depois, precisei utilizar AngularJS em um projeto. Foi um tempo pesquisando para acabar entendendo e aprendendo. Hoje tenho um projeto em produção usando essa tecnologia.
Graças a necessidade.
Aprendendo com a necessidade
A verdade é que cada um tem seu jeito de fixar conhecimento. Não estou aqui para impor regras a algo tão subjetivo como a forma de aprendizagem de cada um.
Quero compartilhar a minha forma de aprender: E ela chama-se necessidade.
Eu só consigo aprender algo para valer se realmente usá-lo em algum projeto. Um projeto real.
Pode ser pessoal ou comercial, mas que seja algo que eu queira ou precise mesmo fazer.
Para que eu consiga entender e fixar é preciso existir a necessidade de resolver um problema com aquela tecnologia.
Foi assim com o Python, quando comecei a focar em projetos freelance com a linguagem, passei a aprendê-la de verdade.
Resumindo: se não existir um problema real para resolver, dificilmente se chega tão fundo a ponto de conhecer as verdadeiras funcionalidades e qualidades de certa tecnologia.
Quer aprender uma nova tecnologia?
Procure a tecnologia que dê a solução para um problema que você tenha que resolver, ela será a melhor e a mais fácil para você aprender.
