Categoria: Programação

Categorias
Full Stack Programação Tecnologia

Uma arquitetura para a importação assíncrona de eventos espaço-temporais em larga escala

Introdução

O Big Data e Inteligência Artificial é um projeto em desenvolvimento pelo Insight Lab e o Ministério da Justiça e Segurança Pública. O objetivo desse projeto é realizar estudos científicos para criar uma plataforma que permitirá integrar e analisar fontes de dados de segurança pública dos estados brasileiros, direcionando, então, a implantação de estratégias para a melhoria da segurança pública.

Entre as ferramentas já disponíveis desse projeto está o Geointeligência, que é um sistema de georreferenciamento aplicado na segurança pública. E desde 2020, essa ferramenta também está sendo usada na área da saúde, pois, devido à pandemia de Covid-19, o Governo do Ceará implementou o Geointeligência para entender a disseminação dessa doença no estado.

Importação de eventos é uma das principais funcionalidades do Geointeligência. Implementado utilizando a linguagem de programação Scala com Play Framework, ele é um dos sistemas desenvolvidos por nossa equipe e tem como objetivo analisar eventos espaço-temporais através de algoritmos que procuram encontrar padrões capazes de ajudar na melhor aplicação de forças tarefas de segurança.

Como o Geointeligência é um sistema analítico, ele precisa que os eventos utilizados em suas análises sejam adicionados à sua base. E uma das maneiras mais importantes para fazer isso é a importação através de arquivos do tipo csv ou xlsx.

A importação de arquivos traz a facilidade de qualquer usuário poder importar seus eventos e utilizar o sistema para fazer análises a fim de identificar padrões úteis em seus eventos. Sem a importação de arquivos, nenhuma organização ou usuário poderiam criar análises com seus eventos, e com isso as análises seriam menos eficazes para diversos casos. Tendo isso em vista, a importação de eventos tem a necessidade de ser uma funcionalidade robusta e eficaz para importar eventos em larga escala.

Motivação – Processando muitos eventos

A importação de eventos passou a ser uma funcionalidade muito importante para nossos usuários. Com isso, notamos que a maioria deles tinham que dividir os arquivos de importação em diversos arquivos menores devido à limitação de tamanho e ao tempo que eles esperavam que sua tarefa fosse concluída para, só então, ter uma resposta do sistema. 

Por conta disso, nossa equipe resolveu que precisávamos melhorar a eficiência da importação para que fosse possível processar muitos eventos através de um único arquivo e com vários usuários ao mesmo tempo. Quantos eventos nós queríamos ser capazes de processar em um só arquivo? 

> Que tal 300.000 eventos?

Arquivos grandes

Em virtude dos requisitos que nós tínhamos à época, nossa implementação inicial da funcionalidade de importação de arquivos era bem simples. Uma vez que o servidor recebesse a requisição HTTP do usuário, ele carregaria todo o arquivo em memória e faria todo o processamento necessário dos eventos contidos nele dentro do escopo dessa mesma requisição, retornando então para o usuário uma resposta com a quantidade de eventos importados.

Dada a necessidade de se importar grandes quantidades de eventos, surgiram dois problemas principais com essa implementação. O arquivo que deveria conter essa maior quantidade de eventos a serem importados precisaria ser significativamente maior, ocasionando um consumo de memória que tornaria progressivamente mais limitada a utilização dessa funcionalidade por múltiplos usuários ao mesmo tempo.

Além disso, mais eventos significavam que a aplicação precisaria gastar proporcionalmente mais tempo para processar um arquivo completo. Por conta disso e pelo fato de a importação ser realizada dentro do escopo de uma requisição HTTP, o usuário poderia precisar esperar por muito tempo até que o upload desse arquivo fosse feito e seus eventos fossem validados e inseridos na base de dados, para só então ter uma resposta e poder seguir utilizando a aplicação, que ficaria “bloqueada” esperando a finalização da requisição.

Devido ao impacto causado pelo consumo de memória e o tempo de espera do usuário durante uma importação, nós precisávamos resolver esses problemas para obtermos uma implementação que suportasse a importação de grandes quantidades de eventos.

Para resolver o problema do consumo de memória, tivemos de elaborar uma estratégia para o processamento do arquivo na qual fosse garantido que o arquivo em si nunca fosse integralmente carregado em memória, o que ampliaria a escalabilidade da aplicação e permitiria, mais facilmente, a possibilidade de importações sendo executadas simultaneamente. 

Em paralelo, para resolver o problema de espera do usuário, chegamos à conclusão de que o processamento dos eventos não poderia estar limitado ao escopo de uma requisição do usuário. Isto é, uma vez que o usuário iniciasse uma importação, o Geointeligência deveria ser capaz de respondê-lo que sua requisição de importação fora aceita, mas o processo de importação em si deveria ser executado em segundo plano. Por consequência, uma vez que a importação fosse executada fora do escopo da requisição de importação, o usuário precisaria receber algum tipo de feedback do sistema informando-o quando sua tarefa fosse concluída. Desta forma, nós também tivemos de desenvolver um mecanismo, independente do escopo de uma requisição, capaz de informar ao usuário que sua importação foi concluída.

Disco é mais barato que memória RAM

Com o crescimento no tamanho dos arquivos de importação, a estratégia que nós havíamos implementado já não funcionava. Para resolver isso, uma opção seria guardar todo o arquivo em disco e depois ir carregando apenas partes dele na memória à medida que os eventos contidos nele fossem sendo processados.

Felizmente, para uma linguagem como o Scala, carregar apenas uma parte de um arquivo em memória não é uma tarefa difícil, uma vez que esse arquivo esteja salvo em disco ou em uma base de dados. Para implementar isso, nós utilizamos apenas as abstrações de InputStream e OutputStream nativas da linguagem de programação, sem que houvesse a necessidade da utilização de nenhuma biblioteca externa. Como os arquivos que nós usávamos armazenavam os eventos de modo sequencial, nós tínhamos tudo o que precisávamos para implementar essa arquitetura.

Desta forma, nós implementamos a seguinte estratégia:

  1. Assim que o servidor recebesse a requisição com o arquivo de eventos, ele seria diretamente armazenado em nossa base de dados através de um stream;
  2. Quando necessário, o sistema retiraria, também através de um stream, partes do arquivo contendo blocos de eventos que precisavam ser validados e inseridos;
  3. Cada bloco de eventos seria, então, processado de modo independente, isto é, cada um dos eventos de um bloco deveria passar por uma série de validações antes de serem inseridos em nossa base;
  4. Quando todo o arquivo fosse consumido, isto é, quando todo o seu conteúdo tivesse sido “lido”, e todos os seus eventos fossem processados, o sistema removeria esse arquivo da base.

Utilizando essa estratégia, nós conseguimos controlar de maneira muito mais detalhada o quanto do arquivo seria carregado na memória dos nossos servidores, além de permitir que partes de um mesmo arquivo pudessem ser processadas paralelamente.

O usuário não pode esperar 

Importar algumas centenas de eventos no escopo de uma requisição HTTP era algo simples. Processar um arquivo pequeno com essa quantidade de eventos não é uma tarefa tão custosa assim. O usuário ficaria esperando alguns poucos segundos e a tarefa dele estaria concluída. 

Acontece que esse padrão de uso não durou muito tempo e logo os usuários precisaram fazer importações na casa dos milhares de eventos. Essas importações demoravam mais, deixando o usuário esperando por vários segundos; isso quando o processo todo conseguia ser executado dentro do tempo limite de uma requisição HTTP. 

Isso não estava bom o suficiente. Nós precisávamos permitir que nosso sistema fosse robusto o bastante para permitir importações maiores e gostaríamos também que o usuário não fosse obrigado a ficar esperando sua importação terminar para realizar outras atividades dentro do sistema.

Nós precisávamos que as importações feitas no Geointeligência acontecessem em segundo plano, isto é, uma vez que o usuário iniciasse uma importação, esta deveria acontecer fora do escopo de sua requisição, e o usuário deveria ter alguma forma de verificar se sua tarefa já havia sido concluída.

Para isso, nós utilizamos a ferramenta mais indicada para a nossa necessidade e que estava à nossa disposição: o Akka.

Por que Akka e Akka Cluster?

O Akka é um conjunto de ferramentas que simplifica a construção de aplicativos concorrentes e distribuídos na JVM. Como nossos sistemas são implementados utilizando a linguagem de programação Scala, que roda na JVM, o Akka costuma ser uma ótima ferramenta para nos auxiliar a tornar nossos sistemas mais poderosos. Além disso, o Akka nos traz a possibilidade de trabalhar com o modelo de atores, que facilita o nosso trabalho como desenvolvedores no processo de criação de sistemas concorrentes e distribuídos. 

Outro ponto importante é que nossa infraestrutura prevê a possibilidade da criação de múltiplas instâncias da mesma aplicação com o objetivo de suportar uma maior quantidade de usuários durante um momento de estresse do sistema. Desse modo, o Akka, juntamente com o Akka Cluster, nos permitem desenvolver funcionalidades utilizando modelo de atores com o objetivo de tornar transparente para o desenvolvedor questões de gerenciamento e comunicação entre mais de uma instância de um mesmo sistema.

Conversa entre atores

No fim, para conseguirmos que a importação fosse toda processada fora do escopo da requisição do usuário, nós tivemos que fazer grandes mudanças na forma como ela era implementada, substituindo a estratégia anterior por uma baseada no modelo de atores. Resumidamente, essa estratégia utiliza um conjunto de atores, pequenas unidades de processamento capazes de se comunicar entre si através de mensagens, que são responsáveis por executar cada passo da importação.

Para implementar essa arquitetura de atores nós utilizamos a API de atores do Akka, uma vez que ela já abstrai uma porção de detalhes de gerenciamento de threads e bloqueios, tornando o trabalho do desenvolvedor mais focado na construção do sistema em si e nas interações entre os atores.


Resumidamente, quando um usuário envia uma requisição de importação para o sistema, o arquivo enviado é imediatamente salvo em nossa base de dados e uma mensagem com informações desse arquivo é enviada para um ator de arquivo (File Actor). As principais responsabilidades desse ator de arquivo são controlar o andamento da importação e carregar o arquivo de importação armazenado na base em partes na memória. Toda essa etapa inicial é executada ainda dentro do escopo da requisição HTTP do usuário, mas a partir desse ponto a execução ocorre em segundo plano.

O ator de arquivo, então, envia uma parte do arquivo para um segundo ator: o ator de blocos de eventos (Buffer Actor). Ele funciona como um buffer, responsável por processar um bloco de eventos, realizando as devidas validações e inserindo os eventos válidos na base. Uma vez que o ator de blocos de eventos tenha inserido todo um bloco de eventos, ele notifica novamente o ator de arquivo com informações desses eventos. O ator de arquivo então envia para um terceiro ator (Status Actor) as informações atualizadas da importação. Esse ator é responsável por manter o estado da importação com informações como quantidade de eventos inseridos e quantidade de erros encontrados.

O ator de arquivos, então, reinicia seu ciclo de execução, retirando partes do arquivo, uma a uma, e enviando-as para o ator de blocos. Por fim, quando o último bloco do arquivo é retirado da base e seus eventos são processados, o ator de arquivo remove esse arquivo da base, completando assim o processo de importação.

Acompanhando o progresso

A evolução da importação para ser processada fora do escopo de uma requisição HTTP não bloqueando o usuário no sistema gerou a necessidade de uma funcionalidade de feedback para o usuário sobre o processamento da importação do seu arquivo de eventos. A nossa arquitetura de atores possui um ator de notificação (Notification Actor) cuja função é justamente disponibilizar informações sobre as importações que estão ocorrendo naquele momento. 

Por isso, surgiu a ideia de criar um canal de comunicação direto entre o front-end e esse ator de notificação através de um Websocket. Sempre que o ator de estado da importação é atualizado com novas informações de importações atuais, ele utiliza esse Websocket para enviar mensagens com o progresso dessas importações para o front-end que, por sua vez, fica responsável por apresentar ao usuário essas informações como indicado na imagem abaixo:

O Geointeligência apresenta cada importação com uma barra de progresso sendo atualizada em tempo real. Ao clicar sobre a importação, o usuário verá mais informações sobre a quantidade de eventos que estão sendo inseridos, repetidos ou se houve erros:

Com essa funcionalidade o usuário tem a todo instante o entendimento do momento atual de sua importação e pode continuar usando o sistema sem precisar esperar que todo o processo seja finalizado.

Capacidade de importação

O Geointeligência passou a importar de forma eficaz uma quantidade significativamente maior de eventos por arquivo. Essa evolução deveu-se à saída do escopo de uma requisição HTTP, leitura otimizada do arquivo durante processamento, adição do modelo de atores do Akka para processamento de eventos e introdução do Akka Cluster para suportar diversas instâncias

Hoje, nosso sistema consegue importar arquivos com 300 mil eventos em pouco mais de dois minutos, sem que o usuário precise esperar o processamento de todos esses eventos para continuar a utilizar o sistema. O usuário pode fazer uma análise de eventos enquanto outros são importados. Isso melhorou a usabilidade do nosso sistema, permitindo ao usuário utilizar seu tempo para fazer as análises em vez de preparar os dados.

Conclusão

Com tudo isso, nossa equipe encontrou uma ótima forma de lidar com uma importação maciça de eventos sem precisar que o usuário esperasse a finalização de todo o processamento. 

A utilização do Akka e de atores trouxe  mais responsividade para a funcionalidade e, com isso, a utilização de mensagens assíncronas para informar progresso ao usuário permitiu que nosso sistema se comportasse de maneira mais reativa.

Nossos usuários ganharam tempo de processamento com o uso de modelo de atores para processar partes dos eventos por vez, e além disso, agora eles podem acompanhar todo o processo em tempo real com o progresso visual. A saída do escopo da requisição HTTP trouxe muitas vantagens para a importação no Geointeligência e a utilização do Akka fez com que o desenvolvimento disso fosse bem menos complexo do que poderia ser. 

Melhorar a experiência do usuário é sempre um objetivo que devemos procurar dentro de nossos sistemas.

 

Categorias
Ciência de Dados Machine Learning Programação

10 habilidades indispensáveis para os cientistas de dados em 2021

Muito se fala sobre a grande procura das empresas por cientistas de dados e os excelentes salários reservados a esses profissionais. Mas quem pode receber esse título, quais habilidades tornam os cientistas de dados tão requisitados e ainda raros no mercado de trabalho?

Para conhecer quais competências você deve desenvolver para se tornar um cientista de dados, e entender que este não é um processo de apenas 6 meses, trazemos aqui a lista produzida por Daniel D. Gutierrez sobre as 10 habilidades essenciais de ciência de dados em 2021.

Gutierrez é cientista de dados, autor de quatro livros de data science, jornalista de tecnologia e professor, tendo ministrado aulas de ciência de dados, aprendizado de máquina (machine learning) e R em nível universitário.

 


1. Experiência com GPUs

Agora é a hora de entender a grande popularidade das GPUs. A maneira mais fácil de começar a usar GPUs para aprendizado de máquina  é começar com um serviço de GPU em nuvem. Aqui está uma pequena lista de opções que podem ser adequadas às suas necessidades:

 

  • Colab – Google Colaboratory, ou “Colab” para abreviar, é um produto do Google Research. O Colab permite que qualquer pessoa escreva e execute código Python arbitrário por meio do navegador, e é especialmente adequado para aprendizado de máquina. Especificamente, o Colab é um serviço de nuvem gratuito hospedado pelo Google que usa o Jupyter Notebook, ou seja, que não requer instalação para uso, ao mesmo tempo que fornece acesso a recursos de computação, incluindo GPUs.
  • Kaggle – Kaggle (propriedade do Google) fornece acesso gratuito às GPUs NVIDIA TESLA P100. Essas GPUs são úteis para treinar modelos de aprendizado profundo (deep learning), no entanto, não aceleram a maioria dos outros fluxos de trabalho, como bibliotecas Python, Pandas e Scikit-learn. Você pode usar um limite de cota por semana de GPU. A cota é restabelecida semanalmente e é de 30 horas ou às vezes mais, dependendo da demanda e dos recursos.
  • NVIDIA NGC – O catálogo NGC ™ é um hub para software otimizado por GPU para deep learning, machine learning e computação de alto desempenho que acelera a implantação para fluxos de trabalho de desenvolvimento para que cientistas, desenvolvedores e pesquisadores possam se concentrar na construção de soluções, coleta de insights e entrega de valor comercial.
  • Cloud GPUs no Google Cloud Platform – GPUs de alto desempenho no Google Cloud para aprendizado de máquina, computação científica e visualização 3D.
  • Lambda GPU Cloud para Deep Learning – Lambda oferece Lambda GPU Cloud, um serviço de nuvem GPU para Deep Learning. 

 


2. Visualização de dados criativa e storytelling de dados

A visualização de dados, juntamente com o storytelling de dados, continua sendo uma habilidade importante a ser cultivada por todos os cientistas de dados. Essa etapa integra o processo de ciência de dados e é uma habilidade que diferencia os cientistas de dados de seus colegas engenheiros de dados. Os cientistas de dados assumem a importante função de interagir com os responsáveis pelo projeto ao entregar os resultados de um trabalho de data science.

Além dos tradicionais relatórios e resultados numéricos, uma visualização de dados atraente e bem pensada é a melhor maneira de mostrar os resultados provenientes de um algoritmo de aprendizado de máquina. Além disso, é também um ingrediente básico do estágio final do storytelling de dados do projeto, onde o cientista de dados se esforça para chegar a uma descrição concisa e não técnica dos resultados, onde as principais descobertas são facilmente compreendidas.

Para quem sente dificuldade nesta parte, como no trabalho com elementos mais criativos e visuais, sempre procure por novas técnicas de visualização de dados usando pacotes R recém-descobertos e bibliotecas Python para tornar o resultado mais atraente.

 

 


3. Python

Para Gutierrez, é difícil ignorar o Python, pois a maioria dos bons artigos de blog e materiais de aprendizagem usam esta linguagem. Por exemplo, a maioria dos documentos de aprendizagem profunda que aparecem no arXiv referem-se a repositórios GitHub com código Python usando estruturas como Keras, TensorFlow e Pytorch, e quase tudo que acontece no Kaggle envolve Python.

Ainda de acordo com o autor, o R costumava ter a vantagem com os 16.891 pacotes disponíveis para complementar a linguagem base, mas o Python afirma ter uma ordem de magnitude maior do que essa. Um conhecimento robusto de Python é uma habilidade de ciência de dados importante para se aprender.

 

 


4. SQL

SQL é uma ótima linguagem de consulta de dados, mas não é uma linguagem de programação de propósito geral. É fundamental que todo cientista de dados seja proficiente em SQL. Muitas vezes, seus conjuntos de dados para um projeto de ciência de dados vêm diretamente de um banco de dados relacional corporativo. Portanto, o SQL é seu canal para adquirir dados. Além disso, você pode usar SQL diretamente em R e Python como uma ótima maneira de consultar dados em um quadro de dados.

 

 


5. GBM além de Deep Learning

A IA e o aprendizado profundo continuam no topo do “hype cycle” do setor, e certamente 2021 não será diferente. O aprendizado profundo é a ferramenta perfeita para muitos domínios de problemas, como classificação de imagens, veículos autônomos, PNL e muitos outros. Mas quando se trata de dados tabulares, ou seja, dados típicos de negócios, deep learning pode não ser a escolha ideal. Em vez disso, o GBM (Gradient Boosted Machines) é o algoritmo de aprendizado de máquina que geralmente atinge a melhor precisão em dados estruturados / tabulares, superando outros algoritmos, como as tão faladas redes neurais profundas (deep learning). Alguns dos principais GBMs incluem XGBoost, LightGBM, H2O e catboost.

 

 


6. Transformação de dados

Muitas vezes, é mencionado em voz baixa quando os cientistas de dados se encontram: o processo de data munging (também conhecido como data wrangling, transformação de dados) leva a maior parte do tempo e do orçamento de custos de um determinado projeto de ciência de dados.

Transformar dados não é o trabalho mais atraente, mas acertar pode significar sucesso ou fracasso com o aprendizado de máquina. Para uma tarefa tão importante, um cientista de dados deve certificar-se de agregar à sua caixa de ferramentas de ciência de dados código que atenda a muitas necessidades comuns. Se você usa R, isso significa usar dplyr e, se você usa Python, então Pandas é sua ferramenta de escolha.

 

 


7. Matemática e estatística

Manter um conhecimento sólido dos fundamentos dos algoritmos de aprendizado de máquina requer uma base em matemática e estatística. Essas áreas são normalmente deixadas por último no esforço de aprendizado de muitos cientistas de dados, isso porque matemática / estatística podem não estar em sua lista pessoal de atualização. Mas um entendimento elementar dos fundamentos matemáticos do aprendizado de máquina é imprescindível para evitar apenas adivinhar os valores dos hiperparâmetros ao ajustar algoritmos.

As seguintes áreas da matemática são importantes: cálculo diferencial, equações diferenciais parciais, cálculo integral (curvas AUC-ROC), álgebra linear, estatística e teoria da probabilidade. Todas essas áreas são importantes para entender como funcionam os algoritmos de aprendizado de máquina.

Um objetivo de todos os cientistas de dados é ser capaz de consumir “a bíblia do aprendizado de máquina”, “Elements of Statistical Learning”, de Hastie, Tibshirani e Friedman. Esse é um daqueles livros que você nunca termina de ler.

Para atualizar sua matemática, verifique o conteúdo do OpenCourseWare do professor Gilbert Strang do MIT.

 

 


8. Realização de experimentos com os dados

Busque novos conjuntos de dados e experimente, experimente e experimente! Os cientistas de dados nunca conseguem praticar o suficiente trabalhando com fontes de dados desconhecidas. Felizmente, o mundo está cheio de dados. É apenas uma questão de combinar suas paixões (ambientais, econômicas, esportivas, estatísticas de crime, o que for) com os dados disponíveis para que você possa realizar as etapas do “processo de ciência de dados” para aprimorar suas habilidades. A experiência que você ganha com seus próprios experimentos com dados o ajudará profissionalmente no futuro.

 

 


9. Conhecimento especializado

Um consultor independente de ciência de dados pode trabalhar em todos os tipos de projetos interessantes em um amplo espectro de domínios de problemas: manufatura, sem fins lucrativos, educação, esportes, moda, imóveis, para apenas mencionar alguns.

Então, quando se tem um novo cliente de um novo setor, é fundamental aumentar rapidamente seu conhecimento na área desde o início. Falar com pessoas da organização do cliente que são especialistas no assunto, analisar as fontes de dados disponíveis, ler tudo que possa encontrar sobre o assunto, incluindo white papers, postagens em blogs, periódicos, livros, artigos de pesquisa; tudo isso em uma tentativa de começar a todo vapor.

 

 


10. Aprendizado de máquina ético

O professor Gutierrez apresenta aos seus alunos uma lista de casos em que cientistas de dados foram solicitados a usar suas habilidades para fins nefastos.

“Falo a eles sobre os cientistas de dados que desenvolvem tecnologia para criar imagens e vídeos ‘deep fake’ indetectáveis. Conto a eles a vez em que testemunhei um gerente de ciência de dados de uma grande empresa pública de jogos que disse a uma multidão em um encontro que ele e sua equipe trabalharam com psicólogos para descobrir maneiras de viciar crianças em seus jogos. E eu falo sobre Rebekah Jones, a cientista de dados do estado da Flórida que se recusou a adulterar os dados do COVID-19 para fazer a situação da saúde pública do estado parecer melhor.”

Se você deseja se tornar um profissional de ciência de dados ético, pense no futuro. Saiba desde já que em sua carreira, provavelmente, surgirão situações nas quais você precisará se posicionar contra o uso de suas habilidades para prejudicar outras pessoas. Olhando para 2021, o clima político pode estar propício para tais dilemas. 

 

Fonte: Data Science Skills for 2021: 10 Skills You Need to Get Ahead

Categorias
Dica de Leitura Limpeza de Código Programação

Insight Indica o livro Código Limpo: Habilidades Práticas do Agile Software

O Insight indica hoje uma leitura para quem está procurando conhecer sobre limpeza de códigos. Código Limpo: Habilidades Práticas do Agile Software é uma obra bem avaliada, indicada por especialistas e o melhor, com versão em português. Como destacado nas críticas dos usuários, a obra possui leitura agradável e provoca a mudança do seu entendimento em relação aos códigos. Se você é iniciante, sinta-se encorajado a este mergulho.

Um código ruim pode funcionar? Sim, mas se ele não for limpo, pode acabar comprometendo todo um projeto. Um código mal escrito demanda um tempo considerável dos desenvolvedores para resolver problemas de programação, ao invés de se dedicarem a inovações. Porém, isso pode ser resolvido se você tiver interesse em aprender sobre códigos limpos com quem domina o assunto.

 

O Livro

O célebre especialista em software, Robert C. Martin, apresenta um paradigma revolucionário com o livro Código Limpo: Habilidades Práticas do Agile Software. Martin se reuniu com seus colegas do Mentor Object (equipe de consultores experientes) para divulgar suas melhores e mais ágeis práticas de limpar códigos “dinamicamente” em um obra que apresentará gradualmente os valores necessários a um profissional de software, assim como, pode transformá-lo em um programador melhor. Mas lembre-se, é preciso muita prática.

 

O que você vai encontrar

Nesta obra você lerá muitos códigos. Isso lhe ajudará a entender o que está correto e errado neles. Além disso, te dará um incentivo para reavaliar seus valores profissionais e seu comprometimento com o seu trabalho.

 

Divisão do conteúdo

Código Limpo está dividido em três partes com 17 capítulos ao todo. Na 1ª parte há diversos capítulos que descrevem os princípios, padrões e práticas para criar um código limpo. 

A 2ª parte consiste em diversos casos de estudo de complexidade cada vez maior. Cada um é um exercício para limpar um código – transformar o código base que possui alguns problemas em um melhor e mais eficiente. 

A 3ª parte é a compensação: um único capítulo com uma lista de heurísticas 

reunidas durante a criação dos estudos de caso. O resultado será um conhecimento base que descreve a forma como pensamos quando criamos, lemos e limpamos um código. 

 

O que você aprenderá com este livro

Após ler este livro os leitores saberão:

✔ Como distinguir um código bom de um ruim

✔ Como escrever códigos bons e como transformar um ruim em um bom

✔ Como criar bons nomes, boas funções, bons objetos e boas classes

✔ Como formatar o código para ter uma legibilidade máxima

✔ Como implementar completamente o tratamento de erro sem obscurecer a lógica

✔ Como aplicar testes de unidade e praticar o desenvolvimento dirigido a testes

Esta leitura é essencial para qualquer desenvolvedor, engenheiro de software, gerente de projeto, líder de equipes ou analistas de sistemas com interesse em construir códigos melhores.

 

Sobre o autor

Robert C. “Tio Bob” Martin é profissional de softwares desde 1970 e consultor internacional de software desde 1990. Ele é o fundador e o presidente da Mentor Object, Inc., uma equipe de consultores experientes que orientam seus clientes no mundo todo em C++, Java, C#, Ruby, OO, Padrões de Projeto, UML, Metodologias Agile e Xtreme Programming.

 

Concluindo

Este livro não promete lhe transformar no melhor programador ou lhe dar a “sensibilidade ao código”. Tudo o que ele pode fazer é lhe mostrar a linha de pensamento de bons programadores e os truques, técnicas e ferramentas que eles usam.

Assim como um livro sobre arte está cheio de obras, Código Limpo está repleto de códigos. Você irá se deparar com códigos bons e ruins; código ruim sendo transformado em bom; listas de heurísticas, orientações e técnicas e também exemplo após exemplo. Depois disso, é por sua conta praticar.

? A boa leitura é garantida, então tenha um excelente aprendizado e pratique sempre!

 

Fonte: Livro Código Limpo

Categorias
Ciência de Dados Programação trabalho Vagas Vagas Encerradas

Trabalhe como Desenvolvedor Full Stack no Insight Lab

Olá! Iniciamos hoje o processo de seleção para a vaga de Desenvolvedor Full Stack Pleno, que será responsável por atuar no desenvolvimento de aplicações web e desenvolver soluções inovadoras.

 

Competências obrigatórias: Python,  Docker, Shell Script, Jupyter Notebook, PostgreSQL, Conda, Git,  Javascript, HTML, CSS, Linux e Inglês.

Competências desejáveis: Kubernetes, Data Lake, Big Data, Django, Scala, Java, Spring Boot, MongoDB, Redis, Play Framework e Lagom Framework.

 

Carga Horária 

40 horas semanais.

 

Modalidade de contratação

CLT 

 

Local de exercício das atividades

O candidato atuará em nossa sede em Fortaleza-CE. No entanto, pela necessidade de distanciamento social imposta pela pandemia de Covid-19, durante o período inicial o candidato desenvolverá suas atividades remotamente.

 

Etapas da seleção

– Envio das respostas do desafio e preenchimento do formulário de inscrição: 14/08 a 28/08

– Entrevistas: 01/09 a 04/09

– Divulgação do Resultado: 07/09

 

Desafio e Formulário

Deseja preencher esta vaga? Então, solucione o desafio e depois acesse o formulário para registrar seus dados e enviar seu currículo. 

 

Clique aqui para acessar o documento com mais especificações e esclarecimentos sobre a vaga de Desenvolvedor Full Stack.

Boa sorte e continue acompanhando o Insight Lab para receber todas as nossas novas publicações.

 

Categorias
Pandas Programação Python

6 truques do Pandas para impulsionar sua análise de dados

O Pandas é uma das melhores bibliotecas Python para análise de dados. Esta biblioteca open source oferece estrutura de dados de alto nível com um excelente desempenho para simplificar tarefas complicadas de manipulação de dados. Sua grande variedade de ferramentas possibilita traduzir operações complexas com dados em um ou dois comandos, além de possuir métodos internos para agrupar, filtrar e combinar dados.

 

Conheça agora, os seis truques mais úteis dos Pandas para acelerar sua análise de dados.

 

  1. Selecionar colunas por tipo de dados;
  2. Converter cadeias de caracteres em números;
  3. Detectar e manipular valores ausentes;
  4. Converter um recurso numérico contínuo em um recurso categórico;
  5. Criar um DataFrame a partir da área de transferência;
  6. Construir um DataFrame a partir de vários arquivos.

Confira aqui o repositório no Github para obter o código-fonte.

 

1. Selecione colunas por tipos de dados

Aqui estão os tipos de dados do DataFrame Titanic:

df.dtypes

 

PassengerId int64

Survived int64

Pclass int64

Name object

Sex object

Age float64

SibSp int64

Parch int64

Ticket object

Fare float64

Cabin object

Embarked object

dtype: object

 

Digamos que você precise selecionar as colunas numéricas.

df.select_dtypes(include='number').head()

 

Isso inclui as colunas int e float. Você também pode usar esse método para:

 

  • selecionar apenas colunas de objeto;
  • selecionar vários tipos de dados;
  • excluir certos tipos de dados.

 

# select just object columns

df.select_dtypes(include='object')

 

# select multiple data types

df.select_dtypes(include=['int', 'datetime', 'object'])

 

# exclude certain data types

df.select_dtypes(exclude='int')

 

2. Converta sequências de caracteres em números

 

Existem dois métodos para converter uma string em números no Pandas:

  • O método astype()
  • O método to_numeric()

Vamos criar um exemplo de DataFrame para ver a diferença.

df = pd.DataFrame({ 'product': ['A','B','C','D'],

                 'price': ['10','20','30','40'], 

                'sales': ['20','-','60','-'] 

                })

 

 

As colunas de price e sales são armazenadas como uma cadeia de caracteres e, portanto, resultam em colunas de objeto:

df.dtypes

 

product    object

price      object

sales      object

dtype: object

 

Podemos usar o primeiro método astype()para realizar a conversão na coluna de price da seguinte maneira:

 

# Use Python type

df['price'] = df['price'].astype(int)

 

# alternatively, pass { col: dtype }

df = df.astype({'price': 'int'})

 

No entanto, isso resultaria em um erro se tentássemos usá-lo na coluna de sales. Para consertar isso, podemos usar to_numeric() com o argumento errors='coerce'.

 

df['sales'] = pd.to_numeric(df['sales'], errors='coerce')

 

Agora, valores inválidos – são convertidos para  NaN e o tipo de dado é float.

 

3. Detectar e manipular valores ausentes

Uma maneira de detectar valores ausentes é usar o método info(). Veja na coluna Non-Null Count.

df.info()

 

RangeIndex: 891 entries, 0 to 890

Data columns (total 12 columns):

#   Column       Non-Null Count  Dtype 

---  ------       --------------  ----- 

0   PassengerId  891 non-null    int64 

1   Survived     891 non-null    int64 

2   Pclass       891 non-null    int64 

3   Name         891 non-null    object

4   Sex          891 non-null    object

5   Age          714 non-null    float64

6   SibSp        891 non-null    int64 

7   Parch        891 non-null    int64 

8   Ticket       891 non-null    object

9   Fare         891 non-null    float64

10  Cabin        204 non-null    object

11  Embarked     889 non-null    object

dtypes: float64(2), int64(5), object(5)

memory usage: 83.7+ KB

 

Quando o conjunto de dados é grande, podemos contar o número de valores ausentes. df.isnull().sum() retorna o número de valores ausentes para cada coluna.

 

df.isnull().sum()

 

PassengerId      0

Survived         0

Pclass           0

Name             0

Sex              0

Age            177

SibSp            0

Parch            0

Ticket           0

Fare             0

Cabin          687

Embarked         2

dtype: int64

 

df.isnull().sum().sum() retorna o número total de valores ausentes.

 

df.isnull().sum().sum()

 

886

 

Além disso, também podemos descobrir a porcentagem de valores que estão faltando, executando: df.isna().mean()

 

PassengerId    0.000000

Survived       0.000000

Pclass         0.000000

Name           0.000000

Sex            0.000000

Age            0.198653

SibSp          0.000000

Parch          0.000000

Ticket         0.000000

Fare           0.000000

Cabin          0.771044

Embarked       0.002245

dtype: float64

 

Eliminando valores ausentes

 

Para descartar linhas se houver algum valor NaN:

df.dropna(axis = 0)

Para descartar colunas se houver algum valor NaN:

df.dropna(axis = 1)

Para descartar colunas nas quais mais de 10% dos valores estão ausentes:

df.dropna(thresh=len(df)*0.9, axis=1)

 

Substituindo valores ausentes

 

Para substituir todos os valores de NaN por um escalar:

df.fillna(value=10)

Para substituir os valores de NaN pelos valores da linha anterior:

df.fillna(axis=0, method='ffill')

Para substituir os valores de NaN pelos valores da coluna anterior:

df.fillna(axis=1, method='ffill')

Você também pode substituir os valores de NaN pelos valores da próxima linha ou coluna:

# Replace with the values in the next row

df.fillna(axis=0, method='bfill')

# Replace with the values in the next column

df.fillna(axis=1, method='bfill')

 

A outra substituição comum é trocar os valores de NaN pela média. Por exemplo, para substituir os valores de NaN na coluna Idade pela média.

 

df['Age'].fillna(value=df['Age'].mean(), inplace=True)

 

4. Converta um recurso numérico contínuo em um recurso categórico

 

Na etapa de preparação dos dados, é bastante comum combinar ou transformar recursos existentes para criar outro mais útil. Uma das maneiras mais populares é criar um recurso categórico a partir de um recurso numérico contínuo.

 

Observe a coluna Age do dataset do Titanic:

 

df['Age'].head(8)

 

0    22.0

1    38.0

2    26.0

3    35.0

4    35.0

5     NaN

6    54.0

7     2.0

Name: Age, dtype: float64

 

Age é um atributo numérico contínuo, mas se você desejar convertê-la em um atributo categórico, por exemplo, converta as idades em grupos de faixas etárias: ≤12, Teen (≤18), Adult (≤60) e Older (>60).

 

A melhor maneira de fazer isso é usando a função Pandas cut():

 

import sys

 

df['ageGroup']=pd.cut(

   df['Age'],

   bins=[0, 13, 19, 61, sys.maxsize],

   labels=['<12', 'Teen', 'Adult', 'Older']

)

 

Usar a função head(),na coluna age Group, deverá exibir as informações da coluna.

df['ageGroup'].head(8)

 

0    Adult

1    Adult

2    Adult

3    Adult

4    Adult

5      NaN

6    Adult

7      <12

Name: ageGroup, dtype: category

Categories (4, object): [<12 < Teen < Adult < Older]

 

5. Crie um DataFrame a partir da área de transferência

 

A função Pandas read_clipboard() é uma maneira muito útil de inserir dados em um DataFrame de forma rápida..

Suponha que tenhamos os seguintes dados e desejemos criar um DataFrame a partir dele:

 

    product   price

0    A         10

1    B         20

2    C         30

4    D         40

 

Só precisamos selecionar os dados e copiá-los para a área de transferência. Então, podemos usar a função para ler um DataFrame.

 

df = pd.read_clipboard ()

df

 

6. Crie um DataFrame a partir de vários arquivos

Seu dataset pode se espalhar por vários arquivos, mas você pode querer lê-lo em um único DataFrame.

Uma maneira de fazer isso é ler cada arquivo em seu próprio DataFrame, combiná-los e excluir o DataFrame original. Porém, isso seria ineficiente em memória.

Uma solução melhor é usar o módulo interno glob  (graças aos truques do Data School Pandas).

 

Neste caso, glob() estará procurando no diretório de dados, todos os arquivos CSV que começam com a palavra ” data_row_ “. O glob()recupera nomes de arquivos em uma ordem arbitrária, e é por isso que classificamos a lista usando a função sort().

 

Para dados em linha

Digamos que nosso dataset esteja distribuído por 2 arquivos em linhas: data_row_1.csv e data_row_2.csv.

 

Para criar um DataFrame a partir dos 2 arquivos:

 

files = sorted(glob('data/data_row_*.csv'))

pd.concat((pd.read_csv(file) for file in files), ignore_index=True)

 

sorted(glob('data/data_row_*.csv')) recupera nomes de arquivos. Depois disso, lemos cada um dos arquivos usando read_csv()e passamos os resultados para a função concat(), que conectará as linhas em um único DataFrame. Além disso, para evitar um valor duplicado no índice, dizemos ao concat()que ignore o index (ignore_index=True) e, em vez disso, use o índice inteiro padrão.

 

 

Para dados em colunas

Digamos que nosso dataset esteja distribuído em 2 arquivos em colunas: data_col_1.csv e data_col_2.csv.

 

Para criar um DataFrame a partir dos 2 arquivos:

files = sorted(glob('data/data_col_*.csv'))

pd.concat((pd.read_csv(file) for file in files), axis=1)

Desta vez, dizemos à função concat() para conectar ao longo do eixo das colunas.

————-

Isso é tudo!

Obrigada pela leitura e continue acompanhando nossos postagens em Data Science.

 

Texto original: B. Chen

 

 

Categorias
Cursos Programação

Aprenda a construir aplicações escaláveis com o nosso novo curso

Hoje, apresentamos o nosso curso de “Aplicações escaláveis na prática”, disponível em nosso canal no YouTube. O curso é ministrado por Felipe Marcel, desenvolvedor full-stack do Insight Lab com experiência em desenvolvimento de aplicações usando as tecnologias Docker, Kubernetes, Scala, Play, Akka, Akka Stream, arquitetura de micro-serviços com Lagom Framework e MongoDB.

Na primeira parte deste curso você aprenderá a preparar a infraestrutura para construção de aplicações escaláveis. Os tópicos “Overview da aplicação SisBus” e “Docker” já estão no ar e, a partir do dia 06 de agosto, você também poderá acessar os itens “Docker-compose” e “Kubernetes”.

Como continuação desta formação, estamos produzindo o “Módulo de Desenvolvimento”, que também estará disponível em nosso canal no YouTube.

O curso segue a seguinte estrutura:

Módulo de Infraestrutura

1. Overview da aplicação SisBus (Disponível)

– Apresentação 

– Introdução 

– Objetivos  

– Solução – Amostra 

– Solução – Infra Persistência 

– Solução – Infra Backend 

– Solução – Infra Frontend 

– Solução – Infra Web Server 

– Solução – Arquitetura 

– Solução – Estrutura e tecnologias 

– GTFS/Fluxo de Carga 

– Próximos Passos

 

2. Docker (Disponível) 

– Apresentação

– Introdução 

– Persistência – Mongo Dockerfile 

– Persistência – Mongo Run 

– Persistência – Data-seed Dockerfile 

– Persistência – Data-seed Run 

– Backend – nodejs-api 

– Frontend – webapp 

– Web server – proxy 

– Backend II – Serviço lagom-api 

 

3. Docker Compose (Disponível em 06/08) 

– Introdução 

– Persistência – Mongo 

– Persistência – Data-seed 

– Backend – nodejs-api 

– Frontend – webapp 

– Web server – proxy I 

– Web server – proxy II 

– Backend II – Serviço lagom-api 

 

4. Kubernetes (Disponível em 06/08) 

– Introdução: Conceitos 

– Introdução: Minikube 

– Persistência: Conceitos e comandos 

– Persistência: Mongo

– Backend I

– Frontend 

– Proxy 

– Backend II 

 

Módulo de Desenvolvimento (em produção)

 

Para acompanhar o curso recomendamos que você tenha conhecimentos básicos em Docker e Kubernetes. Caso ainda não esteja familiarizado com essas ferramentas, indicamos:

Curso de Introdução ao Kubernetes (disponível em nosso canal do YouTube)

Curso de Introdução ao Docker (disponível em nosso canal do YouTube).

 

Bons estudos!

Categorias
Git Programação

Os 6 comandos do Git que todo Cientista de Dados deve saber

Uma introdução ao uso do Git para projetos de aprendizado de máquina

O Git é uma plataforma destinada a desenvolvedores para o gerenciamento de projetos e versões de códigos, permitindo desenvolver projetos colaborativos com pessoas do mundo todo. É a rede social dos desenvolvedores.  

Como controle de versão, ele tem a capacidade de gerenciar diferentes versões de um mesmo projeto. É possível assim, obter históricos das modificações, permitir que vários programadores trabalhem no mesmo projeto, e permitir um comparativo entre várias versões do projeto.

Essas funcionalidades são essenciais durante o treinamento de um novo modelo de machine learning, em que vários programadores trabalham no mesmo código. 

Iniciando o processo

Consideraremos aqui que você já tenha o Git instalado, caso não, aqui está um recurso para fazê-lo. Depois disso, não se esqueça de configurar uma chave SSH. 

Você deve ver o seguinte ao digitar git na linha de comando no Mac / Linux ou GitBash se estiver no Windows.

 

1.Init

Vamos começar com o comando mais básico, o init. Ele inicializa um projeto Git, uma maneira simples para dizer: “adicione os arquivos necessários ao Git na raiz da pasta em que você está”. Simplesmente acione o comando cd para o diretório do seu projeto e digite o seguinte:

 

$ git init

 

Em troca, você receberá uma mensagem dizendo que seu projeto está pronto para a execução.

Você só precisa fazer isso uma vez por projeto.

2. Remote Add

Agora, graças ao comando init, você tem um repositório local para o seu projeto. Você poderá fazer tudo o que precisa para controlar, de maneira satisfatória, seu projeto localmente. Crie um projeto online para aproveitar ao máximo o Git. A maioria dos desenvolvedores têm uma conta GitHub, embora existam boas alternativas como BitBucket e gitlab. De um modo geral esses serviços são semelhantes para quem está iniciando.

Depois de escolher o serviço que você deseja usar, vá em frente e crie um novo projeto.

 

Depois de criar seu projeto, você receberá um URL personalizado. Neste caso, o gerado para este projeto é:https://github.com/jessefreeman/GitExample.git

Tudo o que precisamos fazer agora é conectar nosso projeto local ao projeto online que criamos. Para fazer isso, você usará o seguinte comando:

 

$ git remote add origin <PROJECT_URL>

 

Você também pode se conectar pelo caminho SSH, dependendo do que o serviço Git fornece.

3. Add

Neste ponto, seu projeto está pronto para rastrear versões localmente. Vá em frente e adicione um arquivo ReadMe.txt ou algo à pasta. Lembre-se de que o Git ignora pastas vazias. Quando estiver pronto, adicione as alterações ao repositório. A preparação é uma maneira simples de dizer que o Git vai rastrear arquivos específicos até que você esteja pronto para salvar uma versão deles.

 

Para adicionar arquivos, basta digitar o seguinte comando: 

 

$ git add .

 

Embora você possa especificar arquivos pelo nome após add, . é um curinga que incluirá automaticamente todos os arquivos que foram alterados desde a última confirmação.

4. Status

A qualquer momento, você pode obter uma lista dos arquivos no projeto Git e ver se eles estão prontos ou não. Para fazer isso, digite o seguinte comando:

 

$ git status

 

Isso dará uma lista de todos os arquivos que o Git vê no diretório.

Você pode ver os arquivos não adicionados no momento em vermelho. Os arquivos prontos para serem salvos aparecerão em verde. A lista de status do arquivo é útil quando você desejar ver se está tudo concluído antes de salvar as alterações.

5. Commit

Depois de organizar os arquivos, você precisará salvar uma versão deles. Chamamos isso de commit. O Git pega os arquivos que você adicionou anteriormente e os compara com a última versão. Em seguida, ele salva os deltas, ou as diferenças, em uma pasta .git oculta especial na raiz do seu projeto.

Para salvar as alterações, digite o seguinte na linha de comando: 

 

$ git commit -m "Add a message so you know what you did"

 

Este é provavelmente o mais complexo dos comandos que usamos até agora. Se olharmos para cada parte, estamos ligando commit e -m representando a adição de uma mensagem. Por fim, você fornecerá a mensagem de confirmação entre aspas. Dessa forma, depois você poderá olhar no log de confirmação para lembrar as alterações que você fez.

Se você estiver usando o GitHub, existem alguns recursos interessantes que você pode usar ao confirmar seu código. Aqui citaremos, como exemplo, a aba de Issues do repositório, esse local vai permitir a você acompanhar as tarefas, aprimoramentos e bugs de seu projeto. Cada tópico representa um número de identificação exclusivo e você pode vinculá-lo referenciando-o em seu comentário como este:

 

$ git commit -m "Finished making changes to #1"

 

O GitHub irá adicionar automaticamente um link do seu commit ao problema. É uma ótima maneira de se manter organizado enquanto você trabalha.

6. Push

A última etapa deste processo é enviar todos os seus commits para o repositório remoto no GitHub. O Git é único, pois permite trabalhar localmente até que você esteja pronto para adicioná-los de volta ao repositório principal. É isso que permite que as equipes trabalhem de forma mais eficiente em seus computadores e depois mesclem tudo de volta para um único projeto.

Lembra-se de quando ligamos nosso projeto local ao projeto online? Agora, quando você diz ao Git para empurrar (to push) as alterações, elas serão copiadas e mescladas no projeto principal. Tudo que você precisa fazer é digitar o seguinte na linha de comando: 

 

$ git push --all

 

O --allé semelhante ao curinga ., que usamos anteriormente ao preparar nossos arquivos. Essa flag diz ao Git para enviar todas as confirmações recentes para a origem padrão, que é o que definimos com o comando remote add.

Veja e repita

Agora você já conhece os seis comandos mais essenciais para usar o Git:

  1. init Criar um novo projeto
  2. remote add origin Vincular um projeto local a um projeto online
  3. add Adicionar arquivos para acompanhar
  4. status Retornar a uma lista de arquivos no projeto local
  5. commit Salvar as alterações nesses arquivos
  6. push Copiar essas alterações no projeto online

Agora você pode executar as etapas 3 à 6 para continuar salvando as alterações feitas. Não há limite para o número de confirmações que você pode fazer, embora seja necessário limpar o repositório do Github de tempos em tempos, se você fizer muitas alterações.

À medida que você se sentir mais confortável com o Git, verifique como usar o arquivo .gitignorepara excluir itens específicos que você não deseja que sejam rastreados. Aqui, temos um projeto de Jesse Freeman que poderá ser utilizado como referência e que ignora os modelos gerados e alguns dos arquivos de configuração do projeto Python que não são críticos para quem procura executar o projeto localmente.

Finalmente, é importante observar que o Git tenta armazenar grandes arquivos binários, o que é outro motivo para usar um arquivo .gitignore. Muitos dados de treinamento, como imagem, vídeos ou qualquer coisa acima de 50 megas, podem causar um problema. O GitHub tem um limite rígido para arquivos de tamanho grande, caso envie no commit arquivos assim, você terá que seguir algumas etapas adicionais para desfazer as alterações. É melhor fazer backup desses arquivos em um sistema de controle de versão diferente .

Esperamos que este tutorial tenha sido útil para você que é novo no Git ou para você que procura uma atualização rápida. 

Faça seu comentário ou pergunta. Estaremos aqui para te ajudar.

 

Matéria adaptada de Jesse Freeman

 

Categorias
Ciência de Dados Programação Scala

Dica de leitura: Learning Scala Programming

Para quem está de quarenta, todo dia é um ótimo dia de leitura.

Então, se você já tem uma lista de livros para ler neste período, anota mais um!

O livro Learning Scala Programming de Vikas Sharma, foi feito para programadores que desejam se familiarizar com a Linguagem de Programação Scala para escrever programas concorrentes, escaláveis ​​e reativos. Não é preciso ter experiência em programação para entender os conceitos explicados no livro. Porém, caso tenha, isso o ajudará a aprender melhor os conceitos.

SAIBA MAIS

Scala é uma linguagem de programação de uso geral que suporta paradigmas de programação funcional e orientada a objetos. Devido ao seu design e versatilidade, as aplicações em Scala foram estendidas a uma ampla variedade de campos, como Ciência de Dados e Computação Distribuída.

Apesar de ser uma linguagem baseada na JVM (Java Virtual Machine) de uso geral, como Java, Scala fornece uma vantagem com as primitivas funcionais. Scala também possui um sistema de tipagem rico, o que o torna mais expressivo. Usando sistemas de tipagens, os desenvolvedores podem escrever aplicações menos propensas a erros em tempo de execução.

O LIVRO

O autor começa analisando os conceitos básicos da linguagem, sintaxe, tipos de dados principais, literais, variáveis ​​e muito mais. A partir daí, o leitor será apresentado às suas estruturas de dados e aprenderá como trabalhar com funções de alta ordem. 

Além disso, o livro apresenta conceitos como pattern matching, case classes e recursos de programação funcional. Em seguida, você aprenderá como trabalhar com os recursos de orientação a objetos em Scala e sobre programação assíncrona e reativa, onde será apresentado ao framework Akka. Há ainda o aprendizado sobre a interoperabilidade do Scala e Java.

Com tudo isso, este livro fornece todos os elementos essenciais necessários para escrever programas usando Scala. Ele tem todos os blocos de construção básicos que alguém novo em Scala pode querer saber sobre ele, além dos motivos para usá-lo. Um dos principais objetivos deste livro é permitir que você escolha uma construção específica acima de outra.

O AUTOR

Vikas Sharma é desenvolvedor de software e evangelista de tecnologia de código aberto. Ele tenta manter as coisas simples, o que o ajuda a escrever um código limpo e gerenciável. Ele investiu muito tempo aprendendo e implementando o código do Scala e é autor de cursos de vídeo de Scala. Sharma também trabalha como desenvolvedor no SAP Labs.

Depois de ler este livro, você estará familiarizado nesta linguagem de programação e em seus recursos e poderá escrever programas escaláveis, concorrentes e reativos em Scala.

Esta leitura será uma companheira em sua jornada de aprendizado e no desenvolvimento de aplicações em Scala.

 

Boa leitura!

 

 

Categorias
Ciência de Dados Programação Vagas Encerradas

Resultados das bolsas de Cientista de Dados e Programador Web

Notícia boa e em dose dupla!

Saíram  os resultados dos editais para bolsistas Cientista de Dados e Programador Web . 

Os candidatos aprovados receberão e-mails em breve com as orientações futuras.

Se você tava na ansiedade, clica aqui no link  e confira.

Categorias
Cursos DevOps Programação

Segunda parte do Curso de Introdução ao Kubernetes está disponível

Semana passada, nós disponibilizamos em nosso canal do YouTube a primeira parte do “Curso de Introdução ao Kubernetes”, contendo:

– Apresentação

01- Revisão Docker

02- O que é Kubernetes?

03- Arquitetura do K8s

04- Conceitos importantes do K8s

05- Instalação dos componentes do K8s

 

Hoje, lançamos em nosso canal a segunda parte,  contendo os módulos:

06- Configuração do K8s

07- ReplicaSet

08- Deployment

09- Service

10- Microservices

 

Clique aqui para acessar o Curso de Introdução ao Kubernetes 

Bons estudos!

 

Sair da versão mobile