• Home

    Escolha seu Plano

    Carreiras Alura

    Evolua com profundidade técnica, direção clara e aplicação prática.

    Jornadas guiadas do básico ao avançado com checkpoints práticos, desenhadas para quem busca profundidade e protagonismo técnico.

    Iniciante

    Comece do zero com uma trilha clara e progressiva.

    Fundamentos práticos para dar os primeiros passos com segurança e construir uma base sólida.

    Intermediário

    Continue sua evolução com cursos que conectam fundamentos, ferramentas e prática profissional. Ganhe autonomia, e avance para projetos mais completos.

    Avançado

    Aprofunde temas técnicos e estratégicos para enfrentar desafios mais complexos. Explore boas práticas, arquitetura, performance com visão profissional.

    Cursos

    Ver mais cursos de Back-end
    • Pensamento computacional: fundamentos da computação e lógica de programação
    • Lógica de programação: mergulhe em programação com JavaScript
    • DDD: fundamentos do design orientado a domínio
    • ASP.NET: autenticação e autorização em APIs e aplicações web
    • Microsserviços: migração de monólitos e modularização

    Cursos

    Ver mais cursos de Dados
    • Python para Dados: primeiros passos
    • Excel: domine o editor de planilhas
    • Engenharia de Dados: Orquestração de Pipelines com Apache Airflow
    • Power BI Desktop: construindo meu primeiro dashboard
    • Governança e Arquitetura de Dados

    Cursos

    Ver mais cursos de Inteligência Artificial
    • IA: Explorando o Potencial da Inteligência Artificial Generativa
    • Engenharia de Prompt: Criando Prompts Eficazes para IA Generativa
    • Claude para Análise de Dados: prompts, integrações e automações
    • Agno: criando agentes e sistemas multiagente
    • Engenharia de software na era da IA: segurança de aplicações com agentes, MCPs e código gerado por IA

    Cursos

    Ver mais cursos de Front-end
    • HTML e CSS: ambiente, estrutura e estilo
    • React: realizando testes avançados com Jest e Testing Library
    • React: integrando TypeScript em projetos
    • JavaScript: aprendendo a programar
    • React: aplicando arquiteturas de Micro frontends

    Cursos

    Ver mais cursos de DevOps
    • Sistema Operacional Linux: fundamentos e administração prática
    • Containers e Docker: empacotamento, isolamento e gestão
    • Redes: dos conceitos iniciais à criação de uma intranet
    • Linux: gerenciando diretórios, arquivos, permissões e processos
    • Cibersegurança: Fundamentos e práticas integradas

    Cursos

    Ver mais cursos de UX & Design
    • UX Research: mapeando a experiência da pessoa usuária
    • UX/UI Design: Entregando produtos digitais com IA
    • UI Design: Prototipação e animações interativas
    • Figma: Conhecendo o programa
    • Product Design: métricas e ciclo de vida do produto

    Cursos

    Ver mais cursos de Gestão & Negócios
    • Canva: Criação de landing pages e e-mail marketing
    • Agilidade: como ela pode ajudar a criar um time de alta performance
    • Google Analytics 4: Extrair insights e configurar eventos
    • Management 3.0: gerencie o ambiente, não as pessoas
    • Automação de processos com n8n: Inteligência de dados para Marketing

    Cursos

    Ver mais cursos de Mobile
    • React Native: Estilização e Layouts com Flexbox e StyleSheet
    • Flutter: Graphql e suporte offline
    • Android com Gemini: Trabalhando com textos e imagens na IA
    • Dart: trabalhando com orientação a objetos
    • React Native: Dominando Listas com FlatList e ScrollView

    Carreiras

    Ver mais carreiras
    • Especialista em IA
    • Engenharia de IA
    • Ai native software engineering
    • Arquitetura de Soluções com IA
    • AI Product Design
    • Engenharia de Machine Learning
    • Desenvolvimento Front-End React
    • Engenharia de Dados
    • Cloud Security
    • Social Media Marketing
    • Engenharia de Agentes de IA

    Cursos

    • Engenharia de Prompt: Prompts Eficazes para IA Generativa
    • Claude Code: Criando sua Primeira Aplicação
    • Python: Crie sua Primeira Aplicação
    • Git e GitHub: Compartilhando e Colaborando
    • N8N: Fluxos de Trabalho Avançados

    Cursos

    • Copilot Studio: Solução Multiagentes
    • Padrões de API HTTP e Modelagem de APIs
    • Python para Análise de Dados com SQL
    • Docker: Criando e Gerenciando Containers
    • Design com IA: Otimizando o Processo Criativo

    Cursos

    • Model Context Protocol (MCP)
    • Spec-Driven Development: Dev Assistido por Agentes
    • Arquitetura de Sistemas Distribuídos com Java
    • Governança de Modelos e Reprodutibilidade
    • Pentest: Vulnerabilidades em Aplicações Web

    Escolha seu Plano

    Skills & Go

    O Skills & Go é para Tech Leads, Product Managers, estrategistas e early adopters que transformam ideias em soluções de alto impacto. Em cursos ao vivo e 100% online, você domina a nova era da IA em tempo real.

    Aulas ao vivo

    Saiba mais
    • Agentic Engineering: orquestre múltiplos agentes com confiabilidade
    • Building AI Products: transforme ideias em produtos reais com IA
    • AI Data Strategy: transforme dados em decisões estratégicas com IA

    Escolha seu Plano

    Eventos Alura

    Nossos eventos são pensados para quem quer estar à frente das mudanças em tecnologia, IA e inovação. Em experiências presenciais, você acompanha tendências e se conecta com especialistas que estão moldando o futuro.

    Próximos eventos

    • Imersão Engenharia de Software: Dev na Era da IA
    • IA Conference
    • Alura Signals
  • Talent Lab
  • IA

    Escolha seu Plano

    Conteúdos gratuitos

    Explore conteúdos gratuitos para aprender tecnologia no seu ritmo. Encontre artigos com conteúdos técnicos para aprender na prática, notícias para acompanhar as principais tendências do mercado e o Alura Labs, com análises e reflexões de especialistas sobre tecnologia, IA e carreira.

    Conteúdos gratuitos

    • Artigos
    • Notícias
    • Alura Labs
  • Para Empresas
Ver planos
Links principais
  • Planos e Promoções
  • Links complementares do menu mobile
  • Talent lab
  • Inteligência Artificial
  • Pós Graduações
  • Para Empresas
  • Sobre a Alura
  • Grupo Alun
  • Entrar
    • Home
    • Carreiras
    • Skills & Go
    • Talent Lab
    • Inteligência Artificial
    • Pós Graduações
    • Artigos
    • Sobre a Alura
    • Grupo Alun
    LoginContato
    • LinkedIn
    • Instagram
    • YouTube

    Institucional

    • Sobre nós
    • Trabalhe Conosco
    • Para Empresas
    • Para Escolas
    • Política de Privacidade
    • Compromisso de Integridade
    • Termos de Uso
    • Canal de Ética
    • Código de Ética
    • Fale Conosco
    • Documentos Institucionais
    • Status
    Institucional
    • Sobre nós
    • Trabalhe Conosco
    • Para Empresas
    • Para Escolas
    • Política de Privacidade
    • Compromisso de Integridade
    • Termos de Uso
    • Canal de Ética
    • Código de Ética
    • Fale Conosco
    • Documentos Institucionais
    • Status

    A Alura

    • Como Funciona
    • Inteligência Artificial
    • Plataforma
    • Depoimentos
    • Instrutores(as)
    • Dev em <T>
    • Luri, a Inteligência Artificial da Alura
    • IA Conference
    • Cursos Imersivos
    • Perguntas Frequentes
    A Alura
    • Como Funciona
    • Inteligência Artificial
    • Plataforma
    • Depoimentos
    • Instrutores(as)
    • Dev em <T>
    • Luri, a Inteligência Artificial da Alura
    • IA Conference
    • Cursos Imersivos
    • Perguntas Frequentes

    Conteúdos

    • Alura Cases
    • Imersão Engenharia de Software: Dev na Era da IA
    • Artigos
    • Podcasts
    • Artigos de educação corporativa
    Conteúdos
    • Alura Cases
    • Imersão Engenharia de Software: Dev na Era da IA
    • Artigos
    • Podcasts
    • Artigos de educação corporativa
    Uma Empresa do GrupoLogo Grupo Alun

    Outras empresas do Grupo Alun

    • FIAP
    • STARTSE
    • PM3
    • LUMINA

    Ao submeter seu e-mail, você concorda com a política de privacidade da Alura.

    Redes Sociais & Apps

    instagram
    youtube
    tiktok
    x
    appStore
    googlePlay
    Uma Empresa do GrupoLogo Grupo Alun

    Outras empresas do Grupo Alun

    • FIAP
    • STARTSE
    • PM3
    • LUMINA

    Ao submeter seu e-mail, você concorda com a política de privacidade da Alura.

    Redes Sociais & Apps

    instagram
    youtube
    tiktok
    x
    appStore
    googlePlay
    Alura

    O que você quer aprender?

    FiltrosFiltrar por:

    Tipos de conteúdo
    Categorias
    • Back-end

      Próximos passos e carreiras em tecnologia

      Neste vídeo, iremos explorar o vasto universo da programação! Se você tem dúvidas ou está começando sua jornada, este é o guia perfeito para você. --- **Guilherme**: Se você chegou ao final da formação em Lógica de Programação, queremos te ajudar nos seus próximos passos e explorar onde trabalhar com desenvolvimento de software. **Vinicios**: Agora já temos uma base sólida e os fundamentos necessários. Há dois caminhos que se destacam como próximos passos naturais. Se você está mais voltado para o front-end e tem interesse em telas, estilos, pode prosseguir na trilha de front-end. Por outro lado, se se identifica mais com o back-end e não tem muito interesse na parte de posicionamento de elementos e visuais, deve seguir para o back-end. Mas, você não necessariamente ficará restrito a uma dessas áreas. Há possibilidade de transitar entre elas, o que pode abrir outras portas. Em ambas as esferas, front-end e back-end, existem diversos caminhos a serem trilhados. Identificar com qual você se encaixa mais, vai ajudá-lo a seguir seu próprio caminho. **Guilherme**: Vamos pensar especificamente sobre essas duas áreas, front-end e back-end. No front-end, existe o HTML, cujo enfoque não foi tão aprofundado no curso de Lógica de Programação, pois o objetivo estava mais voltado para trabalhar a linguagem, utilizando bastante o JavaScript e também o CSS. Quem busca uma carreira no **front-end** pode encontrar uma rota ideal se aprofundando mais em **HTML, CSS e no próprio JavaScript**. **Vinicios**: Se você curtiu o front-end, uma boa base com HTML, CSS e JavaScript será sempre útil e vai te auxiliar no que vier pela frente. **Guilherme**: Ao se falar em **back-end**, existem diversas linguagens, como Java, Python, C#, Go, entre outras. **Qual linguagem escolher?** **Vinicios**: Não existe uma regra específica para isso. Há muitas linguagens diferentes, mas também existem algumas que se assemelham, como Java e C#. Você pode escolher uma linguagem que já ouviu falar, por exemplo. Se você quer escolher uma mais famosa, talvez seja interessante o Java ou C#. Ou pode até mesmo continuar com JavaScript que você já aprendeu durante o curso. Afinal, já estará mais familiarizado com o modo como funciona. Ao aprender JavaScript, poderemos utilizar a mesma lógica para linguagens diferentes. **Guilherme**: Importante ressaltar que, independente da linguagem que você escolher para estudar, o conhecimento adquirido em uma linguagem não é descartado em outra - seja JavaScript para o back-end, Python ou Java. O código é escrito de uma maneira um pouco diferente, mas você vai reconhecer os padrões. Isso reforça a ideia de uma pessoa desenvolvedora mais generalista, que é capaz de trabalhar em projetos com linguagens diferentes. No início, o ideal pode ser selecionar uma linguagem e se dedicar a aprender ao máximo sobre ela. No entanto, não existem apenas dois caminhos na programação. Se você concluiu a formação em lógica de programação, há outras possibilidades. Uma delas é a área de dados. Pessoas que trabalham com **dados** utilizam frequentemente a linguagem Python, assim como no front-end se utiliza muito o JavaScript. O perfil geralmente associado às pessoas que querem trabalhar com ciência de dados, uma das grandes escolas da Alura, é o perfil mais curioso, investigativo, que gosta de trabalhar intensivamente com análise, criação de gráficos variados, testes de hipóteses, entre muitos outros aspectos interessantes. Possuímos uma trilha específica para isso na Alura. Se você tem interesse em aprender Python, já estudou lógica de programação e deseja adentrar no campo de dados, vamos reutilizar e aproveitar esses conhecimentos adquiridos nessa outra área de dados. **Vinicios**: E assim como temos dados, temos também a parte **mobile**, que abrange o desenvolvimento para dispositivos móveis. Fazendo uma correlação, a parte de dados está mais próxima do back-end enquanto a parte de mobile está próxima do front-end. Afinal, dispositivos móveis também são uma forma de interagir com a pessoa usuária. Mas, estamos falando de desenvolver especificamente para Android ou iOS. Da mesma forma que trabalhamos com as duas plataformas, podemos discutir desenvolvimento exclusivo para iOS ou exclusivo para Android, ou mesmo algo no meio do caminho, onde escrevemos um único código e o entregamos tanto para uma plataforma quanto para outra. Este é um dos possíveis caminhos e eu diria que está um pouco mais próximo do front-end porque está mais próximo da usuária, já que falamos de tela. **Guilherme**: Além disso, é algo muito usado. Em nosso celular, temos diversos aplicativos. Portanto, existe um mercado relevante em relação a isso também. Bom, essas são algumas das possibilidades do mercado e meu conselho pessoal para você agora é: **escolha um caminho**. No início, podemos ter a sensação de que escolher um caminho é como escolher uma faculdade e que teremos que segui-lo até o final. Mas, fiquem tranquilos, não é assim. O Vinny mencionou sobre começarmos em uma linguagem ou em uma área e, de repente, mudarmos para outra. Isso é algo tão bom e relevante que aqui na Alura temos um guia chamado Tech Guide. Nele, se você escolher a área de front-end, serão apresentados diversos caminhos e possibilidades de conteúdos relevantes tanto para o mercado como para nosso desenvolvimento nessa área. **Vinicios**: É hora de experimentar! Na Alura, temos todas as possíveis combinações de próximos passos. Experimente e explore! Se você gostou, aprofunde-se. Se não se identificou, experimente outras áreas, pois em alguma delas você certamente encontrará o que gosta e fazer seus olhos brilharem. **Guilherme**: Estamos torcendo por você! Lembre-se, estamos aqui para ajudar no seu desenvolvimento e no seu sucesso profissional. --- Se você ainda precisa de ajuda para encontrar o melhor conteúdo para você aqui na Alura, confira [este artigo](

    Ainda não estuda com a gente?

    Invista na transformação da sua carreira!

    Comece agora
  • Back-end

    Empresas que aprendem

    Você sabe qual o papel do aprendizado dentro de uma organização? **O aprendizado organizacional promove tanto a adaptação às mudanças quanto o crescimento da empresa**. Mas você tem ideia de como isso pode ser feito? Neste Alura+, Priscila Stuani fala sobre qual é o papel da organização no processo de aprendizado dos seus profissionais. As organizações possuem responsabilidades no processo de aprendizado de seus colaboradores e colaboradoras. Uma das formas de atuar nesse sentido é fomentar algumas competências, como o pensamento sistêmico, o domínio pessoal, trabalhar modelos mentais, construir uma visão compartilhada, aprendizagem em equipe, e reconhecer os padrões de interação que dificultam este aprendizado, além de estimular as tecnologias componentes. **Algumas estratégias que podem ser tomadas são: ouvir novas propostas, permitir o crescimento profissional das pessoas e incentivar interações!** Está afim de ser uma empresa que aprende? Confira as sugestões abaixo: **Cursos**: - [Aprender a Aprender: Técnicas para seu autodesenvolvimento]( Para conhecer os estilos de aprendizagem, criar rotinas produtivas e usar ferramentas para uma aprendizagem de alta performance. - [Desenvolvimento de Carreira: A demanda do mercado]( Para conhecer as principais estratégias para direcionar sua carreira. - [Alavancas de gestão do conhecimento: Aprendizagem e produtividade]( Para conhecer as cinco disciplinas propostas por Peter Senge para estruturar o processo de aprendizagem e produtividade contínua organizacional. **Podcast**: - [Cultura de Aprendizado]( **Artigo**: - [O dia a dia do profissional que aprende]( Vem **Inovar** com a gente! _____ # Transcrição Olá, eu sou **Priscila Stuani**, instrutora da Alura, e hoje vamos falar sobre as empresas que aprendem. Vamos entender qual é o papel da organização no processo de aprendizagem dos seus profissionais. Para exemplificar essa questão, vamos apresentar a **Bytebank**. Imaginemos que ela é composta por várias equipes multidisciplinares, com diversas áreas dentro da organização. Neste caso, destacaremos a área de **tecnologia da informação**. Existem várias pessoas dentro da equipe com diferentes perfis profissionais, desde aquelas em seu primeiro emprego até outras que já estão no mercado há algum tempo. O que essas pessoas têm em comum? Se a sua resposta for **desenvolver novos conhecimentos na área de programação**, faz todo sentido. Afinal, precisamos contar com alguns apoios dentro da organização. Na Bytebank, por exemplo, existe a Maria, responsável pela área de treinamento e desenvolvimento. Em outras organizações, pode ser um líder ou uma líder que exerce esse papel de acompanhar as demandas que as equipes precisam suprir em relação aos treinamentos. Maria recebe muitas demandas durante o dia, pois são várias áreas, e dentro da área de tecnologia da informação, há várias equipes que precisam desse apoio. Isso começou a gerar uma certa sensação de: > "Como acompanhar todos esses avanços para apoiar o constante processo de aprendizado das equipes?" Nesse caso, trabalharemos com a perspectiva de que existem vários profissionais que investem esforço individual e até financeiro em suas carreiras, fazendo especializações, o que é fantástico e faz todo sentido, pois acreditamos que o aprendizado é o melhor investimento que podemos fazer. Mas, e as empresas? As empresas também têm responsabilidade nesse processo. Mas como podem apoiar esses profissionais? Uma dica interessante é fomentar algumas **tecnologias componentes**, ou seja, gerar inovação para as organizações que aprendem. Profissionais que têm respostas rápidas, conseguem resolver problemas complexos em um curto período de tempo e são mais assertivos nas iniciativas acabam impactando positivamente a inovação da empresa. Para entender como tudo isso pode funcionar, é importante falar das tecnologias componentes. Quando bem integradas, elas fomentam o aprendizado nas organizações. A ideia é não focar apenas em separar um dia para deslocar a equipe para fazer um curso, que sabemos ser importante e muitas vezes ajuda a resolver situações pontuais. Quando falamos de empresas que aprendem, é importante colocar isso no DNA da organização, para que o processo flua de forma mais orgânica, e que as trocas e a forma como as pessoas interagem para resolver questões pendentes possam fluir de maneira mais tranquila e orgânica. Vamos falar de algumas competências que a organização precisa ter. ## Pensamento sistêmico A primeira delas é o pensamento sistêmico, cuja raiz está na ideia de que cada parte do sistema influencia o todo. Quando temos um problema em nosso coração, não é somente ele que fica doente; podemos comprometer outros órgãos. Quando falamos de "sistêmico", é quando algo é constituído por um conjunto de partes que se influenciam mutuamente. Na organização, quando temos um pensamento sistêmico bem alinhado, as equipes passam a trabalhar de forma mais produtiva e efetiva. A criatividade e a resolução de problemas complexos podem surgir de maneira mais natural. Fomentamos a troca de ideias e experiências, contribuindo para o processo de aprendizado contínuo das pessoas. ## Domínio pessoal Outra competência a compartilhar é o domínio pessoal. A expressão "domínio pessoal" pode sugerir controle sobre pessoas e coisas, além de um certo nível de proficiência na questão em que estamos atuando. No contexto das empresas que aprendem, pessoas com alto nível de domínio pessoal têm conquistas como concretizar resultados importantes e comprometer-se com seu aprendizado. Existe uma automotivação, uma energia que nos move para atingir o objetivo esperado. Gosto muito da frase de Peter Senge que diz o seguinte: > "**Domínio pessoal** é a disciplina de continuamente esclarecer e aprofundar na sua **visão pessoal**, de concentrar nossas energias no que realmente é importante, de desenvolver paciência e de ver a realidade objetivamente." > > **Peter Senge** Quantas vezes nos deparamos com situações que fogem do nosso controle e focamos apenas no problema, em vez de buscar soluções? Muitas vezes, buscamos culpados em vez de criar meios para resolver a situação e, em outros momentos, antever falhas para evitar perda de tempo, investimento e emoções. Domínio pessoal é uma característica fundamental que precisamos desenvolver. Na Bytebank, nem sempre foi assim. Quando não temos domínio pessoal, geramos poucos estímulos para o aprendizado das pessoas e desperdiçamos recursos. O que podemos fazer para evitar esse contexto? Podemos levantar o que tem sido feito para garantir que as pessoas na organização desenvolvam e apliquem esse domínio pessoal. Como fazemos isso? **Conversando**. Isso deve fazer parte da cultura organizacional, com um trabalho de comunicação onde as pessoas se conscientizem da importância do domínio pessoal, seus ganhos e como desenvolver essa competência. Além disso, precisamos trabalhar a questão dos modelos mentais. ## Modelos mentais Se pautamos nossas ações apenas em pressupostos arraigados, fazemos generalizações e criamos imagens que influenciam nossa forma de ver e agir, muitas vezes sem consciência, agimos no piloto automático. Este vídeo é um convite para revermos nossos modelos mentais e como reagimos diante de problemas. Quando somos contrariados, como reagimos? Talvez isso esteja ligado a esses pressupostos. É importante entender que isso faz parte do processo que passamos durante a vida, construindo essas referências. No trabalho em equipe e desenvolvimento pessoal, precisamos dar um passo atrás e ver quais são essas influências e o impacto negativo que podem ter em nossa forma de trabalhar e ser como um todo. > "O trabalho com modelos mentais começa por virar o espelho para dentro; **aprender a desenvolver nossas imagens internas do mundo** e levá-las à superfície sobre uma rigorosa análise." > > **Peter Senge** Uma das frases de Peter Senge que mais me impacta é justamente essa. É um processo contínuo, precisamos olhar para dentro para ver como estamos expondo tudo isso. Isso inclui promover conversas ricas em aprendizagem, indagações e argumentações. A ideia da Bytebank é fazer com que seus profissionais extrapolem a visão do óbvio. Sei que o óbvio é relativo, mas quando começamos a propor ideias e fazer coisas de modo diferente para verificar quais os resultados, promovemos a inovação. Falo de inovação não no sentido de tornar a empresa a grande startup do mundo, mas de ações do dia a dia que trazem impacto, ajudam a ganhar produtividade, efetividade, assertividade e um diferencial competitivo mais claro. São ações que podem parecer muito simples, mas são efetivas. ## Construção de uma visão compartilhada A construção de uma visão compartilhada precisa fazer parte do DNA da Bytebank. Vamos além da missão da empresa, internalizando missão, visão e valores para criar identificação e pertencimento ao ambiente. Quando falamos de visão compartilhada, como as pessoas estão vendo tudo isso? Trata-se de uma visão genuína sobre a empresa, essencialmente verdadeira, para evitar a impressão de que a missão no quadro da parede não corresponde à prática. O mercado está seletivo, e os profissionais também. As pessoas dão tudo de si e aprendem não só por obrigação, mas porque querem, vendo os efeitos no dia a dia e como o trabalho pode ser mais leve, sem desespero diante de problemas. A colaboração e a visão compartilhada são fundamentais nesse processo. Quando falamos de aprendizado, não há espaço para visões pessoais. Não é sobre fazer um curso porque o chefe mandou, mas sim sobre agir em função de uma visão compartilhada. Mais uma frase de Peter Senge: > "A prática da visão compartilhada envolve habilidades de descobrir 'imagens do futuro' compartilhadas que estimulem o compromisso genuíno e o envolvimento, em lugar de mera aceitação." > > **Peter Senge** As pessoas estão mais seletivas, buscando algo que faça sentido para elas. Estamos evoluindo para um patamar onde não fazemos algo apenas porque foi mandado, mas porque vemos sentido e importância, empenhando-nos para realizar a tarefa. Ao dominar essa disciplina, a liderança aprende como é contraproducente tentar ditar uma visão, por melhores que sejam suas intenções. A ideia não é julgar valores, mas reconhecer que a pessoa em liderança pode ter arraigado muitas coisas que desviam da cultura que promove o aprendizado na organização. É importante que a liderança esteja em constante auto-observação, observando também a equipe, estabelecendo relações saudáveis pautadas na confiança, para que o aprendizado surja de maneira mais tranquila, suave e real. ## Aprendizagem em equipe A aprendizagem em equipe também faz parte desse contexto. Quando compartilhamos experiências, aumentamos as chances de construir novos repertórios baseados nessas experiências, atingindo objetivos e sendo mais efetivos nas ações. Sentimos a sensação de triunfo ao resolver problemas, seja individualmente ou em equipe. Como estimular a disciplina da aprendizagem em equipes? Sabemos que enfrentamos vários desafios no dia a dia, mas basicamente é conversando, ou seja, a capacidade dos membros de deixarem de lado ideias pré-concebidas e participarem de um verdadeiro pensar em conjunto. Trazemos a conversa para um nível de racionalidade, concentrando atenções em resolver problemas ou pensar em meios de evitá-los futuramente. Reconhecer padrões de interação que dificultam a aprendizagem da equipe também precisa estar no radar, seja para quem exerce liderança ou atua em desenvolvimento e treinamento. Quando percebemos que algo está emperrado, já passamos todas as referências, trocamos ideias e as coisas não avançam, talvez seja um mecanismo de defesa, uma resistência ao novo. Sabemos que isso é um processo natural. Quando alguém diz "sempre foi assim", precisamos ter cuidado e carinho ao tratar questões sensíveis, desbravando pensamentos e modelos mentais arraigados, mas através de comunicação acolhedora, apresentando vantagens e ganhos, trazendo a pessoa para perto de nós. Além disso, promovemos a busca por ideias ou identificamos problemas e, de forma conjunta, conseguimos promover soluções efetivas. Vejamos a seguinte frase: > "Para concretizar seu potencial, o pensamento sistêmico também precisa das disciplinas de construção de uma visão compartilhada, modelos mentais, aprendizagem em equipe e domínio pessoal." > > **Peter Senge** O que a Bytebank ganha com tudo isso? Ao construir uma visão compartilhada, estimulamos o compromisso a longo prazo, fazendo com que as pessoas vejam o sentido do trabalho delas. Os modelos mentais contribuem para revelar limitações em nossas formas atuais de ver o mundo. A ideia não é dizer que alguém está errado, mas trazer a pessoa para perto, apresentando benefícios, ganhos e vantagens, para que ela perceba além da visão que tem, que pode ser limitada, e comece a perceber o sentido do trabalho que estamos fazendo. Pode ser um processo lento, pois trata-se de crenças pessoais, mas o trabalho precisa ser constante, pois os ganhos podem ser surpreendentes. Quando falamos de domínio pessoal, ele é responsável pela motivação pessoal de aprender continuamente como nossas ações afetam o mundo. Chamamos a responsabilidade para nós, sem terceirizar a responsabilidade dos nossos problemas. Isso pode ameaçar a visão sistêmica, tão importante na cultura de uma empresa. ## Aprendizado organizacional Quando falamos de aprendizado organizacional, lembramos que ele promove o crescimento da organização como um todo, contribui para a adaptação do negócio às mudanças, e os líderes têm papel fundamental na criação de condições que promovam esse aprendizado. Precisa ser algo sistêmico, de dentro para fora, para que as pessoas vejam que faz sentido e que todos estão envolvidos. Como podemos fazer isso? * Ouça novas propostas * Permita a apresentação de novas ideias, tenha disposição para compartilhar e acolher experiências; * Promova rodas de conversa * Concretização. Tudo que fica no campo das ideias não é efetivo, então talvez precisemos fazer adaptações, consultar outras áreas e responsáveis para implementar, mas esse é o processo, a dinâmica do jogo. **Permita o crescimento profissional das pessoas**, estimule e facilite a aquisição de competências, ofereça autonomia para que se desenvolvam. Proporcione um ambiente para treinar competências. **Incentive interações**, pois a lenda de que profissionais focados em suas tarefas são mais produtivos pode não ser verdade. A interação entre a equipe é importante para que o conhecimento seja transmitido corretamente. Pense em plataformas para troca de ideias entre as pessoas. **Aceite que o fracasso faz parte do crescimento**. Atenção a esse ponto, pois falamos de recursos financeiros, tempo e profissionais envolvidos. Trabalhamos na intenção de acertar, mas sabemos que nem tudo sairá perfeito. Aceitar que isso faz parte do processo de aprendizagem é fundamental. Algumas iniciativas podem não funcionar, trazendo consequências como demissão ou desconto no salário, mas isso não é rotina em empresas preocupadas em fomentar o aprendizado. Reconhecer quando as coisas não vão bem evita desperdícios de recursos. Precisamos ter domínio pessoal e entender que as coisas não saíram como esperado, e isso é natural. Na próxima vez, o que podemos fazer para evitar isso? Lembre-se, domínio pessoal é a chave. A aprendizagem organizacional permite que as pessoas participem mais ativamente. Esse é o ambiente que criaremos para que os profissionais façam parte do dia a dia da organização e promovam essas iniciativas!

  • Dados

    O que é SQL e por que aprender SQL é essencial para você?

    Neste vídeo, Igor do Nascimento explora o uso do SQL e quem pode se beneficiar com essa linguagem poderosa. Se você é uma pessoa desenvolvedora, administradora de banco de dados, cientista de dados ou profissional de negócios, o SQL é uma habilidade essencial. Aprenda por que o SQL é crucial e como ele pode impulsionar sua carreira. Para que você possa se aprofundar no tema, seguem links de conteúdos complementares: ### Artigo - [Saiba tudo sobre SQL - A linguagem padrão para trabalhar com banco de dados relacionais!]( ### Formação - [Formação **Conhecendo SQL**]( ### Mão na massa **1 - Criação da tabela de filiais:** sql CREATE TABLE filiais ( id_filial INTEGER PRIMARY KEY, nome_filial TEXT, email_contato TEXT ) Nesta parte do código, uma tabela chamada "filiais" está sendo criada. Ela possui três colunas: "id_filial" (um número inteiro que serve como chave primária), "nome_filial" (texto que armazena o nome da filial) e "email_contato" (texto que armazena o endereço de e-mail de contato da filial). **2 - Criação da tabela de vendas com a chave estrangeira:** sql CREATE TABLE vendas ( id_venda INTEGER PRIMARY KEY, id_filial INTEGER, quantidade_vendida INTEGER, mes_venda INTEGER, FOREIGN KEY (id_filial) REFERENCES filiais(id_filial) ); Nesta parte, uma tabela chamada "vendas" está sendo criada. Ela possui quatro colunas: "id_venda" (um número inteiro que é a chave primária da tabela de vendas), "id_filial" (um número inteiro que será usado como chave estrangeira para fazer referência à tabela "filiais"), "quantidade_vendida" (um número inteiro que armazena a quantidade de unidades vendidas) e "mes_venda" (um número inteiro que representa o mês da venda). A linha FOREIGN KEY (id_filial) REFERENCES filiais(id_filial) estabelece uma relação entre a coluna "id_filial" na tabela "vendas" e a coluna "id_filial" na tabela "filiais". Isso significa que podemos relacionar vendas a filiais usando a chave estrangeira. **3 - Inserir alguns dados de exemplo na tabela de vendas e filiais:** sql -- Inserir alguns dados de exemplo na tabela de vendas INSERT INTO vendas (id_filial, quantidade_vendida, mes_venda) VALUES (1, 5500, 1), (2, 4800, 1), (3, 6000, 1), (1, 5200, 2), (2, 4800, 2), (3, 5900, 2); -- Inserir alguns dados de exemplo na tabela de filiais INSERT INTO filiais (id_filial, nome_filial, email_contato) VALUES (1, 'Filial A', '[email protected]'), (2, 'Filial B', '[email protected]'), (3, 'Filial C', '[email protected]'); Aqui, estão sendo inseridos dados de exemplo nas tabelas "vendas" e "filiais". Os valores inseridos na tabela "vendas" incluem o ID da filial, a quantidade vendida e o mês da venda. Os valores inseridos na tabela "filiais" incluem o ID da filial, o nome da filial e o e-mail de contato. **4 - Consulta SQL:** sql SELECT f.nome_filial, f.email_contato FROM vendas AS v JOIN filiais AS f ON v.id_filial = f.id_filial WHERE v.mes_venda = 2 AND v.quantidade_vendida > 5000; Nesta consulta, estamos selecionando o nome da filial e o e-mail de contato da tabela "filiais" e juntando esses dados com a tabela "vendas" usando a cláusula JOIN com base na correspondência do ID da filial. Estamos filtrando os resultados para mostrar apenas as vendas que ocorreram no mês 2 (Fevereiro) e tiveram uma quantidade vendida superior a 5000 unidades.

  • Back-end

    Classe Object C#

    # Transcrição Olá, tudo bom? Meu nome é **André Bessa**, faço parte do time de instrutores da Alura. Neste vídeo, vamos tratar da **classe Object**, muito importante na plataforma .NET. Para tratar desse assunto, vamos usar o projeto de um módulo de cliente do banco ByteBank, em que definiremos novos comportamentos para a classe Cliente. Por exemplo, podemos exibir todas as informações de um cliente de uma vez só, em vez de chamar vários métodos de ConsoleWriteLine(). Essa implementação é interessante, pois outros desenvolvedores do projeto também poderão utilizar essa classe de maneira mais fácil. Com o projeto aberto no Visual Studio Community 2022, no arquivo Program.cs, notaremos que atualmente a exibição dos dados do usuário é feita com Console.WriteLine(), um método padrão para projetos console. Já no arquivo Cliente.cs, veremos que a classe Cliente é bem simples, tem apenas suas propriedades autoimplementadas com get e set: CPF, nome, e-mail e idade. Voltando ao Program.cs, a partir da linha 3, definimos um novo objeto do tipo Cliente e passamos informações para suas quatro propriedades: Cliente cliente = new Cliente(); cliente.Nome = "André"; cliente.Cpf = "111.444.666-88"; cliente.Email = "[email protected]"; cliente.Idade 23; Na sequência, para exibir esses dados, usamos Console.WriteLine() chamando cliente.Nome, cliente.Cpf e cliente.Idade: Console.WriteLine(cliente.Nome); Console.WriteLine(cliente.Cpf); Console.WriteLine(cliente.Idade); Essa construção não está muito boa, pois estamos escrevendo três linhas de código para exibir informações do nosso objeto. Nossa meta é que o desenvolvedor consiga obter esse resultado simplesmente passando o objeto cliente como parâmetro ao Console.WriteLine(). Vamos adicionar essa opção na linha 13: using ModuloCliente; Cliente cliente = new Cliente(); cliente.Nome = "André"; cliente.Cpf = "111.444.666-88"; cliente.Email = "[email protected]"; cliente.Idade 23; Console.WriteLine(cliente.Nome); Console.WriteLine(cliente.Cpf); Console.WriteLine(cliente.Idade); Console.WriteLine(cliente); Ao posicionar o *mouse* sobre um parâmetro, é possível verificar mais informações sobre ele, como seu tipo. Nos três primeiros casos, o método Console.WriteLine() está recebendo Nome (*string*), Cpf (*string*) e Idade (inteiro). Já quando passamos cliente como parâmetro, trata-se de um **objeto** — é mais complexo, porém o código não alega nenhum erro. A classe Console tem algumas sobrecargas do método WriteLine() que recebem tipos diferentes, mas será que uma delas recebe o tipo Cliente? Para investigar esse tópico, vamos acessar os **metadados** da classe Console. Basta pressionar e segurar a tecla "Ctrl" e clicar sobre a palavra Console (por exemplo, no início da linha 13). Desse modo, abrimos os metadados da classe, onde conseguimos visualizar as propriedades e os métodos disponíveis nela. A partir da linha 1667, podemos verificar as sobrecargas do método WriteLine(): há uma que recebe bool, uma que recebe decimal, outra que recebe long e, na linha 1821, encontraremos uma sobrecarga que recebe um object. A seguir, vamos entender melhor o que é o tipo object. Voltando ao Program.cs, o Console.WriteLine() não resulta em erro quando passamos como parâmetro um objeto completo (como cliente), porque Cliente é um Object. Vamos dar uma olhada nos metadados de Object também. Na linha 15, escreveremos "Object" e clicaremos nele, segurando a tecla "Ctrl". Observando os metadados, notamos que a classe Object também tem alguns métodos disponíveis. Por exemplo, na linha 22, temos public virtual bool Equals(object? obj) — considerando nossos conhecimentos das regras de sobrecarga e sobrescrita, sabemos que esse método deve ser sobrescrito. Temos também GetHashCode(), GetType(), MemberwiseClone(), ReferenceEquals() e ToString(). Se nossa classe é um object, quer dizer que temos todos esses métodos disponíveis nela! Voltando ao Program.cs, na linha 13, vamos acrescentar um **ponto** após cliente para acessar suas propriedades e métodos. Veremos Nome, Cpf, Email e também ToString, GetType, GetHashCode, entre outros. Ou seja, a classe Cliente herda de Object! **Todas as classes do . NET herdam explícita ou implicitamente da classe Object.** Vamos remover a palavra Object da linha 13, pois não vamos usá-la mais. Em seguida, vamos ao arquivo Cliente.cs para fazer um teste. Na linha 9, para indicar que a classe Cliente herda de Object, utilizaremos o operador dois pontos (**:**) seguido da classe da qual estamos herdando: public class Cliente:Object Note que não ocorre nenhum erro, porém essa construção é redundante, pois o compilador do C# já entende que essa classe herda de Object. Tanto que já tínhamos aqueles métodos disponíveis (ToString e Equals, por exemplo). Portanto, vamos apagar :Object. Vamos relembrar qual era nosso objetivo inicial: usar um método para exibir todas as informações do objeto cliente. Para tanto, após as propriedades da classe Cliente, vamos sobrescrever o método ToString() que é virtualna classe Object. Na linha 16, basta digitarmos override e pressionar a barra de espaço para o Visual Studio mostrar algumas sugestões de métodos para sobrescrever. Ao selecionar ToString(), a IDE gerará automaticamente uma estrutura que chama ToString() da classe base, isto é, de Object: public override string ToString() { return base.ToString(); } Para testar, vamos ao Program.cs e passaremos cliente.ToString() como parâmetro do Console.WriteLine(), na linha 13: Console.WriteLine(cliente.ToString()); Em seguida, vamos rodar a aplicação, clicando no *play* no menu superior do Visual Studio. O projeto será compilado e renderizado. Como resultado, serão exibidas as propriedades que passamos aos três primeiros Console.WriteLine() seguido de "ModuloCliente.Cliente", como era mostrado anteriormente. Quando passamos um objeto para o WriteLine(), ele invoca o método ToString() do objeto. Como não há implementação, ele invoca da classe base (Object), que retorna o nome da classe. Então, na classe Cliente, em vez de retornar da classe base, vamos **redefinir o método ToString()**: public override string ToString() { return $"Nome: {this.Nome}, \n" + $"Email: {this.Email}, \n" + $"Idade: {this. Idade}, \n" + $"Cpf: {this.Cpf}"; } > A expressão \n serve para criar uma quebra de linha. Assim, definimos como as informações serão exibidas, quando invocarmos o método ToString() de Cliente. Vamos salvar e testar, pressionando o *play* na parte superior do Visual Studio. A partir da quarta linha, veremos o resultado do método ToString() de Cliente. Vale lembrar que, quando passamos o objeto completo para o Console.WriteLine(), ele também invoca o ToString(): Nome: André, Email: [email protected], Idade: 23, Cpf: 111.444.666-88 Então, aprendemos que existe uma superclasse do .NET chamada Object da qual todas as classes herdam. Não somente as classes, todos os tipos do .NET também herdam de Object, por meio da classe ValueType! Por exemplo, um inteiro, um float, um double. A Struct que representa os inteiros (o int), por exemplo, herda de ValueType. Dessa maneira, o inteiro também herda de Object pelo mecanismo da herança. Basicamente, no .NET, temos dois tipos de objetos: por referência (onde entram nossas classes) e os ValueType (os tipos de valor, como inteiro): ![Diagrama sobre a classe Object. Há três níveis. No nível inferior, à direita, há um quadrado representando Struct. No segundo nível, há dois quadrados: ValueType à direita e MinhaClasse à esquerda. No nível superior, há um grande quadrado representando Class Object, com três métodos de exemplo. Há uma seta que liga Struct a ValueType, uma seta que liga ValueType a Classe Object e uma seta que liga MinhaClasse a Class Object.]( Como tem sido sua experiência aprendendo C# e orientação a objetos na Alura? Tem gostado? Não deixe de praticar bastante. Nos vemos na próxima!

  • Back-end

    Como usar ChatGPT para Gestão Ágil

    Neste Alura+, Daniela Soares, monitora na Alura, explica como utilizar a inteligência artificial do ChatGPT para **impulsionar a gestão ágil** em sua organização. Por meio dessa poderosa ferramenta, você aprenderá passo a passo como analisar dados para: * Construir personas; * Analisar ciclo de vida do produto. Você conhecerá como extrair informações valiosas dos dados disponíveis para criar personas detalhadas, que representem os diferentes perfis de consumidores. Com a ajuda do ChatGPT, você pode interpretar os dados de forma mais eficiente e identificar áreas de melhoria para impulsionar a experiência do cliente, além de descobrir como o ChatGPT pode ajudar na análise do ciclo de vida do seu produto! Bateu a curiosidade? Ao longo deste vídeo, você aprenderá a aplicar o ChatGPT para impulsionar a gestão ágil, transformando dados em insights. E para você se aprofundar no tema, confira: * [Artigo ChatGPT: o que é, como usar e dicas de comandos para o dia a dia]( * [Artigo Quais são os 4 tipos de aprendizagem na IA, algoritmos e usos no dia a dia]( * [Curso ChatGPT: otimizando a qualidade dos resultados]( # Transcrição É comum que, navegando na internet, nos deparemos com manchetes como esta: > **"Conheça as 10 profissões que serão substituídas pela inteligência artificial."** É um título um tanto dramático, não? Será que esse receio tem fundamento? Faz sentido construir um título dessa forma? É pensando em questões como essa que vamos explorar como o **ChatGPT** pode nos auxiliar nas **funções de gestão ágil** das pessoas que atuam como gerentes ágeis ou com agilidade de forma geral. Quando falamos de inteligência artificial, precisamos compreender um ponto: assim como outros avanços tecnológicos e inovações, a IA serve como **complemento às nossas funções e tarefas**, principalmente aquelas que podem ser **automatizadas**. Dessa forma, economizamos esforço humano em atividades repetitivas, tornando nossa experiência profissional mais gratificante. Vamos explorar como utilizar o ChatGPT como um **potencial colaborador** para nossas funções. Vamos ver como podemos construir uma *persona* e também avaliar o ciclo de vida de um produto. Para quem não sabe o que é ou nunca utilizou o ChatGPT,, não há problema. Disponibilizaremos vários conteúdos na descrição do vídeo para acesso posterior. Estamos utilizando a versão **3.5** do ChatGPT, que é gratuita. Um detalhe importante: **não compartilhe informações sensíveis com o GPT**. Utilizaremos dados fictícios para demonstrar o processo de construção da *persona*. Mas por que criar a *persona* é importante para a gestão ágil? Porque a *persona*, essa representação ideal do cliente, nos ajuda a compreender e **atender às necessidades dos clientes**. ## Construindo personas no ChatGPT Vamos começar perguntando ao ChatGPT o que é uma *persona*. A resposta é que uma *persona* é uma representação fictícia de um público-alvo ou de um cliente ideal. Ele fornece uma resposta bastante extensa. Em seguida, forneceremos algumas informações sobre o papel que ocupamos na equipe e o tipo de serviço ou produto que oferecemos. Por exemplo, escreveremos: > "Sou um gerente ágil e estou trabalhando com um aplicativo de *e-learning* para pessoas que desejam aprimorar seu currículo de forma flexível". O ChatGPT pode demorar um pouco para responder, pois é a versão gratuita. Ele sugere que definamos nossas *personas* criando personagens que representem nossos usuários-alvo e estabelecendo a história dos usuários. Não é exatamente o que gostaríamos que ele respondesse, mas deixamos que ele termine a resposta. Informaremos que temos **dados sobre os usuários do aplicativo** e pedimos que ele sugira algumas *personas* com base nesses dados. Após enviar os dados fictícios, ele começa a analisar informações como **idade**, **interesses** e **formação acadêmica**. Ele faz um resumo e, em seguida, pedimos que ele identifique **padrões nos dados fornecidos**. A resposta inclui **relação entre tecnologia e áreas de interesse**, **diversidade de formações acadêmicas**, **conexão entre interesses** e **objetivos profissionais**, e variedade de hobbies. Após esse processo, pedimos que ele sugira algumas *personas* que poderíamos construir a partir desses dados. Ele sugere cinco *personas*: > **Amanda**, a designer inovadora; > > **Lucas**, o desenvolvedor ágil; > > **Gabriela**, a gerente de projetos de TI; > > **Rafael**, o especialista em inteligência artificial; > > **Carolina**, a profissional de marketing digital. Pedimos que ele refaça as sugestões para ver se há variações. Ele modifica algumas informações, sugerindo, por exemplo, a *persona* Beatriz, a *Tech Enthusiast* (entusiasta de tecnologia), que não havíamos mencionado. É importante **não confiar 100% no GPT**, mas sim aloinhar o que você já conhece da sua profissão com o que ele pode te ajudar no dia a dia. Voltamos à resposta inicial e escolhemos a *persona* **Lucas, o desenvolvedor ágil**, para explorar mais. Ele detalha motivações, desafios e objetivos do Lucas com o aplicativo. Por exemplo, Lucas é **apaixonado por tecnologia** e tem **forte interesse em métodos ágeis**. Ele pode enfrentar desafios ao implementar práticas ágeis em sua equipe ou organização. O ChatGPT retorna inclusive recomendações para o aplicativo de e-learning, algo que não solicitamos. Pedimos que ele refaça as sugestões de *personas* com base em critérios estabelecidos: **aprimorar habilidades**, **rotinas saudáveis de estudo** e **sentir-se representado**. Com base nesses critérios, ele sugere novas *personas*: > **Sofia**, a jovem profissional ambiciosa; > > **Matheus**, o estudante determinado; > > **Carla**, a profissional em transição de carreira; > > **André**, o empreendedor criativo; > > **Isabela**, a profissional multitarefa. Pedimos que ele organize as sugestões em **ordem de prioridade** considerando os critérios que citamos anteriormente, algo que não alterará muito a configuração. Utilizamos um comando de texto para o ChatGPT, mas se tivermos uma **tabela no Excel**, podemos copiar todo o conteúdo e colar no GPT. ## Ciclo de vida de um produto Após a construção da *persona*, analisamos o **ciclo de vida de um produto**, utilizando o mesmo aplicativo de *e-learning*. Perguntamos ao ChatGPT o que é ciclo de vida do produto. Ele explica que é uma representação dos estágios pelos quais um produto passa desde a introdução no mercado até a retirada. Os estágios são: **introdução**, **crescimento**, **maturidade** e **declínio**. É importante que uma pessoa que trabalha com gestão ágil saiba identificar o ciclo de vida do produto em que está inserida para pensar **estratégias e investimentos adequados** para a fase em que o produto se encontra. Nesse caso, identificamos que estamos com **crescimento de assinaturas**, **forte concorrência** e **lucro crescente.** Com base nessas informações, o ChatGPT analisa e identifica que estamos no **início do estágio de crescimento** ou no **ponto intermediário**. Perguntamos quais **estratégias** podemos utilizar na fase de crescimento. Ele sugere **marketing intensivo**, **expansão para novos mercados**, **melhoria contínua do produto**, **aumento da oferta de valor**, **parcerias estratégicas**, **monitoramento dos concorrentes** e **fortalecimento do relacionamento com os usuários**. Após conferir as estratégias, pedimos que ele organize de acordo com critérios anteriores. > Critério 1: **aprimorar habilidades** > > Critério 2: **rotinas saudáveis de estudo** > > Critério 3: **sentir-se representado** Como retorno, ele organiza os critérios e as estratégias que fazem parte desse critério. Vamos pedir para que as estratégias sejam organizadas em uma tabela. | Critério | Estratégias | |------------------------------------------|-------------------------------------------------| | Critério 1: Aprimorar habilidades | - Melhoria contínua do produto | | | - Expansão para novos mercados | | Critério 2: Rotinas saudáveis de estudo | - Fortalecimento do relacionamento com os usuários | | | - Aumento da oferta de valor | | Critério 3: Sentir-se representado | - Parcerias estratégicas | | | - Marketing intensivo | ## Impacto das IAs na gestão ágil Após utilizar o ChatGPT para **analisar dados**, seja para criar uma *persona* ou identificar o ciclo de vida do produto, podemos nos perguntar como a IA impactará nosso trabalho como gerentes ágeis. O ChatGPT, assim como outras IAs, pode colaborar com nossas funções na gestão ágil, economizando tempo na busca de informações e tornando a tomada de decisões mais eficiente, possibilitando entregar mais valor aos clientes e *stakeholders*. Assim como o Trello, Jira ou Notion, o ChatGPT pode fazer parte do nosso dia a dia e auxiliar nas funções e tarefas como gestores ágeis. Além da análise de dados, o GPT e outras IAs podem auxiliar na melhoria contínua do produto ou serviço e no gerenciamento do projeto. Se ainda não utilizao GPT, você pode replicar os casos apresentados aqui com dados fictícios e conferir as respostas. Sinta-se à vontade para compartilhar ideias e expectativas sobre inteligência artificial no Discord Alura e conectar-se com outros alunos e alunas. Nos vemos em breve!

  • Back-end

    VSCode: Dicas e truques

    Tudo o que você precisa saber para tornar seu desenvolvimento mais prático dentro do VSCode. # Transcrição da aula Olá! Eu sou o Leonardo e nesse Alura+ vou apresentar para vocês um pouco do Visual Studio Code, também conhecido como VSCode ou VSC. O Visual Studio Code é uma IDE muito utilizada atualmente e com várias opções de atalhos e customizações. Com o VSCode aberto, começaremos a escrever código. Para isso, podemos criar um novo arquivo ou abrir uma pasta. Nesse caso, vou abrir uma pasta, o que facilita mantermos o código organizado. A pasta será criada no diretório "Documentos/Alura/Alura+ VSC". Não teremos nenhuma mudança visual grande, não abrimos nenhum editor e ainda não podemos escrever nenhum código. Isso porque ainda não temos um arquivo onde escrever esse código. Do lado esquerdo da tela, temos o "Explorer" do VSCode, que é onde ficam organizados nossos arquivos e editores. Dentro dos arquivos, temos a pasta "Alura+ VSC", onde estará o nosso código. Passando o mouse sobre esse menu, veremos algumas opções: * New File (novo arquivo) * New Folder (nova pasta) * Refresh Explorer (para atualizar o Explorer, por exemplo quando colocamos um arquivo por fora e ele não é detectado automaticamente) * Collapse Folders in Explorer (minimizar pastas no Explorer) Clicaremos em "New File" e, na caixa de texto que se abriu, digitaremos o nome do arquivo: app.js. O arquivo será criado e uma nova aba se abrirá no editor de código. Tínhamos outra aba aberta, "Getting Started", que podemos fechar. Começaremos criando uma variável. Como nosso arquivo é um .js, trabalharemos com Javascript. Ao começarmos a digitar const, uma caixa de sugestões será exibida, algo que pode nos ajudar a escrever o código. Criaremos a const nome com o valor igual a leo. const nome = "leo" Podemos mudar de ideia e, ao invés dessa const, fazer um console.log. Se apagarmos parte do nosso código, veremos que a caixa de diálogo não se abrirá novamente. Para que ela apareça, apertamos o comando "Ctrl + Espaço". Utilizando o "Enter", selecionaremos a palavra console e continuaremos o preenchimento com console.log(). Se quiséssemos o console.timeLog(), poderíamos nos dirigir a ele utilizando as setas para cima e para baixo. Mas além do Javascript, que outras linguagens de programação o VSCode suporta? No canto inferior direito da IDE, veremos a palavra "Javascript" como linguagem selecionada - isso porque estamos trabalhando com um arquivo .js e ele fez a detecção automaticamente. Se clicarmos nessa opção, abriremos um menu com todas as linguagens que podemos utilizar dentro do Visual Studio Code, dentre elas C, C++, Docker (dockerfile), Go, JSON, Lua, Markdown, dentre outras várias possibilidades. Vamos continuar trabalhando com Javascript. Se fôssemos escrever um código completo nesse Alura+, ele seria muito longo. Ao invés disso, pegaremos um código pré-preparado e o copiaremos para o arquivo app.js. Usaremos "Ctrl + A" para selecionar o conteúdo de source.js, "Ctrl + C" para copiá-lo e "Ctrl + V" para copiá-lo" no nosso arquivo. A primeira coisa que faremos é executar esse código. Porém, navegar pelas pastas dentro do console é um pouco trabalhoso. O Visual Studio Code também nos ajuda com isso, pois possui um terminal integrado. Abriremos o menu "Terminal" na parte superior da tela e clicaremos em "New Terminal", fazendo com que o console seja aberto na parte inferior da tela. Para executarmos, usaremos o comando node seguido do nome do arquivo. node app.js Ao pressionarmos "Enter", veremos que nada acontecerá. Note que a nossa tela está um pouco pequena, e podemos aumentá-la segurando a tecla "Ctrl" e usando o "+" do teclado. Da mesma forma, "Ctrl -" reduz o zoom da tela. Mas por que nosso código não retornou nada? Isso aconteceu pois esquecemos de salvar o conteúdo de app.js. O Visual Studio Code não salva os arquivos automaticamente. Isso é visível pelo aviso "1 unsaved" - ou seja, "um arquivo não salvo" - na área de editores do nosso menu. Além disso, tem uma "bolinha" ao lado do nome do arquivo app.js, tanto nos editores abertos quanto na sua aba, algo que também indica que o arquivo não foi salvo. Para salvar, usaremos o atalho "Ctrl + S" ou o menu "File > Save" (Arquivo > Salvar). Após salvarmos, voltaremos ao terminal e usaremos a tecla para cima do teclado para retornarmos ao último comando, node app.js. Ao pressionarmos "Enter", teremos duas saídas: > 8 > > [ 1 ] Vamos analisar o que nosso código faz para chegar a essas saídas. // idades = [30, 35, 28] // nomes = ["Ana", "Juliana", "Leonardo"] // faculdade = ["false, true, true"] // funcionarios = [nomes,idades,faculdade] // function eMaiorQue10(value) { // return value >= 10; // } // var filtrado = numeros.filter(eMaiorQue10); // //filtrado [é 12, 130, 44] // console.log(filtrado) const notas1 = [10, 6.5 , 8, 7.5] const notas2 = [9, 6, 6 ] const notas3 = [8.5, 9.5] const notasGerais = [notas1, notas2, notas3] let media = 0 for (let i = 0; i Word Wrap", cujo atalho é "Alt + Z". Isso fará com que parte do texto seja jogada para a próxima linha, que na verdade é uma continuação da linha 42 e não tem numeração, mantendo a 43 vazia. Salvaremos o arquivo e o executaremos novamente para verificarmos se não quebramos o código. Como temos o mesmo retorno, tudo continua correto. Outro ponto interessante: repare que na linha 39, o código console.log("retornou") parece "apagado", enquanto os demais códigos têm cores mais vivas. Ao deixarmos o ponteiro do mouse sobre ela, veremos a mensagem "Unreachable code detected", informando que o código dessa linha não é executado. Para resolvermos isso, podemos clicar sobre a linha e pressionar "Ctrl + .", abrindo o menu "Quick fix" (reparo rápido), que sugerirá remover essa linha. Como não queremos removê-la, mas sim executá-la, precisaremos encontrar outra alternativa - por exemplo, colocá-la antes do return da função teste() já que o essa instrução encerra a execução da função. Poderíamos recortar e colar o código, mas também existe outra maneira: segurar a tecla "Alt" com o cursor sobre a linha e pressionar a tecla para cima do teclado, movendo o código console.log("retornou") uma linha para cima. Após salvarmos e executarmos, continuaremos não recebendo nada, o que acontece pois a função teste() não é chamada nenhuma vez. Resolveremos isso incluindo a chamada da função. //... console.log(media) teste() function teste() { console.log("retornou") return 10 } //... Limparemos o console com clear e executaremos node app.js novamente. Podemos acessar esse código rapidamente pressionando para cima no teclado duas vezes. Como retorno, teremos: > 8 > > retornou > > [ 1 ] Agora nossa saída mudou, antes era só 8 e [ 1 ]. Vamos ver se realmente teve alteração? Usaremos "Alt + baixo" no teclado para descermos o console.log("retornou") para a linha original. Ao salvar e executar, voltaremos a ter o retorno anterior - ou seja, realmente funcionou. Quando estamos criando código, nem sempre tudo ocorre como esperado, e às vezes cometemos erros, por exemplo de sintaxe. Para testarmos isso, vamos incluir um erro bastante óbvio em nosso código: um + sozinho em uma linha. Repare que o VSCode realçará esse +, sublinhando-o. Além disso, o nome do arquivo app.js será realçado em vermelho tanto no menu "Open Editors" quanto na aba aberta, com o número "1" ao lado do nome, indicando o número de erros. No canto superior direito, temos também um pequeno resumo do nosso código, que inclui uma linha vermelha no ponto em que colocamos o +; e na barra de rolagem um tracinho será exibido na altura do erro. Nesse arquivo está fácil encontrarmos o erro, afinal nós o colocamos propositalmente. Porém, em códigos mais extensos, às vezes fica difícil encontrar os erros. Para contornar isso, podemos usar o atalho "F8" para navegar diretamente ao próximo erro, indicando também qual é o erro - nesse caso, temos a mensagem *"expression expected"*, ou seja, o Javascript espera uma expressão. Vamos simplesmente apagar o + que estava sozinho na linha e fechar a caixa de diálogo clicando no "x". Note que, após apagarmos o erro, a expressão *"expression expected"* ficara mais escura, indicando que foi resolvida. O Visual Studio Code também nos traz outras funcionalidades que podem ajudar no desenvolvimento. Vamos começar passando pelo array texto usando a expressão for. let texto = ["oi", "ok"] for A estrutura do for é bastante conhecida, e não precisamos fazê-la manualmente toda vez. Sendo assim, escreveremos for e usaremos "Ctrl + Espaço" para abrir a caixa de sugestões. Selecionaremos a opção For Loop. Ela é na verdade um *snippet*, um trecho de código já pronto para utilização. Ao clicarmos, toda a estrutura do for será montada no editor: let texto = ["oi", "ok"] for (let index = 0; index = 10; // } // var filtrado = numeros.filter(eMaiorQue10); // //filtrado [é 12, 130, 44] // console.log(filtrado) Poderíamos apagar as barras (//) linha por linha, mas existe o atalho "Ctrl + ;" (ou "Command + ;" no Mac), que permite comentar ou descomentar trechos de código. Mas e se quisermos alterar esse atalho de "Ctrl + ;" para "Ctrl + /"? Para isso, clicaremos na engrenagem no canto inferior esquerdo (*"Manage"*) e acessaremos o menu *"Keyboard Shortcuts"* (atalhos de teclado), cujo atalho é "Ctrl + K > Ctrl + S". Na nova aba, pesquisaremos por *"comment"* (comentário em inglês) e clicaremos duas vezes em *"Toggle line comment"*, opção que permite "trocar" o comentário da linha - ou seja, se ela está comentada, deixará de estar; se não estiver comentada, será comentada. Será aberta uma caixa de texto pedindo para digitarmos a nova combinação, em nosso caso "Ctrl + /". A caixa será preenchida com "ctrl+abnt_c1" e logo abaixo teremos o significado desse código, que é o atalho que digitamos. Após pressionarmos "Enter", o conteúdo será salvo. O interessante desse menu *"keyboard shortcuts"* é a possibilidade de encontrar todos os atalhos do VSCode, como *"cut"*, o clássico "Ctrl + X", e o *"copy"*, "Ctrl + C". No último caso, o VSCode também aceita "Ctrl + Insert". No arquivo app.js, selecionaremos o trecho comentado e pressionaremos "Ctrl + /" para descomentarmos. idades = [30, 35, 28] nomes = ["Ana", "Juliana", "Leonardo"] faculdade = ["false, true, true"] funcionarios = [nomes,idades,faculdade] function eMaiorQue10(value) { return value >= 10; } var filtrado = numeros.filter(eMaiorQue10); //filtrado [é 12, 130, 44] console.log(filtrado) Assim conseguiremos descomentar o bloco inteiro de código. Mais abaixo, vemos que a linha filtrado [é 12, 130, 44] continua comentada. Isso acontece pois ela já era um comentário - inclusive, se selecionarmos o bloco inteiro e o comentarmos novamente, a linha será comentada duas vezes (// //). Isso é útil pois conseguimos guardar o que já era comentário anteriormente em nosso código, evitando problemas. Já vimos os principais atalhos do VSCode, e agora conheceremos outras funções que ele nos oferece. Uma delas é o "Source Control", também conhecido como "Git" para quem já tem costume. Acessado a partir do menu à esquerda da tela (e pelo atalho "Ctrl + Shift + G"), ele nos permite inicializar um repositório Git ou publicar nosso código no Github - ou seja, o VSCode tem integração com o Github. Se escolhermos "Publish to Github", a IDE nos perguntará se a extensão pode utilizar nosso login, abrindo uma janela do navegador pedindo autorização para acessar nosso Github. Caso você não esteja logado, será necessário usar seu usuário e senha. Na janela seguinte, basta autorizar o acesso, clicar em "Abrir Visual Studio Code" e, de volta no programa, em "Open". Na parte superior da rela, teremos uma caixa de diálogo onde é possível criar um repositório, sugerindo o nome da nossa pasta ("Alura+ VSC"). Podemos publicá-lo como um repositório privado ou público. Não criaremos o repositório nesse vídeo, mas, caso você queira, basta fazer todo o percurso normal do Git, incluindo commit, push e assim por diante. Vamos falar um pouco sobre as extensões do VSCode, que também são bem úteis. Acessadas pelo menu à esquerda (e também pelo atalho "Ctrl + Shift + X"), elas permitem incluir mais funcionalidades ao VSCode. Como estamos trabalhando com Javascript, o ESLint é uma extensão bastante utilizada. É um formatador de código que inclui algumas boas práticas em Javascript. Pesquisando por ESLint e clicando em "install", ele será instalado. O ESLint é um caso especial dentre as extensões, pois precisa ter a biblioteca instalada na máquina - algo que pode ser feito usando o comando npm install eslint, para usá-lo somente no projeto atual, ou npm install -g eslint para instalá-lo globalmente. Outra extensão interessante é a Live Share. Desenvolvida pela Microsoft, essa ferramenta permite compartilhar código com outra pessoa em tempo real, como um arquivo do Google Docs ou do Office 365. Isso é legal quando você está trabalhando em grupo e é necessário editar o mesmo arquivo sem que seja necessário ficar "disputando o teclado" ou narrando o código para alguém digitar. Basta todas as pessoas baixarem o Live Share para que possam editar o mesmo código. O Live Server também é bem interessante. É um jeito rápido de desenvolver sites, muito útil para quem desenvolve em HTML, CSS e Javascript para Web. Ele abre um servidor em uma porta, que podemos acessar pelo navegador para explorar os efeitos do código no site que estamos desenvolvendo. Para quem trabalha com banco de dados SQL, temos a SQLTools, que ajuda a formatar o seu banco de dados, gerar queries, explorar os conteúdos salvos, dentre outras funcionalidades. Se você desenvolve em Java, temos a extensão da Language Support (suporte de linguagem) da Redhat, uma grande empresa bastante conhecida por quem trabalha com Linux. Existem algumas linguagens ou plataformas que não são suportadas pelo Visual Studio Code, por exemplo os microcontroladores. Nesse caso, podemos usar o PlataformIO, uma IDE que trabalha "em cima" do VSCode, oferecendo algumas plataformas como Atmel AVR (para Arduino), Expressif 32 e assim por diante. Também é uma plataforma boa para desenvolver com IOT, com frameworks para Arduino, por exemplo, substitindo a IDE própria do Arduino, que não é muito amigável em termos de possibilidades (como atalhos e sugestões). Já passamos por vários atalhos de teclado e funções do Visual Studio Code, nos familiarizamos com sua interface e aprendemos a começar projetos do zero ou abrir projetos já existentes. Também aprendemos a usar o terminal integrado e a integração com o Github, além de conhecermos algumas extensões. Devemos nos lembrar que as extensões do VSCode existem para expandir as possibilidades e tornar nosso trabalho mais ágil. Uma opção que acabei não comentando é a troca de tema do VSCode, acessada pelo menu à esquerda da tela o pelo atalho "Ctrl + K > Ctrl + T". Existem vários temas disponíveis, alguns claros (*light)* e outros escuros (*dark*), e outros como o *Tomorrow Night Blue*, que deixa a interface mais azul. Espero vocês na próxima!

  • Mobile

    Crie seu primeiro aplicativo de IA generativa no Android Studio

    Uma das maneiras de manter as pessoas usuárias cada vez mais em nossos aplicativos é fornecer **experiências mais ricas e personalizadas**. Nesse contexto, ter uma espécie de inteligência artificial que entenda o que a pessoa usuária está fazendo e seja capaz de interagir com ela é muito útil. Vamos começar a utilizar o *Gemini* dentro de nossos aplicativos e quem vai te acompanhar nessa jornada é o Junior Martins. > **Audiodescrição**: Junior é uma pessoa de pele clara, cabelos castanho-escuros compridos, que usa óculos com armação preta e também veste uma camiseta na cor preta. Ele está à frente de uma parede branca iluminada por luzes em degradê que vão do azul ao rosa. Durante esse conteúdo, queremos mostrar especificamente o que é o *Gemini*, que, caso você não conheça, é uma **ferramenta de inteligência artificial desenvolvida pelo Google** que, como eles mesmos comentam, foi desenvolvida para concorrer com o já conhecido *ChatGPT*. Ele faz parte de um modelo de inteligência artificial que são as IAs generativas onde podemos introduzir alguma informação, como um texto, uma imagem e ela será capaz de devolver mais informações. É muito comum, por exemplo, enviar um texto e pedir para ela resumir, criar uma história, gerar algum código, resolver algum problema ou mesmo passar alguma informação, como uma imagem, e pedir para ela trabalhar em cima disso. ## Explorando o Gemini do Google O *Gemini* é dividido em **três modelos principais**: temos o *Gemini Ultra*, uma versão muito mais potente, que geralmente é feita para rodar em servidores; o *Gemini Pro*, nas versões 1.0 e, mais recentemente 1.5, que é a versão que mais costumamos usar, mas ainda é uma versão que roda em servidores; e também o *Gemini Nano*, desenvolvido especialmente para rodar em dispositivos móveis, como smartphones. Na documentação do Google, eles explicam um pouco melhor o que é o *Gemini Nano*, dando uma introdução e explicando que ele está disponível apenas para alguns dispositivos. Se deslizarmos um pouco para baixo, no tópico “Benefícios da execução do dispositivo”, é comentado que essa versão roda diretamente no dispositivo, ou seja, ele não se conecta a nada para poder funcionar, tanto que temos o acesso offline de tudo que o *Gemini* é capaz. Mas, justamente por ele ter esse poder de processamento utilizando o próprio dispositivo como base, precisaremos ter alguns dispositivos muito potentes, com hardware muito bom, para poder rodar o *Gemini Nano*. E por isso que não vamos focar muito nele, afinal poucos dispositivos hoje em dia possuem essa versão. Dentro dessa própria documentação já é descrito que caso queiramos utilizar o *Gemini* em aplicativos, mas não tenhamos um desses dispositivos ou não queiramos focar especificamente no *Gemini Nano*, podemos utilizar a outra versão do *Gemini*, que é o *Gemini Pro*, dentro de nossos aplicativos. E por isso temos uma outra documentação com alguns exemplos de código. Se subirmos um pouco para o topo, teremos um cabeçalho semelhante àquele que já conferimos do *Gemini Nano*, mas com o título “Como usar a API Gemini em apps Android (SDK do cliente)”. Ou seja, podemos colocar um código dentro do nosso aplicativo que vai acessar o *Gemini* remotamente. Nesse caso, precisaremos fazer uma série de configurações que é descrita dentro dessa documentação, como por exemplo, fazer a configuração da chave da API, entender quais são os métodos que o *Gemini* traz para utilizar no Android. Essa é uma página dedicada a ensinar como podemos utilizar o *Gemini* através de APIs REST. Mas é descrito também que o próprio Google já preparou um *SDK* do *Gemini*, então podemos ir deslizando e conhecendo um pouco melhor desse *SDK*, com alguns códigos que funcionam de maneira mais simples, sem precisarmos de implementações tão complexas para poder começar. Mesmo assim, se continuarmos deslizando para baixo, veremos que alguns passos são necessários para poder utilizar o Gemini. Pensando nisso, o Google também tem trabalhado em um novo recurso dentro do próprio Android Studio, para facilitar nosso primeiro contato com o Gemini. Acessando a página do site Android Developers, acessaremos a aba “Desenvolver > Android Studio > Visualizar” e chegaremos à página “Criar seu primeiro app de IA generativa no Android Studio”. Aqui, temos a informação de que o Android Studio possui uma nova opção. ## Iniciando o projeto Se deslizarmos um pouco para conhecer, quando clicamos em “Criar um novo projeto”, aparecerá essa opção que é a Gemini API Starter. Se continuarmos deslizando para baixo, veremos algumas imagens, um passo a passo relativamente simples, sobre como utilizar essa função e quais são os passos que podemos seguir para continuar com ela. Porém, um detalhe que precisamos ficar atentos é sobre a **versão do Android Studio** em que essa função está disponível. Estamos com o Android Studio aberto, especificamente no Android Studio Koala 2024.1.1 Canary 3. É um número de versão bem grande, mas precisamos nos atentar de que essa nova opção que acabamos de visualizar na documentação só existe por enquanto nas **versões betas do Android Studio**. Vamos deixar especificamente essa versão para você poder fazer o download, e se quiser utilizar uma versão mais recente do Android Studio que esteja em beta, recomendamos que utilize a ferramenta Toolbox, que aparece no canto direito da tela. É uma ferramenta oficial da JetBrains, e recomendamos o uso dela. Pode ser que você tenha essa mesma versão, a Koala, instalada, mas que ela esteja em alguma versão futura, Canary 10, por exemplo, e ela não tem essa opção. Então, recomendo que você utilize o Toolbox, localize o Android Studio, clique nos três pontinhos verticais do lado direito dessa opção, clique em “Outras versões” no menu suspenso. Aqui dentro, você terá uma lista de versões. Geralmente esses recursos em teste beta costumam ficar nas versões Canary mais recentes. Por exemplo, temos a Koala nesse momento, mas um recurso que já esteve em versões anteriores, como, por exemplo, a Jellyfish 2023.3.1 Beta 2, mas que, por exemplo, nessa Jellyfish Beta 2, uma versão mais recente, não está mais presente. De qualquer maneira, repito que vamos deixar essa mesma exata versão para você poder fazer o uso. Com essa versão, quando clicamos em “New Project”, temos ali a opção Gemini API Starter, ou API Starter. Quando clicamos nessa opção, podemos perceber que ela está com uma tag de preview, que está em amarelo com texto preto no topo à direita. Essa tag vem sendo adicionada em recursos beta do Android Studio, então toda parte do Material Design, do Jetpack Compose, em algum momento esteve também com essa tag, e hoje em dia está de maneira oficial no próprio Android Studio. Então, pode ser que no futuro você não tenha mais essa tag, mas a opção já esteja ali nativamente. Podemos clicar no botão “Next”, e vamos seguir então com a criação de um projeto comum. Podemos, por exemplo, definir um nome, que vamos deixar como “GenIA”, e vamos deixar o pacote com com.alura.genia, que é a nossa Generate AI. Não precisamos alterar nenhum outro parâmetro. Vamos deixar a opção de Kotlin DSL como está e clicar no botão “Next”, e aqui tem um detalhe que precisamos prestar um pouco de atenção. Quando clicarmos no botão “Generate API key with Google AI Studio”, ele vai abrir um novo site no nosso navegador. Caso você nunca tenha acessado esse site, a primeira coisa que vai aparecer é um aviso de termos de serviço, e você pode marcar a primeira caixinha para poder aceitar esses termos e poder utilizar o Gemini. Vamos clicar na opção “Continue”, depois de marcar essa primeira caixinha, recomendamos que você leia as licenças, e logo de cara já teremos então essa tela de “API keys”, e você pode clicar em “Create API Key” no centro da página. Quando fizermos isso, ele abrir uma nova aba e pedir para criar uma chave novamente, podemos clicar em “Create API key in new project”. O objetivo aqui é gerar uma chave que conecta nossa conta a algum projeto do Android, que teremos disponibilizado na plataforma da Google. Para a Google ter um controle de quem está utilizando essa API, precisamos gerar uma chave, similar ao que vários outros serviços já fazem. Essa chave é uma sequência alfanumérica e depois que ela for gerada, podemos clicar em “*Copy*” (Copiar). Agora, podemos voltar para o nosso projeto no Android Studio. De volta no Android Studio, podemos colar a chave no campo “API Key” que estava vazio. > **Atenção:** recomendamos que você não compartilhe essa chave com ninguém, porque ela está justamente ligada à sua conta da Google. Nesse caso, vamos utilizar essa chave agora, depois que terminarmos de gravar, vamos invalidá-la, então você também não vai conseguir utilizá-la. Feito isso, podemos clicar em *Finish* (Finalizar), e aguardar o projeto ser construído. Então, ele vai abrir o projeto e fazer algumas configurações, é um procedimento um pouco demorado, teremos um erro que deve surgir no projeto que foi compilado. Esse erro vai ser justamente no arquivo MainActivity, que ele deve abrir por padrão, e na nossa MainActivity, que é a nossa tela principal, o BuildConfig provavelmente não vai ser reconhecido. Isso acontece porque esse arquivo de BuildConfig está relacionado a alguma das opções que veremos lá na própria documentação do Gemini, para poder configurar as chaves de maneira segura. Não vamos aprofundar muito nisso, vamos apenas corrigir esse erro. Ele dá a opção de fazer o *Import Class* nesse momento, só que se fizermos o *Import Class* dessa classe padrão, ele provavelmente não vai funcionar. Então, recomendamos que você clique na opção para poder construir o nosso projeto novamente, no topo da interface temos o ícone de um martelo que corresponde à opção “*Make Module*”. Vamos clicar nessa opção no canto superior do Android Studio, ali na parte direita, e vamos aguardar ele fazer o *build* do Gradle na parte inferior do Android Studio. Nosso projeto terminou de fazer o *build*, e ele já trouxe o erro que está na linha 50. Para corrigir esse erro, podemos simplesmente apagar esse BuildConfig.apiKey da linha 50, e começar a escrever BuildConfig novamente. Duas opções devem aparecer, sendo que precisamos selecionar aquela que tem o com. seguido do nome do nosso pacote, que no nosso caso é o com.alura.genia. Podemos então colocar um ponto no final e deve aparecer a sugestão “*apiKey*”, podemos selecioná-lo. val generativeModel = GenerativeModel( modelName = "gemini-pro", apiKey = com.alura.genia.BuildConfig.apiKey ) Se usarmos o atalho “Ctrl + B” nesse “*apiKey*”, a mesma chave que acabamos de girar no site da Google vai estar armazenada nesse projeto, de uma maneira segura, gerada automaticamente pelo plugin do Gradle. Podemos então rodar o nosso aplicativo com o “Shift + F10”, e ver que esse projeto já está todo configurado, podemos apenas testá-lo. O nosso aplicativo rodou, já estamos indo com o nosso emulador em tela, e das várias funcionalidades que o Gemini tem, uma delas é **sintetizar um texto**, ou seja, fazer um resumo de um texto que passamos. ## Resumindo um texto com o Gemini Quando rodamos o aplicativo, a primeira coisa que ele vai sugerir nessa interface, que tem justamente um campo para poder inserir informações, é digitar um texto e pedir para ele se resumir (“Enter text or a URL to summarize”). Então, pegaremos um texto bem extenso, que é um texto da documentação do Gemini, vamos clicar na caixa de texto e colar. É um texto com várias linhas que descreve o Gemini, como ele é um concorrente do ChatGPT, e podemos clicar na opção “*Go*” depois de colar esse texto. Ele vai fazer um pequeno *loading*. Esse *loading* é basicamente o nosso aplicativo consultando a API do Gemini, mandando essas informações que a pessoa usuária, que no nosso caso somos nós, inserimos e trazendo algum resultado. Então, tínhamos um texto com várias linhas e pedimos para ele ser resumido, sintetizado. Agora temos um texto muito menor, mas que ainda contém toda a essência do texto anterior. Ou seja, o texto foi interpretado e resumido mantendo os principais pontos-chave com relação às tecnologias. Foram mantidos o *Google DeepMind*, *Gemini*, *ChatGPT*, dentre outras. Se voltarmos para o código que temos além do emulador, podemos perceber que na MainActivity é chamado o SummarizeViewModel. Podemos clicar nele e usar o atalho “CTRL + B”, que vai nos redirecionar para o arquivo “SummarizeViewModel.kt”. Dentro desse ViewModel temos um sistema muito similar ao que nós já utilizamos em vários outros cursos, seguindo a documentação oficial do Android. É dito que uma configuração específica foi feita utilizando a API do *Gemini* para que, toda vez que ele passar na linha val prompt = “Summarize the following text for me: $inputText”, ele pegar o texto que a pessoa usuária colocou e adicionar essa nova instrução, que é a de resumir o texto. Mas, se quisermos, podemos fazer o *Gemini* não ter nenhuma instrução anterior para poder entender um pouco melhor como utilizá-lo. Essa é uma ideia bem simples de adaptar nesse código: ao invés de fazer esse val prompt conter todo esse texto “Summarize the following text for me:”podemos fazer o val prompt ser igual apenas ao inputText. fun summarize(inputText: String) { _uiState.value = SummarizeUiState.Loading val prompt = inputText } E se rodarmos o nosso projeto com essa única modificação e aguardarmos ele subir, a partir de agora, dentro desse nosso emulador, temos todo acesso ao potencial do *Gemini* com relação a texto. Então, podemos dar qualquer instrução para ele que ele vai seguir. Por exemplo, vamos clicar em Text to Summarize no nosso aplicativo e colar o texto “liste as 10 primeiras versões do Android”. Vamos clicar em “Go” e o *Gemini* tem justamente todo o conhecimento sobre as versões do Android. Ele vai trazer uma lista, inclusive enumerada, com várias das primeiras versões do Android. 1. Android Alpha 2. Android Beta 3. Android Cupcake (1.5) 4. Android Donut (1.6) 5. Android Eclair (2.0-2.1) 6. Android Froyo (2.2) 7. Android Gingerbread (2.3-2.3.7) 8. Android Honeycomb (3.0-3.2.6) 9. Android Ice Cream Sandwich (4.0-4.0.4) 10. Android Jelly Bean (4.1-4.3.1) Podemos passar várias informações, pedir para ele gerar histórias, para ele organizar listas, gerar códigos. E foi muito rápido o acesso que tivemos. Podemos começar a explorar a possibilidade de utilizar o *Gemini* sem precisar fazer uma série de configurações. Inclusive essa mesma do Build Gradle que vimos, ela é um pouco mais complicada, mas já vem por padrão feita e é algo que não precisamos nos preocupar. Porém, o *Gemini* também tem a possibilidade de lidarmos com outros tipos de informação. Para isso, podemos voltar mais uma vez ao nosso código no Android Studio e se clicarmos no menu principal no canto superior esquerdo, e selecionar “File > New > Import Sample”. Ele vai abrir uma nova janela. Na caixa de texto dessa janela, podemos digitar “IA” ou “Generate” e aparecerão alguns exemplos logo abaixo. Vamos selecionar o “*Google Generative IA Sample for Android (Kotlin)*”, logo abaixo de “*Jetpack Compose Layouts*”. A inteligência artificial está em versão beta, então temos a opção “*Google Generative IA Sample for Android (Kotlin)*” duplicada, aparecendo também sob a categoria de *Artificial Intelligence*. No fim das contas, podemos clicar em qualquer um dos dois “*Google Generative*”, ele vai trazer o mesmo exemplo. Selecionando essa opção e clicando em “Next”, ele sugere que criemos um novo projeto. Esse projeto, através do samples, é bem mais completo. E vamos deixar a configuração padrão que ele escolheu. Vamos clicar em “Finish” e aguardar ele gerar esse novo projeto com esse novo exemplo. Nosso projeto terminou de buildar. Já fizemos aquelas correções também com relação à nossa chave que vimos no projeto anterior. A única diferença é que aqui ela está no “GenerativeViewModelFactory.kt”, e está em mais de um lugar. Mas foi só adicioná-la no “local properties”. Já adicionamos o apiKey e buildamos o projeto. Temos um projeto mais robusto com vários exemplos de implementação do *Gemini* que você pode adaptar e também entender melhor estudando como ele funciona. Uma diferença que teremos é que aqui já são definidos vários tipos de modelos diferentes ao longo do código deste *ViewModel*. Então temos o *Gemini Pro*, o *Gemini Pro Vision*, o *Gemini Pro Normal*. ## Outras possibilidades de uso do Gemini Ao executar o projeto que acabamos de importar neste sample, teremos o aplicativo com três opções principais: “Generate text from text-only input”, “Generate text from text-and-image input (multimodal)” e “Build multi-turn conversations (chat)”. Estamos com o meu emulador disponível. Temos algumas opções para, por exemplo, explorar o modo chat, que é a última opção. Temos a opção para poder explorar o modo texto, que é a primeira. Mas a opção mais interessante nesse caso é a do meio, *Generate text from text-and-image input* (Gerar Texto a partir de Entrada de Texto e Imagem). Se clicarmos em *Try It* (Experimente), podemos adicionar algumas imagens de texto às informações que vamos inserir. Ou seja, se você, como pessoa desenvolvedora, quer criar um aplicativo em que o usuário pode enviar uma imagem, fazer uma pergunta ou, por exemplo, trabalhar em cima de alguma resposta com base no que o usuário acabou de fotografar, este é um código que você pode utilizar de exemplo. Se clicarmos no botão *Mais* (ícone de soma do lado esquerdo do campo “Question”), ele vai trazer a galeria do Android. Temos uma foto de uma pessoa e vamos enviar essa foto. Selecionamos a imagem e vamos digitar no campo de texto uma informação que é a seguinte: “qual é o nome do principal objeto do esporte que essa pessoa praticava?”. Vamos clicar em “*Go*” e vou aguardar a resposta. Aguardamos um pouco, já temos a resposta e a resposta foi bem direta (“Bola”), mas vamos explicar rapidamente o que aconteceu: A foto que selecionamos quando clicamos no botão de *Mais* é a foto do jogador de futebol Pelé. E o que o *Gemini* fez foi basicamente pegar essa imagem, fazer um *scan* dela, entender quem era a pessoa que estava presente, depois ele foi procurar se essa pessoa jogava algum esporte, entendeu o que era o futebol, depois ele foi ver qual é o principal objeto utilizado no futebol. Então teve toda uma **linha de raciocínio** que o *Gemini* fez através da entrada de uma imagem e também de texto para poder fornecer uma resposta. Ela foi bem sucinta, mas é apenas para poder demonstrar o potencial que existe ao fazer o uso dessa ferramenta nos nossos aplicativos. Demos esse exemplo um pouco mais complexo, mas justamente para poder mostrar que se você souber aproveitar esse recurso, pode criar aplicações realmente muito úteis para o usuário final. Vamos deixar os links de tudo que visualizamos abaixo para você poder acessar. Se estiver vendo este vídeo em alguma rede social, não se esqueça de clicar nos botões de gostei para sinalizar que curtiu esse conteúdo. Muito obrigado pela sua presença e até mais! ### Outros links e informações relevantes: - [Conheça o Google Gemini.]( - [Documentação do Gemini Nano.]( - [Documentação SDK do Gemini para Android.]( - [Gemini API Starter no Android Studio.](

  • Gestão & Negócios

    Ideação

    Olá estudante, neste Alura+ você vai aprender mais sobre o processo de ideação, o que ele faz, qual o objetivo e técnicas que podem ser aplicadas facilmente em equipes para fomentar a criatividade e deixar o ambiente confortável para compartilhar novas ideias, desenvolver ideias que já existiam e pensar em diferentes caminhos para colocar essas ideias em prática. Para que você possa se aprofundar no tema, seguem links de conteúdos complementares: Artigos Complementares: - [Como melhorar a criatividade?]( - [Design Thinking: Inovação e criatividade]( - [8 passos para conduzir um processo de ideação]( # Transcrição Olá, tudo bem? Eu sou a Alanis, instrutora da Alura, e hoje vamos aprender sobre **ideação**. Alguma vez já aconteceu de você participar de uma atividade de trabalho que requer a elaboração de novas ideias, mas ficou com vergonha de expor suas ideias por medo de julgamento ou de serem consideradas ruins? Este é um cenário muito comum que acontece com muitas pessoas. Neste Alura+, vamos discutir a ideação, que é a terceira de cinco etapas que compõem um processo chamado ***Design Thinking***. Assim, temos a empatia, a definição, a ideação, o protótipo e o teste, que formam um processo criativo de elaboração e compartilhamento de novas ideias. > **Etapas do Design Thinking:** > > * Empatia > * Definição > * Ideação > * Protótipo > * Teste ## O que é ideação? Ideação é o pensamento inovador que não necessariamente resolve apenas um problema, mas também oferece uma forma mais eficiente de elaborar ou implementar uma ideia. Dentro do processo de ideação, temos a criação de novas ideias, o desenvolvimento de ideias existentes que ainda não estão 100% concluídas e pensar na melhor maneira de colocar essas ideias em prática. Vale lembrar que, no processo de ideação, vamos precisar do maior número possível de ideias, pois algumas serão consideradas soluções potenciais enquanto outras serão rejeitadas. Isso é normal. ## Qual o objetivo da fase de ideação? O foco do processo de ideação está na quantidade e não na qualidade das ideias. Precisamos do máximo de ideias possível para conseguirmos encontrar uma solução para resolver um problema. Portanto, em uma sessão de ideação, é importante que descubramos e exploremos novos caminhos, pensemos fora da caixa e, por motivos de inovação e criatividade, o ambiente durante a dinâmica de ideação seja uma zona livre de julgamentos. Afinal, não estamos aqui para analisar ou julgar a ideia de alguém, mas sim para tornar o ambiente o mais confortável possível para que as pessoas possam ter pensamentos criativos e compartilhar esses pensamentos. No começo da sessão de ideação, é comum compartilharmos ideias um pouco óbvias, ou talvez haja pessoas que, ao compartilhar ideias, temem o julgamento ou sentem vergonha de compartilhar uma ideia que possa ser considerada ruim. Existem várias variáveis que podem fazer com que o processo de ideação não saia como o esperado. No entanto, existem algumas técnicas que podemos usar para tornar este processo o mais produtivo possível, e vou apresentar agora três técnicas rápidas e fáceis para você aplicar no seu dia a dia, no processo de ideação. ### Brainstorming O primeiro é o *brainstorming* (chuva de ideias), que é bastante conhecido e amplamente utilizado neste processo de ideação. Vale lembrar que nem todas as pessoas se sentem à vontade para participar dessas sessões. Existem pessoas mais introvertidas, que não necessariamente ficam no fundo da sala, mas compartilham menos ideias e participam menos. Isso não significa que não estejam prestando atenção, apenas que falam menos que as outras pessoas. Enquanto isso, as pessoas mais extrovertidas participam muito e falam bastante sobre suas ideias, e queremos evitar que as pessoas se sintam desconfortáveis ao compartilhar suas ideias. Como podemos evitar que isso aconteça? Por meio de uma atividade de *brainstorming* chamada ***brain dump***. Nesta atividade, as pessoas recebem post-its e escrevem cada ideia em um post-it. No final da dinâmica, cada pessoa cola os post-its com suas ideias na parede e todas conseguem ler as ideias de todas. Outra técnica que pode funcionar é uma atividade chamada ***brainwriting***. Nela, a pessoa recebe um papel, escreve suas ideias nele e, em vez de colá-lo na parede para todos lerem, passa-o para a pessoa ao lado, que complementa sua ideia. Esse papel passará por todas as pessoas. Ao final da dinâmica, cada pessoa lê um papel e discute o que é importante, o que vai ser considerado e o que vai ser rejeitado. ### Pior ideia possível A segunda técnica é a "pior ideia possível". Esta técnica é projetada para tornar o ambiente mais descontraído e é bastante eficaz para isso. Funciona da seguinte forma: precisamos pensar na pior ideia ou solução possível para resolver um determinado problema. Isso também ajuda a reduzir a pressão entre as pessoas que estão participando da dinâmica. Vamos dar um exemplo. Suponha que precisamos pensar na pior ideia possível para um novo design de tênis para trilhas. Então, podemos pensar em tênis com palmilhas de pregos ou tênis com espelhos na sola. São ideias descontraídas, mas é exatamente isso que a atividade pede. Dessa forma, as pessoas sentirão mais conforto ao compartilhar suas ideias, sem medo de serem julgadas por outras pessoas. ### Pensamento reverso A terceira e última técnica é a do pensamento reverso. Esta técnica é mais divertida porque ela inverte o problema, fazendo com que as pessoas pensem em ideias mais inovadoras. Por exemplo, vamos supor que nosso problema, que precisa ser resolvido e de onde precisamos tirar ideias, seja: "como podemos tornar nossos cursos online mais acessíveis?". Usamos a brincadeira do pensamento reverso. Portanto, nesse caso, o questionamento a ser feito é: "como podemos dificultar o acesso dos usuários à plataforma para fazerem nossos cursos online?". As respostas geradas por esse exercício farão com que você imagine o oposto, ajudando a encontrar a solução que de fato necessita. Agora você sabe o que é a ideação, sua importância, seu objetivo e quais técnicas pode utilizar durante a ideação para torná-la muito mais produtiva. Muito obrigado por assistir e até a próxima!

  • DevOps

    Shift Left em DevOps

    Geralmente em processos de desenvolvimento de software as atividades de **testes**, **segurança** e **deploy** são deixadas para o final, causando assim gargalos, bloqueios e dificuldades em se finalizar os ciclos de desenvolvimento e entrega de software. **Shift Left** é uma prática que consiste em **deslocar** para a **esquerda** tais atividades, que normalmente estão mais à direita no processo, para que assim desde o **ínicio** de cada ciclo elas possam ser discutidas e planejadas, evitando problemas e acelerando a entrega de software. --- # Transcrição Olá, tudo bem? Meu nome é **Rodrigo Ferreira**, sou um dos instrutores da Alura, da Escola de Programação e DevOps. > **Audiodescrição:** Rodrigo Ferreira é uma pessoa de pele clara, com olhos castanhos e cabelos também castanhos e lisos. Usa uma camiseta cinza lisa. No fiundo, uma luz LED verde ilumina uma parede com redes de gatos. Hoje, aprenderemos sobre ***Shift Left***. Vamos lá? > **Audiodescrição:** Abertura do Alura +. No fundo toca uma música animada. Sobre um fundo azul, as palavras "Mergulhe", "em", "tecnologia" piscam na tela. Depois aparece a logo do Alura+. Quando a abertura termina, a câmera do Rodrigo está no canto inferior esquerdo e, no centro da tela, temos "Shift Left" escrito em azul-claro sob o fundo azul-marinho. ## Metodologias ágeis e o trabalho como dev Talvez esse termo não seja familiar, mas é **muito utilizado** por pessoas que trabalham com **DevOps** e **metodologias ágeis**. Entenderemos melhor o que ele significa e como pode nos ajudar. Se trabalhamos em uma empresa de desenvolvimento de software, é comum fazermos **parte de um time**. Desenvolver software não é apenas escrever código, tornou-se uma tarefa complexa que envolve várias etapas e pessoas. Antigamente, o **modelo Cascata**, uma abordagem comum para organizar o desenvolvimento de software, como podemos observar na imagem a seguir: ![Diagrama de fluxo simples do processo de desenvolvimento de software com cinco etapas sequenciais conectadas por setas na direção da esquerda para a direita: PLANEJAMENTO (roxo claro), ANÁLISE (azul claro), CODIFICAÇÃO (verde claro), TESTES (amarelo claro), e DEPLOY (rosa claro).]( Era uma abordagem comum para organizar o desenvolvimento de software. Esse modelo incluía etapas como: * Planejamento, * Análise * Codificação * Testes * Deploy Com o deploy, a aplicação era liberada para o acesso das pessoas usuárias terem acesso. Entretanto, esse processo tinha **problemas**, percebidos ao longo dos anos. Por isso, com o tempo, surgiram **novas abordagens**, como o **manifesto ágil e as metodologias ágeis**, amplamente utilizadas hoje. No entanto, mesmo com metodologias ágeis, como o Scrum, **ainda precisamos realizar atividades do modelo cascata**, mas aconteciam durante as sprints (ciclos de desenvolvimento). Dependendo da empresa e do projeto, pode haver etapas adicionais, como **segurança**, onde são realizados testes para garantir a segurança da aplicação. Em outros casos, pode ser que uma das etapas sejam substituídas ou não realizadas. Mesmo com metodologias ágeis, **ainda precisamos dividir tarefas e perfis**. É comum trabalharmos em times com pessoas em diferentes papéis, como codificadoras e testadoras. ### Desafios da metodologia ágil Esse tipo de ambiente, com separação de atividades, pode levar a **problemas**, mesmo em ambientes ágeis. Um problema comum é a **criação de barreiras** entre responsabilidades e papéis, que ficam com pessoas ou times diferentes, resultando em silos e **isolamento**, ao invés de colaboração. ![Diagrama anterior, mas com linhas verticais grossas na cor preta separando e isolando cada processo.]( Isso pode causar **problemas**, especialmente nas **últimas etapas do processo**, como testes e *deploy*. Um dos problemas é a **espera**. As etapas finais, como *deploy*, só são executadas no final, deixando as pessoas responsáveis por essas etapas ociosas. Outro problema é o **travamento**, porque as atividades são realizadas em ciclos. As pessoas responsáveis pelas últimas tarefas vão receber o projeito no final do ciclo, resultando em **sobrecarga de trabalho e atrito entre as pessoas**. As pessoas do final do processo precisam fazer horas extras para conseguir cumprir sua etapa antes do final do ciclo para entregarem sua parte, ampliando as chances de tensão entre os times do final do processo com os times do começo. > **Problemas** > > * Espera > * Gargalo > * Sobrecarga de trabalho > * Atrito entre as pessoas/times Consequentemente, esses problemas podem gerar conflitos entre times, e eu trouxe uma imagem engraçada que representa essa situação, como um cachorro e um gato brigando: ![Fotografia colorida editada para fins de humor. Na fotografia, um cachorro está com uma postura tensa e raivosa, à esquerda, mostrando os dentes para um gato a sua frente, indicando que pudesse estar rosnando. O gato, também está com uma postura bastante raivosa e parece rosnar para o cachorro. Além disso, a imagem foi capturada quando o gato estava prestes a dar uma patada no cachorro. Para fins de humor, adicionarem uma garrafa na pata do gato que bateria no cachorro. Essa cena está acontecendo em uma praia rochosa. Na parte de baixo da foto, está escrito "Devs vs Ops", como se o cachorro representasse o time de Devs e o gato representasse o time de Operações.]( Isso costuma acontecer com os times de desenvolvimento e operações, mas pode acontecer com outros times também, como programação e testes. A considerada demora da entregam o que pode levar a discussões e brigas, **criando mais barreiras entre os times**. ### Solucionando atritos com Shift Left Se identificamos essa situação em nossa empresa, onde as pessoas do final do processo estão sobrecarregadas, podemos minimizar esses problemas com o conceito de **Shift Left**. O termo "Shift" pode lembrar a tecla de mesmo nome, mas não se trata disso, e sim de um **conceito**. A ideia é **deslocar as últimas etapas do processo**, como testes, segurança e *deploy*, **para a esquerda**, ou seja, para o **início do processo**. Por isso "**Shift Left**" (Deslocar para esquerda). Por exemplo, pode-se discutir desde o início quais serão os testes aplicados e, dependendo da implementação, como de testes automatizados, também pode ser iniciado. O Mesmo funciona para o *deploy*. Pode-se discutir se será necessária alguma estrutura, como firewall ou servidor, e antecipar alguns processos. Isso significa **planejar e discutir essas etapas desde o início**, evitando problemas e retrabalho. Ao aplicar o Shift Left, promovemos a **colaboração** entre os times, eliminando conflitos e melhorando o planejamento. Isso evita travamentos e sobrecarga nas etapas finais, agilizando a entrega do software e evitando retrabalho. **Vantagens do Shift Left:** * Colaboração entre pessoas/times * Planejamento prévio das etapas de teste, segurança e entrega * Evita travamentos no processo de desenvolvimento * Agiliza a entrega do software * Evita retrabalho Essas são as vantagens de utilizar a prática do Shift Left. Se ainda não a utilizam, esperamos que esse conhecimento seja útil no seu dia a dia. Podemos aplicar essa ideia em times e empresas que estejam sofrendo com esses problemas de gargalos, retrabalhos e travamentos, deslocando as últimas etapas para a esquerda, **promovendo planejamento e colaboração**. Nos vemos em outros cursos e conteúdos da Alura. Obrigado por assistir. Um abraço!

  • DevOps

    Feature Flags e Parallel Change (Deploy vs Release)

    Neste vídeo você vai conhecer Feature Flags e Parallel Change, dois conceitos bem conhecidos do universo DevOps. Se você quiser conhecer mais de DevOps, pode começar pela formação [Primeiros passos em DevOps]( # Transcrição Você sabia que existem diferenças entre *deploy* e *release*? Neste vídeo, falaremos sobre elas, além de comentar práticas aplicáveis em cima dessas distinções. Oi, pessoal. Eu sou Vinicius Dias. Sejam bem-vindos à Alura. Neste Alura+, vamos bater um papo sobre a **diferença entre *deploy* e *release***, bem como discutir certas práticas que podemos aplicar em cima dessas diferenças. Assim, conseguimos obter resultados interessantes na hora de soltar um *release* ou criar um *deploy*. Primeiramente, vamos entender a diferença entre essas duas palavras. ***Deploy*** basicamente é o ato de ter o ambiente e o software já instalados e configurados. Em resumo, é colocar o software em produção — isso é fazer *deploy*. Se você tem o software desenvolvido e testado, já fez o *build*, passou por toda a *pipeline*, mandou para um servidor de homologação e para a produção, então você fez o *deploy*. Já fazer o ***release*** é entregar esse *deploy* para usuários reais. É perfeitamente possível fazer o *deploy* (por exemplo, de um novo *endpoint*) e não o documente, não entregue, não permita acesso pelos usuários. De qualquer forma, esse *endpoint* está em produção, o *deploy* foi feito. Portanto, o *release* é o ato de tornar público e disponível para os usuários. Então, fazer a publicação é gerar uma *release*. Inclusive, é bastante comum ir aumentando o *deploy* por um período para, no final do mês, por exemplo, gerar um só, mandar para a produção e fazer um único *release* de todas as novas funcionalidades. Em outras palavras, se foi gerada uma nova versão, foram escritas notas de versão e foi enviado um e-mail para o cliente expondo as novidades, então fizemos um *release*. Porém, sabemos que, antes disso, já tínhamos feito o *deploy*, pois o ambiente já estava configurado e o software já estava em produção. Então, essa é a diferença entre esses dois termos. Logo, vale notar que, se temos a opção de fazer o *deploy* sem fazer o *release*, ou seja, se é possível ter código em produção que os usuários ainda não vão acessar, podemos adotar algumas práticas interessantes em cima dessa ideia. Por exemplo, **feature toggles** ou **feature flags**. Ao criar uma funcionalidade, ela pode estar em um ponto crítico da aplicação ou modificar diversos trechos do código. Para diminuir os riscos da *release*, faremos o *deploy* adicionando uma expressão condicional if (uma verificação no código) para que a funcionalidade somente seja exibida caso a *feature flag* esteja marcada. Em outras palavras, a *release* será feita apenas se uma checkbox, uma configuração específica esteja ativa. Com as *feature flags*, conseguimos determinar que somente alguns clientes tenham certa funcionalidade ativa; outros clientes, não. É possível que você já tenha lido a respeito dos ***beta testers* ou testadores de novas funcionalidades**. Basicamente, essas pessoas terão as *feature flags* de funcionalidades novas habilitadas antes do resto dos usuários. Já aconteceu de você ter um aplicativo e seu amigo possuir uma funcionalidade nova que você ainda não possui? Isso é feito por meio das *feature flags*. Embora pareça complexo, visto que aplicativos enormes o utilizam, trata-se de um processo relativamente simples de ser implementado. Podemos realmente fazer um único if: se esta *feature flag* estiver ativa para determinado usuário, então libere a funcionalidade. Essa regra de ativação pode ser um simples botão que marcamos e desmarcamos, ou pode seguir outro padrão. Por exemplo, se quisermos liberar a funcionalidade para metade dos clientes, uma opção é habilitar a *feature flag* para os usuários cujo ID é par — se o ID for par, estará habilitada; se for ímpar, desabilitada. Assim, permitimos acesso a 50% dos usuários. Dessa forma, temos o *deploy* de uma funcionalidade, porém o *release* ainda não aconteceu para todos os clientes. Assim, conseguimos **monitorar com mais cuidado, com menos usuários**. Caso exista um problema, ele afetará menos pessoas, de forma que teremos uma *release* mais segura. Já que estamos falando sobre adicionar if e verificar o ID dos usuários, outra técnica bastante interessante e mais relacionada com o código em si é o ***parallel change*** (em português, "mudanças em paralelo"). Esse conceito também pode ser chamado padrão ***expand, migrate and contract***. A seguir, vamos entender o que isso significa. Vamos imaginar que temos uma classe com um método que recebe dois parâmetros de coordenadas, o X e o Y. Então, agimos em cima dessas informações. Por exemplo, em uma planilha no Excel, nas coordenadas X e Y teremos uma célula em que adicionaremos o conteúdo. Em outro par de coordenadas, teremos outra célula e adicionaremos outros dados, e assim em diante. Contudo, ao estudar sobre boas práticas, notamos que em vez de ter dois parâmetros inteiros seria mais adequado ter uma classe nova de coordenadas. Nela, teríamos a validação (se é uma coordenada positiva, por exemplo). Ou seja, queremos modificar a API do nosso código, alterar a interface com a qual lidamos com o código. Para tanto, precisaríamos quebrar o contrato e atualizar diversas partes do código. A ideia de *parallel change* é basicamente inserir novos métodos que recebem um objeto do tipo coordenada por parâmetro em vez desses dois inteiros. No entanto, os métodos que recebem os dois inteiros continuarão existindo. Todo o código que já existia continua funcionando e qualquer código novo que precise chamar esses métodos pode utilizar essa API melhorada. Então, quando adicionamos esses novos métodos, estamos na fase de ***expand*** — expandimos a API, criamos mais código, mais informações. Em seguida, avançamos para a fase de ***migrate***. Vamos migrar o código já existente para passar a utilizar os métodos novos, a nova API. Esse processo pode ser gradual, de forma mais lenta. Por fim, entramos na fase de ***contract***, em que enforçamos o novo contrato. A nível de código, esse procedimento é feito excluindo os métodos antigos que recebem aqueles dois parâmetros inteiros. Com essa abordagem temos algumas **vantagens**. De início, o código já existente não quebrará com essa melhoria do código, tudo continuará funcionando. Ademais, teremos uma API melhorada, com melhores práticas e pronta para ser utilizada por qualquer código novo. Ou seja, há entregas e melhorias contínuas em nosso código. E, por fim, a migração para o código novo pode ser incremental, realizada lentamente, ao longo de várias *releases*. E se fizéssemos *releases* usando o *parallel change*? E se, além de melhorar o código, pudéssemos liberar novas funcionalidades em paralelo? O nome dessa prática pode ser ***blue-green deployment*** ou ***blue-green releases***. Vamos supor que estamos criando um sistema novo ou novas funcionalidades do mesmo sistema. Temos o código atual rodando em um ambiente e faremos o *deploy* dessa nova funcionalidade em outro ambiente. Em seguida, podemos passar a redirecionar usuários para essa versão 2. Caso ocorra algum problema, basta redicioná-los de volta para o código anterior que continua funcionando. Inclusive, temos a opção combinar os conceitos de *blue-green deployment* com *feature toggles*. Por exemplo, podemos direcionar 20% dos usuários para o código novo e 80% para a versão antiga. Conforme o monitoramento, aumentamos o número de usuários na nova versão. Então, esse é o conceito de *blue-green deployment*. De forma incremental, conseguimos fazer com que os usuários utilizem a nova versão. Ou seja, realizamos um *release* incremental, de forma mais lenta. Já a ideia de *feature flag* é mais de baixo nível, no próprio código. Já o *blue-green deployment* refere-se ao sistema inteiro. São duas bases de códigos diferentes. O fato de conseguirmos separar conceitualmente *deploy* e *release* nos fornece ferramentas interessantes para tornar todo nosso ambiente de desenvolvimento e de operações mais seguro e mais tranquilo para se trabalhar.

  • 1Página 1…96Página 96…221Página 221
    1Página 1…94Página 9495Página 9596Página 9697Página 97
    98
    Página 98
    …
    221Página 221