Quando participamos de um processo seletivo, geralmente ocorre um checklist das ferramentas que o projeto utiliza e as ferramentas com as quais você já trabalhou em outros projetos. Muitas vezes, o candidato é escolhido de acordo com o quanto esse checklist é preenchido. No entanto, se pararmos para refletir por um minuto, veremos que isto não é bom nem para a empresa, nem para o candidato.

Vamos começar pelo mais óbvio. Ao escolher um candidato com base apenas nos seus conhecimentos técnicos, estamos ignorando questões comportamentais e outras características que podem ou não estar alinhadas com a posição. Eu já comentei sobre isto no artigo sobre os Code Challenges. Porém, é necessário também pensar que este checklist das ferramentas demonstra se o candidato possui um bom fit técnico para aquele momento do projeto. Ferramentas podem mudar ou, ao menos, sofrerem atualizações. O candidato pode ser um bom fit naquele momento, mas quando o projeto acabar, ou sofrer uma grande alteração? Só nesse momento é que a empresa vai avaliar se o candidato é capaz de se adaptar? Além disso, se a empresa contrata um candidato apenas pelo checklist técnico, certamente não está em busca de candidatos que sejam capazes de sugerir ferramentas melhores.

Chegamos agora na parte em que relacionamos o assunto com o título do artigo. Eu adoraria que os recrutadores me perguntassem sobre os jogos que eu já platinei. Para aqueles que não fazem parte do mundo gamer, platinar é um termo usado quando você consegue completar todos os desafios ou conquistas de um jogo (eu também não faço parte desse mundo, mas conheço esse termo ). Isso porque eu poderia dizer orgulhosamente que eu conquistei os cinco pantheons do Hollow Knight (sim, parte da motivação para escrever esse artigo foi só para poder compartilhar isso). Mas por que isso seria relevante? Acho que esse jogo demonstra muito da minha personalidade e como eu enfrento os desafios. É um jogo extremamente difícil que exige que você tenha paciência e muita insistência para conseguir desenvolver estratégias e reflexos para cada inimigo diferente. Acho que nada representa melhor o meu estilo profissional do que isso! Eu não sou a pessoa brilhante que consegue resolver os problemas de primeira. Eu sou a pessoa perseverante que tem paciência de me desenvolver aos poucos até conseguir superar os obstáculos, não importa o quão difícil eles sejam.

Obviamente, este caso se aplica muito bem à mim, mas tenho certeza que você também tem algum hobbie que seja um perfeito exemplo de como você lida com os desafios profissionais. Pode ser que o seu hobbie de pintura demonstre bem a sua capacidade de se concentrar e ter atenção aos detalhes, ou o trabalho voluntário que você faz demonstre a sua capacidade de se relacionar com pessoas diferentes e trabalhar em equipe, ou ainda gostar de participar de maratonas, que assim como o jogo que eu mencionei, demonstra paciência e dedicação no processo de preparação, além de uma forte capacidade de concentração durante a corrida.

É claro que eu já passei por algumas entrevistas em que me perguntaram sobre os meus hobbies e sobre “quem é o Rafael fora do trabalho”. Porém, além de estar longe de ser algo comum de ser perguntado durante as entrevistas, não sei até que ponto isso realmente é levado em consideração pelo entrevistador. Aqui eu devo confessar que nas raras vezes em que me perguntaram sobre os meus hobbies, eu sempre tentei passar uma imagem de que “sou uma pessoa como qualquer outra”. Falo sobre os livros e os filmes que costumo assistir, sobre o tempo que passo com a minha família, mas acho que isto realmente sou “eu fora do horário de trabalho”, nada disso diz como eu costumo enfrentar os desafios. Da próxima vez que me perguntarem sobre os meus hobbies, direi: sou uma pessoa que gosta de passar um tempo com a família, ler livros, assistir filmes e que conseguiu passar do quinto pantheon do Hollow Knight! E é por isso que eu gosto de escrever esses artigos, me fazem refletir enquanto eu escrevo.

Enfim, esse artigo foi apenas uma grande reflexão sobre os processos seletivos que focam no match do conhecimento técnico do candidato com as ferramentas que o projeto demanda. Com o tempo o projeto pode mudar de ferramentas e tanto o candidato pode não se sentir mais confortável no projeto quanto a empresa pode também não entender as dificuldades que o profissional está enfrentando. Portanto, precisamos ir além do checklist de conhecimento nas ferramentas do projeto.

A última regra está em destaque porque é a única realmente absoluta, todas as outras possuem exceções, mas são usadas para definir o comportamento mais comum para os dados. Por exemplo, os dados que descrevem um produto em um e-commerce são acessados constantemente, mas ainda seguem as duas outras regras. Feita esta distinção, hoje falaremos um pouco sobre algumas arquiteturas utilizadas para organizar os dados analíticos.

Começando pela arquitetura mais tradicional, o Data Warehouse consiste em uma instância do banco de dados dedicada ao BI e a outros processos analíticos. Nele é feita uma remodelagem dos dados buscando otimizar a performance para a execução de processos analíticos. É comum que os dados de diferentes bancos de dados sejam consolidados nesta instância do Data Warehouse, não sendo necessário onerar os bancos de dados de produção (transacionais) quando forem executados os processos analíticos.

Com o crescimento do volume de dados e a diversificação das estruturas de dados utilizadas surgiu o Data Lake. Eu gosto de pensar no Data Lake como sendo o ambiente Hadoop em si (nunca conheci algum que não fosse). Ele consiste em um file server onde os dados são depositados e processados por um sistema de big data (Hadoop, Spark ou alguma aplicação derivada). Este sistema também é capaz de extrair dados de outros bancos de dados, realizando a junção de dados estruturados, semi-estruturados e não-estruturados. Como um bom dinossauro da área de dados eu já tive a oportunidade de trabalhar em um data lake e sei bem como é fácil ele se tornar um data swamp (pântano de dados).

Surgindo para tentar resolver o problema da governança dos dados no data lake, o data lakehouse é uma arquitetura que combina a flexibilidade do data lake com a governança do data warehouse. Criado e popularizado pela Databricks, o data lakehouse utiliza as delta tables para fazer a estruturação dos dados enquanto a aplicação fornece ferramentas que permitem o fácil acesso e governança dos dados. Também é comum que o data lakehouse possua uma arquitetura medalhão, que é uma forma de organizar o processo de transformação dos dados.

Com a demanda de dados entregues com uma velocidade cada vez maior, alguns processos analíticos estão ganhando características mais próximas dos dados transacionais, por isso a arquitetura Shift Left vem ganhando força nas empresas. Esta arquitetura consiste na mudança de alguns processos analíticos para que sejam feitos com os “dados vivos”. Isso significa que alguns dados de streaming podem sofrer transformações em tempo real e serem entregues ainda no pipeline do processo de streaming. As tecnologias mais utilizadas para realizar este tipo de processo são o Apache Kafka para a execução do pipeline em streaming e o Apache Flink para a realização de transformação dos dados em tempo real.

Existe também o conceito de data warehouse plus onde se realiza todo o processo de um data warehouse, porém utilizando tecnologias que misturam processamentos NoSQL (como bancos de dados colunares) com uma camada SQL para realizar as consultas. Esta é a estrutura mais comum hoje nas startups, porém é comum ver profissionais chamando-as de data lakes. Isto acontece porque os nomes destas arquiteturas são comumente utilizados de maneira freestyle e é comum ver profissionais da área misturando os conceitos. Por isso, espero que este artigo tenha te ajudado a entender a diferença entre cada arquitetura. Esse conhecimento é uma benção e uma maldição ao mesmo tempo, porque agora você sentirá uma dor física toda ver que alguém chamar um banco Postgres de data lake.

Antes de me aprofundar mais no assunto é preciso deixar claro que existem diferentes visões sobre o assunto dependendo do seu grau de senioridade. Para pessoas júniors e com pouca experiência, não há muito o que fazer a não ser se submeter a estes code challenges enviados pelas empresas. Quando estamos precisando de uma oportunidade, fica difícil se recusar a participar de processos seletivos porque eles possuem uma etapa com code challenge. Para você que está começando a carreira, a minha mensagem é “não se frustre!”. O code challenge não é uma boa ferramenta para medir a sua capacidade e conhecimentos técnicos.

Para explicar o meu ponto de vista eu vou falar um pouco sobre a minha experiência. Já fiz inúmeros code challenges e sempre tive a sensação de que era muito mais uma questão de sorte do que de conhecimento. Em uma ocasião específica me enviaram um code challenge com duas questões de Python onde eu teria uma hora para resolver as questões. Na primeira questão eu cometi um deslize na lógica e gastei todo o tempo sem entender porque a minha solução não funcionava. Pouco tempo depois eu estava perdido em meus pensamentos quando percebi o erro que havia cometido e lamentei ter falhado por um descuido tão simples. Para a minha surpresa a recrutadora me ofereceu a possibilidade de tentar realizar o teste mais uma vez. Ao tentar novamente eu consegui resolver as duas questões em menos de 5 minutos. Neste dia eu comprovei; não é só conhecimento, é sorte! Se você der o azar de deixar passar um erro simples, todo o seu teste pode ir por água abaixo. É como aquela prova de matemática onde o você resolve corretamente a integral e as derivadas, mas erra uma simples soma durante o processo e tira zero na questão.

Em outra ocasião eu recebi um teste técnico que consistia em 2 questões de SQL e uma sobre Python. Eu logo percebi que já conhecia aquelas questões de outros testes técnicos e sabia como resolvê-las. Como eu estava participando de outro processo seletivo e acreditava que logo seria chamado para outra vaga, decidi testar a minha hipótese. Respondi a questão de Python utilizando uma biblioteca core e, só por diversão, fiz com que o retorno de cada função se tornasse input para outra, de modo que toda a minha resposta coube em apenas uma linha de código (mas o output desejado era obtido). Resultado, fui aprovado e recebi muitos elogios pelo resultado do teste técnico. Neste dia eu comprovei a minha hipótese; ninguém havia olhado a minha solução, apenas olharam se eu tinha atingido os outputs ou não.

Falando um pouco sobre a minha visão como líder técnico. Eu já conduzi diversos processos seletivos e infelizmente eu já caí na armadilha de enviar code challenges para os candidatos. Posso dizer que, até hoje, a única pessoa que me arrependi de ter contratado foi justamente a pessoa que teve o melhor desempenho no code challenge. Esta pessoa entregou um código excelente, muito bem documentado e com testes. Eu fiquei tão impressionado que não prestei atenção nas red flags que a pessoa tinha em suas soft skills. Resultado, uma pessoa muito boa tecnicamente, mas que nunca se integrou ao time, possuía sérios problemas de comunicação e causou muitos problemas no curto período que fez parte da equipe. Por outro lado, eu já consegui convencer a equipe de recrutamento a adotar um live code bem simples de cerca de 30 minutos onde discutimos conceitos simples de algoritmos com os candidatos. Resultado, a empresa recrutou talentos incríveis! Alguns permanecem na empresa até hoje, outros seguiram carreira internacional e outros ainda se tornaram gestores em outras empresas. Não conheço um só candidato desta fase que não tenha dado certo!

Por fim, preciso dizer que não sou completamente contra os code challenges, mas às vezes (quase sempre) eles são usados de uma forma equivocada. Para as empresas e para os recrutadores enviar um code challenge é muito confortável. É como lançar uma rede ao mar e ver quais peixes vem, mas profissionais qualificados não são como peixes no mar! É preciso estar atento para não perder um bom profissional simplesmente porque ele fez o teste em um dia ruim. Além disso, é muito mais fácil ensinar um conhecimento técnico do que uma soft skill. Afinal, um profissional de tecnologia tem que estar em constante aprendizado, então é muito melhor avaliar a sua capacidade de entendimento da tecnologia e a sua motivação para continuar aprendendo do que avaliar o que ele já sabe.

Sintetizando, acho que os code challenges deveriam ser usados com responsabilidade (enviar code challenge e não ver a resposta do candidato deveria ser crime previsto na lei!). Os recrutadores precisam ter maturidade para saber qual é o conhecimento básico que a vaga exige e parar com aquele discurso de mas eu acho que saber subir um cluster Kubernetes é o básico. Enquanto os code challenges estiverem sendo utilizados como principal critério de recrutamento, as empresas continuaram perdendo excelentes talentos.

Neste artigo eu irei demonstrar algumas das funções que a biblioteca possui na sua versão para Python. No entanto, também existem versões desta biblioteca para JavaScript, .Net, Ruby, Rust e Golang.

Começando por uma pequena demonstração do CPF. É possível gerar, validar e formatar um CPF utilizando as funções contidas no objeto cpf.

Podemos fazer o mesmo também para o CNPJ.

No exemplo a seguir eu utilizei o endereço da casa onde eu passei a minha infância para retornar as informações sobre o logradouro, inclusive o CEP.

Note que inicialmente a validação do CEP retornou como False, mas é necessário que sejam removidos os caracteres especiais antes de realizar a validação.

Ainda sobre o CEP, é possível também resgatar um logradouro informando o CEP. Neste exemplo estou utilizando o CEP de uma famosa rua da cidade do Rio de Janeiro.

Outro objeto que pode ser muito útil é o license_plate que possui ferramentas para trabalhar com dados de placas de carro. Como vemos no código abaixo, é possível gerar uma placa de carro no formato atual (padrão Mercosul) ou no formato antigo utilizando o parâmetro format. Também é possível realizar a conversão de uma placa no formato antigo para o padrão Mercosul.

Nesta biblioteca existem ainda funções relacionadas ao IBGE que podem ser muito úteis, como uma função para obter o código do município a partir do seu nome e uma outra função para gerar o nome da UF a partir do seu código.

Por fim, existem muitas outras funções que podem ser usadas para facilitar o tratamento de dados brasileiros, como uma função para verificar feriados, uma função para formatar valores monetários em real e uma função para transformar datas em texto corrido.

Esta biblioteca pode ser uma ótima oportunidade para aqueles que querem começar a contribuir com projetos Open Source. Por isso, se você achou a biblioteca interessante e teve alguma ideia de melhoria, ou apenas deseja ajudar de alguma forma, não deixe de colaborar com o projeto.

Mas, primeiramente…

O que é um Lexador?

Nada mais é do que um programa que irá percorrer e escanear, da esquerda para a direita, os caracteres da nossa linguagem. Nesta etapa, serão identificados os lexemas (que também podemos chamar de símbolos ou tokens) e seu tipo, seu devido significado naquela instrução.

Existem diferentes categorias de símbolos…

Palavras-reservadas

Também chamadas de keywords, são palavras que estão presentes na linguagem de programação e são utilizadas para se escrever instruções do que queremos que nosso programa faça. Por exemplo, palavras como “while“, “for“, “const“, “else” e entre outras que já fazem parte da linguagem e não podem ser usadas para nomear variáveis ou funções.

Aliás, as funções nativas de uma linguagem também são categorizadas como palavras-reservadas e não podem ser usadas para criar alguma outra instrução. Mas, não se preocupe, caso você não saiba que o nome que você deu a uma variável ou função que já exista na linguagem, ela mesma irá te avisar!

Então, tomando como o exemplo o Pituguês, se quisermos desenvolver uma função para inverter a ordem de um vetor e queremos nomeá-la com inverter, não será possível, pois já existe uma função que leva este nome.

Identificadores

É classificação que recebe tudo aquilo que podemos nomear enquanto desenvolvemos um programa! Ou seja, quando damos um nome a uma variável, seu nome é chamado de “identificador”. O mesmo acontece quando nomeamos uma função.

Se criarmos a seguinte função…

função somar(valor1, valor2):
    retorna valor1 + valor2 

Vamos ter a palavra-reservada função para declaração de funções e, em seguida, o identificador somar. É assim que o Lexador irá reconher o nome da função e categoriza-lo para que seja reconhecido dentro da linguagem.

Constantes

São valores que não sofrem alterações ao longo da execução do programa. Pense que se formos desenvolver um software matemático, o valor do número PI (3,14) jamais poderia ser alterado durante a execução. Linguagens como JavaScript e Delégua permitem que constantes sejam declaradas da seguinte forma:

const valor_de_pi = 3.14;

No entanto, assim como no Python, o Lexador de Pituguês não reconhece ou permite a declaração de constantes como no exemplo de Delégua e JavaScript. Mas isto é algo que pode ser contornado se aplicarmos a convenção do Python no Pituguês que é declarar uma variável em caixa alta:

VALOR_DE_PI = 3.14

Esta convenção fará com que outras pessoas que tiverem contato com o código entendam que aquele dado não deve ser alterado.

Mesmo que o Lexador do Pituguês não seja capaz de reconhecer constantes, achamos que é importante trazer para nossos leitores que elas ainda são uma forma de se identificar e categorizar dados e que, para que seu reconhecimento seja possível, deve ser incluído na programação de um Lexador (afinal, vai que um dia você mesmo queira desenvolver uma linguagem que use constantes…).

Operadores

Outra categoria que um Lexador deve ser capaz de mapear são os operadores. Dentro das linguagens de progamação, teremos:

• Operadores Aritméticos: são os símbolos usados para realizar operações matemáticas – adição, subtração, multiplicação, divisão, módulo e exponenciação. Você pode encontrar os operadores aritméticos (ou matemáticos) que existem no Pituguês na documentação;
• Operadores Relacionais: são os operadores usados para comparação – igual a, diferente de, maior que, menor que, maior ou igual e etc… também temos eles descritos na documentação do Pituguês;
• Operadores Lógicos: podem ser símbolos ou palavras-reservadas em que podemos verificar condições, geralmente retornam os valores verdadeiro ou falso. Os símbolos mais utilizados são: AND, &&, OR, || e ! – mas existem outros mais! Na documentação do Pituguês, temos listados os operadores lógicos e os operadores bit a bit, que também podem se encaixar nesta categoria.

Símbolos Especiais

Geralmente são os símbolos usados na estruturação do programa, por exemplo, quando uma linguagem requer que sua instrução seja terminada em ponto e vírgula, ou que a declaração de vetores exige que seus dados devem estar escrito entre colchetes. Nessas situações, o ponto e vírgula e os colchetes seriam os “símbolos especiais” que fazem parte da estrutura da linguagem para a escrita de comandos.

Lexemas

Nada mais são dos que as strings que correspondem com um típo de símbolo. Por exemplo… quando declaramos uma variável em Pituguês:

nome_da_linguagem = "Pituguês"

Comentamos antes que o nome da variável é reconhecido como identificador, mas ele também vai ser mapeada como um lexema. Então, quando escrevemos esta linha de código em Pituguês e depuramos o Lexador, ele nos trará este retorno:

simbolos: [
    Simbolo {
      tipo: 'IDENTIFICADOR',
      lexema: 'nome_da_linguagem',
      literal: null,
      linha: 1,
      hashArquivo: undefined
    },
    Simbolo {
      tipo: 'IGUAL',
      lexema: '=',
      literal: null,
      linha: 1,
      hashArquivo: undefined
    },
    Simbolo {
      tipo: 'TEXTO',
      lexema: 'Pituguês',
      literal: 'Pituguês',
      linha: 1,
      hashArquivo: undefined
    }
 ]

Note o Lexador nos retorna uma lista de símbolos, em formato json, e cada símbolo é mapeado de acordo com seu tipo e seu lexema. Aqui, o lexema é a declaração literal da escrita da instrução!

Esta etapa é bastante importante para que se tenha a base inicial ao programar uma linguagem de programação, pois a partir da identificação desses lexemas e tipos é que poderemos criar as regras de execução de cada símbolo, baseados na sua função. E isto acontecerá na etapa do Avaliador Sintático.

E como eu posso contribuir com a linguagem Pituguês?

O repositório em que podemos encontrar o Pituguês está disponível no GitHub, dentro do projeto Delégua, então, é dentro desse projeto que podemos fazer contribuições diretamente no Pituguês: é onde está seu código fonte.

Além disso, temos outro repositório em que disponibilizamos um documento que ensina a como contribuir com a linguagem! Lá você vai encontrar um guia de como criar uma conta no GitHub, um passo a passo de como contribuir com a linguagem e como deve registrar sua contribuição na plataforma.

Um pequeno adendo…

Aderir a boas práticas, registrando no GitHub seu processo de contribuição é de suma importância! No guia de contribuição que trouxemos para vocês, é ensinado a como buscar por issues para contribuir – ou abrir as próprias issues – e como fazer um PR (Pull Request). Parte da função dessas etapas é deixar documentado e acessível para que outros contribuidores possam acompanhar o desenvolvimento da linguagem.

Aliás, não apenas para que outras pessoas consigam acompanhar o desenrolar do projeto, mas também é uma forma de mostrar para o mundo o seu trabalho! Aqui na Cumbuca Dev, a gente promove e incentiva a contribuição em projetos de Código Aberto, por ser uma das formas de pessoas iniciantes aprenderem e se desenvolverem na programação, enquanto conquistam experiência real que será super válida para o mercado de trabalho!

Ou seja, enquanto você consegue participar ativamente, ajudando com o crescimento de um projeto e trocando ideia com outros contribuidores, também consegue desenvolver suas habilidades! E como tudo isso é feito com transparência, você pode facilmente comprovar experiência!

Contribuindo com o Lexador!

No documento que contém o guia de como contribuir, temos esta seção que trata da Estrutura do Projeto, nela, temos sinalizados os principais arquivos que estão envolvidos na programação do Pituguês.

Mantendo o foco no Lexador, queremos trazer um exemplo de contribuição que foi implementado por quem vos escreve, a fim de ilustrar brevemente como adicionar uma funcionalidade neste elemento estrutural do dialeto.

No início…

Como Pituguês é um dialeto, muitas estruturas e características acabavam sendo herdadas de Delégua, parecia até uma cópia. O que podemos dizer que “não era considerado muito Pythônico”, uma vez que a proposta do Pituguês é ser um equivalente a Python, enquanto Delégua tem como principais influências Ruby, C# e Kotlin.

Conforme fui estudando mais o dialeto e seu código, identifiquei que o Pituguês usava a mesma função que Delégua: escreva. Então, na época, como Pessoa Iniciante Contribuidora, isto me deixou um pouco inquieta, pois se queremos aproximar o Pituguês do Python, poderíamos buscar traduções equivalentes em casos como este.

Dessa forma, veio a ideia de transformar o escreva em imprima, uma tradução um pouco mais direta do print da linguagem na qual Pituguês se inspira.

Como foi comentado, o Lexador visa identificar os símbolos e seus tipos para que depois sua lógica possa ser implementada no Avaliador Sintático. Precisamos lembrar que o comportamento para uma função chamada imprima já existia na função escreva da linguagem e apenas queríamos adicionar um sinônimo a ela. Portanto, o que precisamos fazer é simplesmente adicionar a palavra “imprima” como uma palavras-reservadas e fazer com que o Lexador a reconheça como parte do Pituguês.

Quais arquivos eu mexo?

Todo o código-fonte da linguagem está dentro do diretório fontes do projeto e como vamos mexer no Lexador do Pituguês, o caminho para chegar até ele é:

fontes > lexador > dialetos > lexador-pitugues.ts

Dentro deste arquivo, você vai encontrar uma função chamada mapear. Imagine que você escreveu a seguinte linha de código:

imprima("Você está aprendendo sobre o Lexador do Pituguês!")

Quando você escreve uma instrução como esta em um editor de código como o VS Code, por exemplo, deve lembrar que escrevemos apenas texto no editor e que esse texto precisa ser traduzido para a linguagem de máquina, como comentamos neste artigo.

Nesse contexto, o Lexador é quem fará a primeira etapa de reconhecimento do que há escrito no código, identificando e retornando os tokens ali presentes, com seus respectivos tipos. Basicamente, neste primeiro momento, precisamos apenas identificar os lexemas que compõe a nossa instrução.

Dentro do Lexador do Pituguês, temos a função mapear para percorrer todas linhas de código escritas no editor, identificando quando aquele comando é iniciado é encerrado. Assim como também verifica a partir de que momento está o início e o final do código por inteiro.

Mas ainda não é aqui que vamos adicionar a palavra-reservada imprima!

Dentro do mapear, temos um trecho de código assim:

while (!this.eFinalDoCodigo()) {
     this.inicioSimbolo = this.atual;
     this.analisarToken();
}

Em resumo, esta instrução está dizendo que “enquanto não for o fim do código, cada token deverá ser analisado”. E é aí aqui que vamos fazer com que o nosso comando imprima seja reconhecido! Através da função analisarToken no Lexador!

Esta função vai capturar caractere por caractere da nossa linha de código e vai buscar identificar cada um deles em um longo switch case. Pode reparar que vamos ter diversos cases para caracteres diferentes (tabulação, espaçamento, nova linha, ponto e vírgula etc). Caracteres correspondentes às categorias que vimos anteriormente no artigo (palavra-reservadas, identificadores, operadores e símbolos especiais). Ou seja, a partir de um momento que o nosso analisarToken consegue identificar um desses caracteres, ele vai verificar se há um tipo de símbolo correspondente ao caractere.

Mas como vamos conseguir identificar a palavra imprima como palavra-reservada dentro deste switch case?

Ainda dentro do analisarToken, no final do switch case, temos:

default:
    if (this.eDigito(caractere)) this.analisarNumero();
    else if (this.eAlfabeto(caractere)) this.identificarPalavraChave();
    else {
         this.erros.push({
                   linha: this.linha + 1,
                   caractere: caractere,
                   mensagem: 'Caractere inesperado.',
          } as ErroLexador);
          this.avancar();
    }

Este trecho vai percorrer os caracteres também, mas seu objetivo é identificar o que é número e o que pode ser alguma letra do alfabeto. Inclusive, note que, na terceira linha, temos uma condição que diz que se haver um conjunto de caracteres, deve ser identificada a palavra chave através da função identificaPalavraChave!

Bom… vamos para esta função agora… nela, vai haver uma série de verificações quanto a composição da sequência de caracteres, mas a cereja do bolo está quando ela, finalmente, consegue determinar o lexema neste momento:

const tipo: string =
    textoPalavraChave in palavrasReservadas
         ? palavrasReservadas[textoPalavraChave]
         : tiposDeSimbolos.IDENTIFICADOR;

Aqui temos o que é chamado de “condição ternária” e está sendo verificado se a palavra que foi escrita no código existe ou não enquanto palavra-reservada.

Na segunda linha do trecho de código anterior, temos a constante palavraReservada, em que temos dentro dela uma lista de palavras-reservadas. Esta constante é importada de um outro arquivo que está no caminho:

fontes > lexador > dialetos > palavras-reservadas > pitugues.ts

Dentro da constante, vamos adicionar o nosso “imprima”, porém… temos que declará-lo neste formato:

imprima: tiposDeSimbolos.IMPRIMA

Você pode conferir a lista de palavras-reservadas neste link do GitHub.

Adicionar o imprima nesta lista de palavras-reservadas ainda não é o suficiente, temos que adicionar, também, na lista de objeto tiposDeSimbolos que está no arquivo:

fontes > tipos-de-simbolos > pitugues.ts

Você pode dar uma olhadinha neste arquivo para conferir o formato que devemos adicionar o nosso tipo de símbolo que é:

IMPRIMA: 'IMPRIMA'

Testando a nossa adição

Seguindo todos esses passos, você já pode adicionar uma nova palavra-reservada no Lexador do Pituguês, mas a gente ainda precisa garantir que ela está sendo reconhecida pela linguagem e sendo executada corretamente.

Agora, vamos ir para nosso arquivo de teste do Lexador de Pituguês que você pode encontrar no seguinte caminho, já saindo do fontes:

testes > lexador > dialetos > pitugues > lexador.test.ts

Já dentro do arquivo, queremos saber se o Lexador já está identificando imprima como nova palavra-reservada, então devemos elaborar um teste unitário e executá-lo:

it('Sucesso - imprima', () => {
    const resultado = lexador.mapear(
        ["imprima('Você está aprendendo sobre o Lexador do Pituguês!')"],
        -1
    );
    expect(resultado).toBeTruthy();
    expect(resultado.simbolos).toHaveLength(4);
    expect(resultado.simbolos).toEqual(
        expect.arrayContaining([
            expect.objectContaining({ tipo: 'IMPRIMA' }),
            expect.objectContaining({ tipo: 'PARENTESE_ESQUERDO' }),
            expect.objectContaining({ tipo: 'TEXTO' }),
            expect.objectContaining({ tipo: 'PARENTESE_DIREITO' }),
        ])
    );
  });

No teste para o Lexador, note que estamos apenas verificando se contém os tipos de símbolos esperados naquela linha de código. É apenas isto que precisamos fazer com o Lexador: verificar se nossos símbolos estão sendo reconhecidos como previsto.

Após adicionar o teste, logo acima dele, no VS Code, você verá escrito Run | Debug e você pode clicar no Run para executar o teste e ver se ele é aprovado. Caso ele passar nos testes unitários, podemos enviar nossa contribuição para o repositório do projeto.

A Design Líquido já fez um vídeo ensinando a programar um Lexador neste vídeo do YouTube! Você pode dar uma conferida nele para ver como é todo o processo em ação.

Lembrando que também temos este guia de como você pode fazer sua contribuições no código-fonte da linguagem!

E agora?

Bom, agora que você já sabe como funciona e como se programa um Lexador, te convidamos a aprender e testar o Pituguês! ​ Escrevemos este tutorial para te ensinar a como programar com ele! Além disso, você sempre pode consultar a documentação!

Neste repositório temos descrito alguns desafios para fazer em Pituguês! E se, por caso, tiver qualquer dificuldade com a linguagem, já pode reportar pra gente que te ajudamos!

Começando pelos bancos de dados tradicionais, estes surgiram por uma necessidade de organizar os dados, armazenando-os de forma segura ao mesmo tempo que fornece meios simples para acesso aos dados armazenados. Os bancos de dados seguem um padrão chamado ACID onde implementam funcionalidades para garantir as quatro características que formam a sigla: Atomicidade, Consistência, Isolamento e Durabilidade. Além disso, estes bancos de dados adotaram uma linguagem padronizada para a consulta dos dados, o SQL. Os bancos de dados transacionais mais populares são o Postgres e o MySQL para projetos menores (ambos open source) e o Oracle e SQL Server para projetos maiores (ambos proprietários).

Talvez o banco de dados NoSQL mais conhecido seja o MongoDB. Este é um banco de dados open source que utiliza estruturas chamadas de documentos (muito semelhantes ao JSON) para armazenar os dados. Assim, o MongoDB foge do padrão tradicional de tabelas para um padrão de dados com um schema flexível, isto é, dados semi-estruturados. Além disso, ele também quebra o padrão ACID, assumindo que inconsistências eventuais podem ocorrer (as versões mais atuais do MongoDB aceitam transações ACID). Isso tudo trouxe ao MongoDB uma maior velocidade e versatilidade, principalmente no processo de escrita dos dados.

Voltando a pensar nos bancos de dados tradicionais nos por um instante. Em seu processo de armazenamento e recuperação dos dados eles mantém todos os dados armazenados no disco rígido e quando é solicitada a leitura de um grupo de dados selecionados, estes são levados para a memória RAM para poderem ser acessados e mantidos lá por um curto período de tempo enquanto houver instruções para que estes sejam acessados. Mas e se nós quiséssemos que todos os dados de um bando de dados ficassem disponíveis diretamente na memória RAM o tempo todo? Para isso foi criado o Redis, um banco de dados que segue a estrutura chave-valor e possui uma velocidade impressionante de acesso aos dados (e um custo igualmente impressionante). Este banco de dados é muito utilizado para fazer cache de dados.

O HBase é um banco de dados colunar que foi desenvolvido pela Google e se tornou um banco de dados open source, sendo agora mantido pela Apache Foundation. Comparado com os bancos de dados tradicionais, o HBase possui uma performance ruim ao lidar com pequenas quantidades de dados, porém sua performance ao lidar com grandes massas de dados é muito superior à dos bancos de dados tradicionais. Este tradeoff permite que este banco de dados seja uma boa opção para processos analíticos que utilizam grandes massas de dados. Esta arquitetura deu origem à diversos bancos de dados fornecidos pelos provedores de serviços na nuvem, como o BigQuery e o Redshift.

Podemos classificar estes bancos de dados em quatro categorias: Relacionais, Orientados à Documento, Chave-Valor e Colunares. Há ainda uma quinta categoria que não abordamos aqui, os bancos de dados de Grafos. Porém, não vamos explorar esse tipo de banco de dados neste artigo, assim como não exploramos a imensa maioria dos bancos de dados. Antes de finalizar este artigo é importante comentar que é muito comum ver projetos utilizando bancos de dados totalmente equivocados em seus processos. Eu já vi (em mais de uma ocasião) empresas utilizando bancos de dados colunares em processos transacionais e depois reclamando que o processo está demorando muito para retornar os dados. Também já vi projetos querendo realizar processos analíticos com um banco de dados MongoDB e reclamando que o schema quebra constantemente os processos. Como vimos no artigo Organização dos Dados Analíticos, dados transacionais (OLTP) e dados analíticos (OLAP) possuem características diferentes e por isso, muitas vezes, precisam de bancos de dados que atendam suas especificidades.

É importante ser honesto e deixar claro que este é um projeto introdutório, totalmente distante do mundo real onde os dados costumam ser muito mais complexos e caóticos. Porém, utilizando a linguagem Python e a biblioteca Scikit Learn, podemos criar um modelo de machine learning capaz de realizar a classificação de três diferentes tipos de flor Íris. Para isto, vamos utilizar um dataset criado por Ronald Fisher que em 1936 realizou a medição das estruturas de diversos exemplares destas flores, classificando-as entre as espécies setosa, versicolor e virginiana. Para treinar um modelo capaz de classificar qual a espécie de cada flor Íris será utilizada a técnica de KNN (K-Nearest Neighbor).

Para este micro projeto, vamos assumir que o leitor já possua uma instalação do Python e um ambiente de desenvolvimento configurado. Vamos utilizar apenas três bibliotecas: Numpy, Matplotlib e SciKit Learn (vamos apresentar o projeto em um Jupyter Notebook, mas a sua instalação é opcional). Após executarmos a instalação das bibliotecas vamos importar algumas funções que usaremos em nosso algoritmo.

Agora devemos realizar o download do dataset Íris e a divisão das medidas da estrutura das flores (X) e da classificação da espécie de cada flor (Y). Além disso, vamos separar 80% do dataset para realizar o treino e 20% para realizar o teste do modelo. Utilizando o parâmetro test_size na função train_test_split, podemos inserir um valor de 0.0 à 1.0 para indicar a porcentagem do dataset que será dedicada ao teste, finalizando a divisão no nosso dataset em quatro variáveis. A partir do momento que o dataset é lido e está em memória passamos a chamá-lo de dataframe.

Podemos visualizar os valores no dataframe original a seguir.

Agora vamos realizar o treinamento do nosso modelo.

Sim, apenas com estas poucas linhas de código nós já possuímos um modelo de machine learning treinado. Utilizando a função score podemos verificar a acurácia média do modelo que foi de 96% (vou falar sobre isto na conclusão do artigo).

Para entendermos um pouco mais sobre o dataframe com o qual nós estamos trabalhando, podemos gerar dois gráficos. No primeiro é mostrada a divisão dos de cada tipo de flor pelo tamanho da sépala, no segundo é mostrada a divisão pelo tamanho da pétala.

Este artigo foi pensado com dois objetivos principais. O primeiro era demonstrar que algumas técnicas de machine learning são simples e podem ser executadas com poucas linhas de código. A segunda era demonstrar que, em alguns raros casos, um simples modelo de machine learning é o suficiente para criarmos um modelo extremamente eficiente. Este modelo possui 96% de acurácia média e parece ser uma solução mais que suficiente para identificar este tipo de flor. Obviamente que existem outras questões a serem verificadas, como a dificuldade de se ter um dataset organizado como este no mundo real e a possibilidade do modelo estar viciado. Porém, o ponto é que, às vezes, uma técnica simples de IA é mais que o suficiente para criar uma solução eficiente. Então, por que não começarmos pelo simples?

Para escrever este artigo eu me baseei na minha própria palestra realizada para o PET Matemática da UFSC e o código utilizado está disponível no meu Github.

Certo dia estava assistindo a uma live onde a pessoa apresentadora estava jogando e alguém perguntou: onde tem esse jogo?
A resposta foi: esse jogo é do Google mesmo.
Penso que essa resposta veio da seguinte lógica: Acessei o Google e pesquisei pelo jogo, logo o jogo é do Google.

O que pode ter de errado nessa resposta?

Bem, o jogo poderia ser realmente do Google, porém não era o caso, o jogo estava em um site acessado via navegador.
Acredito ser comum essa associação entre o buscador do Google e de fato um produto da empresa Google ser feita por pessoas usuárias leigas. Para quem não entende o que acontece por trás das telas, essa confusão pode acontecer, até mesmo pelo Google ser um dos buscadores mais utilizado no mundo.

Quem nunca ouviu “dá um Google”?

Por que não é correto afirmar que um site de jogo não é do Google, se foi lá que encontrei?

O que acontece aqui é que a pesquisa feita em buscadores (Google, DuckDuckGo, Ecosia, entre outros) trazem como resultado uma lista gigante de sites diversos contendo as palavras-chave pesquisadas. Cada buscador tem seus próprios mecanismos de disponibilidade de informações, podendo apresentar os sites que tenham maior relevância com o tema pesquisado (em um mundo ideal), aplicando algumas regras de classificação ou até apresentando propagandas como prioridade (muitos buscadores aderem a esse quesito).

Ok, mas como esses sites são encontrados?

Por trás de cada tela desenhada no navegador, existe uma estrutura de código, algumas partes ficam visíveis para as pessoas usuárias, como: textos, imagens, mídias, botões, etc; e algumas informações ficam “escondidas” mas são lidas pelos buscadores.
Essas informações podem dar uma posição melhor na lista dos buscadores quando são corretamente colocadas na estrutura do site.
Um exemplo básico: Se eu crio um site com o tema de Python, o interessante é que o nome do site tenha relação com o tema, assim como as palavras-chave na estrutura oculta, o conteúdo visível, qualidade dos textos, entre várias outras características. (Você pode pesquisar mais sobre SEO).
Então com essas informações no site, os buscadores conseguem rastrear, indexar e classificar o site para quando a palavra Python for buscada, o site apareça nessa lista.

Teste!
Se você pesquisar por “cumbucadev” no seu navegador, quais são os primeiros conteúdos apresentados para você?

Mas se esses sites não são da Google onde são encontrados?

Os sites são hospedados em servidores de diversas formas, podendo estar em grandes empresas ou até mesmo na sua própria casa.
Quando um site é disponibilizado na internet (uma rede global de computadores conectados) ele tem o seu endereço amigável. Vamos utilizar como exemplo: cumbuca.dev, porém o navegador não entende diretamente qualquer caractere digitado, o que ele consegue entender são endereços IP (IPv4 ou IPv6).

Quando eu acesso um site diretamente pelo endereço amigável, ocorre uma série de acontecimentos, simplificando:

• O nome amigável que acessei vai para um servidor DNS
• O servidor DNS tem uma lista de nomes de sites cadastrados e retorna o seu respectivo IP
• Com o IP, o navegador consegue te entregar o site pesquisado.

Teste!
Abra o terminal e digite ping cumbuca.dev e veja o IP que retornará!

Então, uma das etapas dos buscadores é rastrear novos sites que são hospedados diariamente, para isso existem bots exploradores que acessam os sites, fazem a leitura das informações e entendem do que se trata, para depois indexá-los e classificá-los para entrar na lista de buscas, formando um grande banco de dados de informações.

Continue a discussão

• Você conhecia esse fluxo?
• Apresentamos várias siglas aqui, gostaria de aprender mais sobre alguma delas?
• A popularização dos Chat bots com IA mudou a experiência de buscas?

Deixe seu comentário!

O machine learning consiste em um grupo de técnicas de inteligência artificial como a regressão linear, support vector machine (SVM), K-Nearest Neighbor (KNN), deep learning etc. Estas técnicas são divididas em dois grupos: Aprendizado supervisionado e aprendizado não-supervisionado. É importante saber que todas estas são técnicas de machine learning para entender que cada uma delas possui uma melhor aplicação em um contexto específico.

Começando pela regressão linear, esta é uma técnica matemática básica que consiste em encontrar um padrão definido pela média de valores nos eixos (podendo haver dois ou mais eixos) para realizar uma predição sobre valores ausentes em novos inputs para um ou mais eixos. Esta definição parece muito complexa (e é, porque eu decidi escrever da minha cabeça ao invés de copiar de algum lugar), mas a imagem abaixo simplifica tudo. Para um novo input do eixo x, o valor previsto para y será aquele encontrado na linha traçada. Obviamente, por precisar de um histórico de dados para traçar uma linha preditiva, esta é uma técnica de treinamento supervisionado.

Falando agora sobre o KNN, este se trata de um algoritmo de classificação onde os valores são agrupados de acordo com a sua proximidade. Este também se trata de um algoritmo de aprendizado supervisionado, bastando informar o número de grupos que devem ser criados durante o processo de classificação (valor de K) e fornecer um dataset com os grupos a que cada elemento pertence. Com isto o algoritmo irá classificar os novos inputs de acordo com a proximidade dos grupos já formados.

Por fim, vamos falar sobre o deep learning. Esta é uma técnica bastante complexa que envolve uma arquitetura baseada na ideia (antiga) de como o nosso cérebro funciona. Basicamente o deep learning consiste em testar diferentes combinações de pesos para as features (dados inseridos) buscando a melhor combinação possível para chegar até a resposta desejada. Existem diversos algoritmos de deep learning, mas o mais famoso entre eles é o Tensorflow. Existem também diversas técnicas para aplicação de deep learning e cada uma delas costuma ser mais eficiente com para criar modelos preditivos para um tipo específico de problema, como o CNN para imagens, RNN para textos e até mesmo PINNs para problemas que envolvem cálculos diferenciais. 

Assim como a maioria das tecnologias, cada técnica de machine learning funciona bem para um contexto específico. Talvez esta seja uma das áreas onde a expressão “usar um canhão para matar uma mosca” mais se aplica. É comum ver empresas querendo utilizar técnicas avançadas de deep learning para problemas que seriam facilmente resolvidos com uma simples regressão linear. Eu mesmo já tive a experiência de entrar em um projeto de NLP onde foram discutidas diversas técnicas de machine learning para serem aplicadas e, no fim, eu consegui atingir 98% de assertividade com um simples algoritmo utilizando REGEX.

Por isso, é importante aprender a lógica por trás de cada técnica de machine learning. Devemos sempre optar pela solução que seja mais eficiente e mais simples, abrindo mão da simplicidade apenas quando em troca obtemos um aumento significativo na efetividade.

Muitas pessoas ainda confundem o conceito de dataset com o de dataframe, mas a diferença é realmente muito sutil. Datasets são os conjuntos de dados armazenados, geralmente em formato CSV, mas podendo também estar em bancos de dados. Já os Dataframes consistem nestes mesmos conjuntos de dados, porém quando estes são lidos por algum toolkit e encontram-se em memória para serem manipulados.

Voltando agora para o tema central do artigo, a biblioteca Pandas sofreu um novo major release e isso significa que haverão mudanças significativas em suas funções e em seu comportamento. Para começar, todas as funções que estavam marcadas como deprecated serão removidas, o que significa que se você recebia um warning quando executava seu script, talvez seja bom revisar o seu código antes de fazer um upgrade para o pandas 3.0.

Como sabemos, Python é uma linguagem fracamente tipada, o que significa que você não precisa declarar qual será o tipo da variável ao criá-la. Esta é uma solução muito prática para a pessoa desenvolvedora, mas tem um custo grande na performance do script. Isto porque a linguagem Python transforma toda variável criada em um objeto, não possuindo tipos nativos. Já a biblioteca Pandas utiliza os dtypes, que são os tipos de dados armazenados em objetos otimizados utilizados pelo Pandas chamados Series. Com o release da versão 3.0, agora as strings possuem um dtype próprio (str), deixando de ser tratada com o dtype genérico object. Isto significa que a biblioteca terá uma performance ainda melhor no tratamento de dados do tipo string.

Outra novidade neste novo release é com relação a um comportamento ao realizar alterações condicionais no dataframe. Como a biblioteca Pandas segue o paradigma funcional, em seu comportamento padrão ele retorna um objeto com os dados alterados ao invés de alterar os dados no objeto em si. Contudo, ao realizar o código abaixo isto gerava uma ambiguidade onde o objeto às vezes retornava um objeto com os dados alterados e outras alterava os dados do objeto em si.

df["foo"][df["bar"] > 5] = 100

No entanto, com a nova atualização, a alteração dos dados passa a ser feita com a função loc e o comportamento passa a ser realizar as alterações no objeto em si (copy-on-write) ao invés de retornar um objeto alterado.

df.loc[df["bar"] > 5, "foo"] = 100

É importante destacar que, como esta alteração no valor não está sendo feita inteiramente por uma função, ela não fere o paradigma funcional.

Obviamente a manipulação de dados em um dataframe é uma das aplicações mais comuns para a biblioteca Pandas. Por isto, talvez a maior novidade deste release seja a função col (pandas.col). Esta função permite simplificar a sintaxe em operações entre colunas de um dataframe. Enquanto antes era necessário usar funções lambda (funções anônimas) para realizar operações entre as colunas, agora podemos utilizar a função col para simplificar o código, tornando-o muito mais legível.

# Sintaxe utilizando uma função lambda
df.assign(c = lambda df: df['a'] + df['b'])
# Sintaxe utilizando a nova função col
from pandas import col
df.assign(c = col('a') + col('b'))

Este novo release da biblioteca Pandas ainda possui outras novidades que valem ser mencionadas. Entre estas novidades está a função from_arrow que foi adicionada nos objetos DataFrame e Series para importar dataframes de outras bibliotecas, diversas melhorias nas funções to_excel, to_csv e to_json dos objetos DataFrame e Series, adicionada a função read_iceberg para leitura e a função DataFrame.to_iceberg para escrita de dataframes diretamente no Apache Iceberg, anti joins agora são aceitos nas funções join e merge do objeto DataFrame e, por fim, inúmeros bugfixes e melhorias de performance foram aplicados.

Pandas continua sendo uma das bibliotecas mais importantes para a área de dados e este novo release traz inovações que tornam esta ferramenta ainda mais poderosa. É importante lembrar que este projeto incrível é Open Source e sobrevive graças ao esforço de uma comunidade dedicada que vem evoluindo a biblioteca ano após ano. Você também pode contribuir, mas já aviso que é necessário possuir bastante dedicação, pois o seu funcionamento é bastante complexo e há pessoas do mundo inteiro tentando contribuir com o projeto. Porém, não digo isto para te desanimar, mas sim para avisar que será uma longa jornada. No entanto, toda jornada começa com um simples passo e talvez o seu nome esteja no próximo major release do Pandas, e pode ser que tudo tenha começado com a leitura desse simples artigo. 

Caso você queira saber mais, pode acessar:

• O post de release da versão 3.0 no blog da biblioteca Pandas (https://pandas.pydata.org/community/blog/pandas-3.0.html).
• A nota do release no Github (https://github.com/pandas-dev/pandas/releases/tag/v3.0.0)
• A documentação detalhada do release (https://pandas.pydata.org/docs/whatsnew/v3.0.0.html)