DEV Community: Ana Laura

O que é um Perceptron — ou pelo menos o que eu entendi sobre ele

Ana Laura — Mon, 30 Jun 2025 01:56:50 +0000

E aí, cês tão bem?

Hoje, quero trocar uma ideia sobre o tal do neurônio artificial, mostrar como ele pensa, erra, aprende e, no fim, toma decisões sozinho.

Mas o que é um perceptron?

Um perceptron é o modelo mais simples de uma rede neural. Ele é tipo um neurônio artificial que já consegue tomar decisões do tipo:

sim ou não
1 ou 0
curte ou não curte

A ideia é: ele recebe algumas informações (as chamadas entradas), faz uma conta e toma uma decisão. Mas, assim como a gente, ele só consegue decidir bem depois de aprender ou seja, errando, ajustando, errando de novo… até acertar.

Entradas e decisões

Essas entradas podem ser qualquer coisa: quantas curtidas um post teve, se a pessoa gosta de dançar, se ela vai em baile... o que for.

Entrada: gosta de dançar? → x1
Entrada: vai em baile? → x2

Exemplo prático: quem curte funk?

Imagina que a gente quer ensinar um perceptron a dizer se a pessoa curte funk com base em duas perguntas:

Gosta de dançar? (x1)
Vai em baile? (x2)

Se a resposta for sim, a entrada é 1. Se for não, é 0.

A matemática por trás da decisão

A conta que o perceptron faz é essa aqui:

resultado = (x1 * w1) + (x2 * w2) + b

Onde:

x1, x2 são as entradas (ex: gosta de dançar, vai em baile)
w1, w2 são os pesos, que mostram o quanto cada entrada é importante
b é o bias (viés), um ajuste fino pra linha de decisão

Depois dessa conta, ele compara o resultado com um limiar (threshold):

Se o valor for maior que o limiar, ele diz: curte funk (1)
Se for menor ou igual, ele diz: não curte (0)

Mas o que são esses “pesos”?

No começo, eu buguei com esse negócio de peso. Mas depois entendi que o peso é só o quanto aquela informação influencia na decisão.

Tipo:

Gosta de dançar? Legal, mas pode não significar muito.
Vai em baile funk? Aí sim! Isso provavelmente pesa muito na decisão.

Então, o peso de “ir em baile” talvez seja maior que o peso de “gostar de dançar”.

E o tal do bias?

O bias é outro elemento importante.

Sem ele, a linha de decisão do perceptron sempre teria que passar pela origem (0,0), o que limita muito.

Com o bias, essa linha pode se mover pra cima ou pra baixo, ajudando a separar melhor os dados.

O bias é como empurrar a média final de um aluno pra cima ou pra baixo, pra ajustar essa nota mínima sem mudar a regra da escola.

Lembra do limiar, aquele ponto de corte que decide entre 0 e 1? Quando usamos o bias direto na conta, a gente já tá ajustando esse corte. Ou seja, o bias ajuda o modelo a “empurrar” essa linha de decisão pra cima ou pra baixo, sem precisar de um limiar separado.

Visualizando em um gráfico

Imagina que você tem um plano com dois eixos:

X (horizontal)
Y (vertical)

Cada ponto ali é um "exemplo" com duas características. Por exemplo:

Pessoa	Gosta de dançar (X)	Vai em baile (Y)	Curte Funk?
A	0.9	0.8	Sim (1)
B	0.2	0.1	Não (0)
C	0.7	0.4	Sim (1)
D	0.1	0.3	Não (0)

Quando você plota esses pontos no gráfico, quem curte funk tá mais pra cima e pra direita, e quem não curte tá mais pra baixo e esquerda.

Como o perceptron aprende com os erros?

Aí vem a parte mais massa: ele aprende com os próprios erros.

Pra ensinar o perceptron, a gente não dá só as entradas (x1, x2), mas também a resposta certa que em IA a gente chama de rótulo.

O rótulo é o que a gente espera que o modelo diga.

Por exemplo:

x1 = 1 (gosta de dançar)
x2 = 1 (vai em baile)
rótulo = 1 (a pessoa curte funk)

O perceptron calcula o resultado com os pesos e o bias:

resultado = (x1 * w1) + (x2 * w2) + b

E compara com o rótulo:

Se acertou → não muda nada
Se errou → ele ajusta os pesos e o bias pra tentar melhorar

Esse processo se repete com vários exemplos. É isso que a gente chama de treinamento.

O que acontece depois de aprender?

Depois de muito treino, o perceptron encontra uma linha de decisão ideal aquela que separa direitinho quem curte funk (pontos rosa) de quem não curte (pontos roxos).

Mas isso depois de alguns ajustes, primeiro ele erra e acha uma linha sem muito sentido.

Ai depois de vários ajustes, ele acha a linha ideal que separa os dois grupos direitinho.

A linha pontilhada preta é a "linha de decisão" aprendida pelo modelo: ela separa os dois grupos, quem curte funk (pontos rosa) e quem não curte (pontos roxos). Depois de muitos ajustes, o perceptron encontra a linha ideal que separa os dois grupos.

Essa linha c*hamada linha de decisão* é onde o perceptron passa a dizer:

Desse lado aqui → curte funk (1)
Do outro lado → não curte (0)

É tipo o cérebro dele falando: “A partir daqui, eu sei o que responder.”

Resumão

Perceptron = o neurônio mais básico de uma rede neural
Recebe dados → soma ponderada com pesos e bias → toma uma decisão
Aprende errando e ajustando os pesos
Consegue traçar uma linha de separação entre grupos diferentes
Funciona muito parecido com a forma que a gente aprende: tentando e melhorando com os erros

bjs bjs e até a próxima 💟

Você realmente entende como funciona uma IA generativa?

Ana Laura — Fri, 27 Jun 2025 01:12:47 +0000

Ultimamente eu venho estudando bastante sobre inteligência artificial e comecei a me perguntar: será que a gente realmente entende o que acontece por trás dessas tecnologias?

Quando comecei a aprender sobre machine learning (ou aprendizado de máquina), meu primeiro pensamento foi mais ou menos assim:

“Tá, então a gente ensina a máquina a aprender usando dados que a gente mesmo fornece.”

Por exemplo: se eu quiser prever se vai chover amanhã, eu passo pra máquina várias informações sobre o clima, como umidade, temperatura e vento. Ela analisa tudo isso, procura padrões e tenta prever a resposta. É como se ela dissesse: “olhando pra dias parecidos no passado, geralmente choveu, então provavelmente vai chover agora também.”

Até aqui, a IA trabalha com dados que são mais fáceis de organizar, tipo números e planilhas. Mas o pulo do gato acontece quando a gente entra no mundo do Processamento de Linguagem Natural (PLN).

Nesse momento, os dados deixam de ser números e viram palavras, frases, conversas humanas. E aí o desafio muda completamente. Porque a linguagem humana é cheia de gírias, duplo sentido, contexto... coisas que não são tão fáceis de ensinar pra uma máquina.

Tá, Ana, falei muito e talvez ainda não tenha deixado tão claro, então bora simplificar.

Como a máquina entende texto?

A primeira coisa importante é entender que o computador não entende palavras como a gente. Ele só entende números. Então, pra uma IA conseguir trabalhar com texto, ela precisa transformar as palavras em números.

Existem vários jeitos técnicos de fazer isso, mas o mais importante é saber que cada palavra vira um vetor, ou seja, uma sequência de números.

Esses números representam a posição daquela palavra em um espaço imaginário com várias dimensões, como se fosse um mapa onde cada palavra ocupa um lugar, dependendo de como ela é usada.

Por exemplo, a palavra "banana" pode virar algo como [2, 3, 0, 1]. Esses números não dizem que "banana" é amarela ou é fruta, mas mostram como essa palavra se relaciona com outras. Se "banana" aparece perto de "fruta", "doce", "vitamina", ela vai ficar mais próxima dessas palavras no tal mapa.

E como a IA aprende isso? Tentando, errando, ajustando e tentando de novo. Igualzinho a gente quando tá aprendendo algo novo.

E como a IA gera um texto?

É aqui que a mágica acontece.

Depois de aprender com milhões (às vezes bilhões) de frases, a IA começa a perceber padrões. Ela entende que, por exemplo, a frase “Hoje o céu está...” provavelmente termina com “limpo”, “nublado” ou algo assim.

Pense, por exemplo, no autocomplete do teclado do seu celular: às vezes ele sugere exatamente a palavra que você ia digitar e parece até “adivinhar” suas intenções.

Mas ele não entende o significado das palavras, só reconhece padrões com base no que já foi digitado antes.

Quando você digita uma pergunta ou escreve um texto, o processo dela é mais ou menos esse:

Transforma seu texto em números
Lê esses números e tenta entender o contexto
Prevê qual é a próxima palavra que faria sentido
Escreve essa palavra
Repete isso, uma palavra por vez, até formar a resposta

Ela não entende o que está dizendo como a gente entende. Mas ela sabe, com base nos dados que viu, o que costuma soar certo.

Mas ela é inteligente mesmo?

E é aí que mora o ponto mais importante.

Apesar de parecer inteligente, uma IA como essa não sabe de verdade o que está dizendo. Ela só repete padrões com base nos dados que recebeu.

Se ela nunca viu nada parecido com o que você perguntou, a resposta pode vir errada, sem sentido ou até inventada.

No fim das contas, tudo funciona com muita matemática e lógica — algo muito diferente da complexidade do nosso cérebro humano.

Quando foi que a gente parou de fazer perguntas?

Ana Laura — Mon, 23 Jun 2025 21:23:06 +0000

Hey, Vsauce. Michael here

Alguns meses, descobri um dos melhores canais de todos os tempos. Talvez eu esteja um pouco chateada por não saber da existência dele antes.

O Vsauce fala sobre absolutamente qualquer assunto, mas, acima de tudo, ele me ajudou a recuperar a curiosidade de entender o “porquê” das coisas.

Conforme a gente vai ficando mais velho, muitas vezes paramos de questionar o mundo ao nosso redor. Mas o Vsauce não. Ele questiona tudo — e traz vídeos incríveis sobre temas aparentemente simples, como por exemplo: Por que batemos palma?

Meu único objetivo com esse post é te perguntar:
Por que a gente para de questionar as coisas?

Obrigada, Michael (Vsauce), por ter me ajudado a reencontrar isso. :)

Tipos de Aprendizado de Máquina

Ana Laura — Tue, 23 Apr 2024 02:48:56 +0000

No meu último post aqui, eu trouxe um pouco do que venho vivenciando aprendendo sobre análise de dados. Dando sequência aos meus estudos, comecei a estudar um pouco sobre machine learning e trouxe aqui alguns conceitos mais básicos, como os tipos de aprendizado que existem!

Grande parte das coisas escritas aqui vem do que estou aprendendo no livro:
Mãos à obra: aprendizado de máquina com scikit-learn & tensorflow

~~To achando muito legal aprender sobre tudo isso. Sabe, é como se eu estivesse aprendendo sobre o cérebro de um computador. kkk~~

Então, vamos lá!

Esse tipo de aprendizado se divide em algumas categorias. Vou resumir aqui, mas no decorrer do artigo aprofundarei em cada uma delas.

Treinamento com Supervisão Humana: Os algoritmos de aprendizado de máquina podem ser treinados com ou sem supervisão humana. Isso é conhecido como:
- Aprendizado Supervisionado: O algoritmo aprende a partir de um conjunto de dados rotulados fornecidos por humanos.
- Aprendizado Não Supervisionado: O algoritmo aprende a partir de um conjunto de dados não rotulados, encontrando padrões e estruturas nos dados.
- Aprendizado Semissupervisionado: Uma combinação dos dois anteriores, onde o algoritmo aprende a partir de um conjunto de dados parcialmente rotulados.
- Aprendizado por Reforço: O algoritmo aprende através de tentativa e erro, recebendo recompensas ou punições por suas ações.
Aprendizado em Tempo Real: Alguns algoritmos podem aprender gradualmente em tempo real. Isso é conhecido como aprendizado online. Por outro lado, o aprendizado em lote ocorre quando o algoritmo aprende a partir de um grande conjunto de dados de uma só vez.
Aprendizado Baseado em Instância vs Aprendizado Baseado em Modelo: Os algoritmos de aprendizado de máquina podem aprender de duas maneiras principais:
- Aprendizado Baseado em Instância: O algoritmo aprende os pontos de dados exatos do conjunto de treinamento e faz previsões com base em quão semelhante é um novo ponto de dados aos pontos de dados conhecidos.
- Aprendizado Baseado em Modelo: O algoritmo detecta padrões nos dados de treinamento e cria um modelo preditivo. Esse modelo é então usado para fazer previsões sobre novos pontos de dados.

E ah, podemos combinar cada um desses critérios. Igual na programação onde podemos usar várias libs diferentes juntas.

No livro que estou lendo, ele dá um exemplo do filtro de spam. Imagine que você já utiliza de um filtro de spam muito bom, que já faz bem o trabalho dele. Porém, alguns e-mails de spam mudaram e esse filtro já não consegue captá-los, podemos então fazer com que ele aprenda instantaneamente com a utilização de um modelo de rede neural profundo treinado a partir de exemplos novos de spam. Isso faz dele um sistema de aprendizado supervisionado online, baseado em modelos.

Agora vamos detalhar cada um dos tipos de aprendizados. Bora lá:

Aprendizado supervisionado/ Não Supervisionado 🎓

Podemos classificar aqui de acordo com a quantidade e também o tipo de supervisão que essas máquinas recebem durante seu treinamento.

Esse tipo de aprendizado se divide em quatro categorias:

Supervisionado
Não supervisionado
Semissupervisionado
Aprendizado por reforço

Aprendizado supervisionado 👩‍🏫

Nesse tipo de aprendizado, todo conjunto de dados fornecidos para treinamento do algoritmo inclui as soluções desejadas. Chamamos isso de rótulos ou labels. Voltando ao exemplo do spam, é como se ele fosse treinado com muitos exemplos de e-mails juntos e dentre esses e-mails vamos ter alguns spams. Para treinar esse tipo de sistema é necessário dar pra ele muitos exemplos de e-mails.

Em aprendizado de máquina, quando falamos em atributo, é um tipo de dado, por exemplo, os e-mails (textos), já as características assumem vários significados dependendo do contexto, geralmente corresponde ao atributo mais o seu valor. Por exemplo:

email = "Olá eu sou um e-mail!!!"

Veja alguns exemplos de algoritmos supervisionados.

K-ésimo vizinho mais próximo
Regressão linear
Regressão logística
Máquinas de vetores de suporte
Árvores de decisão e florestas aleatórias
Redes neurais

Aprendizado não supervisionado 🤖

Nesse caso, os dados de treinamento não são rotulados, ou seja, não trazem as soluções desejadas.

Você deve estar pensando: UAI, E AGORA?

Nesse caso, o sistema tenta aprender sem um “professor”, na marra!

Temos alguns tipos, sendo os mais importantes:

Clusterização
K-Means
Clusterização espacial baseada em densidade de aplicações com ruídos
Análise de cluster hierárquica
Detecção de anomalias
Floresta de isolamento
Dentre outros…

Vamos imaginar que você trabalha em uma escola dando aulas e gostaria de entender quais grupos de pessoas possuem mais semelhanças. Em nenhum momento vamos informar para o nosso algoritmo qual grupo o aluno X pertence, vai ser tarefa dele entender isso sozinho.

Outros exemplos bem comuns de aprendizado não supervisionado é a detecção de anomalia, transações incomuns no cartão pra evitar algum tipo de fraude, uma outra tarefa bem parecida seria a detecção de novidades, onde o objetivo é detectar coisas novas/instâncias novas que aparecem diferente de todas as outras que o conjunto de treinamento já possui. Vale lembrar que esse tipo de situação exige um conjunto de treinamento muito limpo.

No livro, ele dá um exemplo bem legal que é, imagine que você tenha milhares de fotos de cachorros e 1% delas representa um PUG, um algoritmo de detecção de novidade não deve tratar as novas fotos de PUG como novidade. Agora, em contrapartida disso, os algoritmos de detecção de anomalias poderiam considerar esses PUG’s tão raros e tão diferentes que provavelmente os classificaria como anomalias, o que não é nada legal…

Um outro exemplo de situação que poderíamos usar esse tipo de aprendizado, vamos imaginar que você tenha um mercadinho, e aí usamos uma regra de associação nos registros de vendas desse nosso mercadinho, com isso descobrimos que as pessoas que compram carne moída, presunto e queijo estão mais propensas a comprar também massa de lasanha, dessa forma podemos deixar a massa de lasanha mais próxima desses itens.

Aprendizado semissupervisionado 🤝

Rotular dados demanda muito tempo e dinheiro, então teremos alguns casos onde a grande quantidade de instâncias não rotuladas será bem maior que as rotuladas. E pra isso, a gente tem um nome chique: aprendizado semissupervisionado.

O livro traz um exemplo muito bom que é o Google Fotos, sabe quando ele meio que detecta as pessoas em comum, por exemplo, sabe todas as fotos que tem sua mãe, alguma amiga ou namorada e ele consegue detectar isso? Então, essa é a parte não supervisionada do algoritmo (clusterização), e aí ele fica esperando que você fale pra ele quem são essas pessoas ou seja, insira rótulos pra cada uma delas. Fazendo isso, você será capaz de pesquisar fotos da e com a pessoa a partir do seu nome.

A grande parte dos algoritmos de aprendizado semissupervisionado são combinações de algoritmos supervisionados e não supervisionados. :)

Aprendizado por Reforço 🎮

Esse aprendizado é bem diferente dos demais. Nesse contexto, temos um elemento chamado de agente, que pode observar o ambiente, selecionar e executar ações e obter recompensas em troca, ou penalidades dependendo do caso (recompensas negativas). Ele deve aprender sozinho qual é a melhor estratégia, que chamamos de política, para obter o maior número de recompensas ao longo do tempo. Essa política é o que define qual ação o agente deverá escolher quando está em uma determinada situação.

Imagem retirei desse artigo aqui

Um exemplo de agente treinando para aprender a jogar o jogo de videogame “Super Mario Bros”:

Ambiente: O mundo do jogo “Super Mario Bros”, incluindo todos os inimigos, moedas, power-ups, buracos, etc.
Agente: O algoritmo de aprendizado por reforço que está tentando aprender a jogar “Super Mario Bros”.
Ações: Os movimentos possíveis que o agente pode fazer (por exemplo, ir para a esquerda, ir para a direita, pular, etc.).
Recompensas: O agente recebe uma recompensa positiva quando coleta uma moeda, derrota um inimigo ou completa um nível. Recebe uma recompensa negativa quando é derrotado por um inimigo ou cai em um buraco.
Política: A estratégia que o agente usa para decidir qual ação tomar em um determinado estado. A política é atualizada à medida que o agente aprende com a experiência.

O objetivo do agente é aprender a política que maximiza a soma total de recompensas ao longo do tempo. Ele faz isso através de um processo de tentativa e erro, onde ele explora o ambiente (jogando o jogo e vendo os resultados) e explota o conhecimento que adquiriu (fazendo movimentos que ele acredita que levarão a recompensas altas).

Aprendizado em Batch e Online 📊

Outro critério que é usado para classificarmos os sistemas de aprendizado é se ele consegue ou não aprender de forma incremental, isto é, a partir da entrada de um fluxo de dados.

Aprendizado em Batch (por Ciclo) 🔄

Nesse caso, o sistema não consegue aprender de forma incremental, ele deve ser treinado usando todos os dados disponíveis. Isso demanda muito tempo e recurso computacional, então normalmente ele é realizado offline. Primeiro o sistema é treinado, em seguida é implementado, e como todo o treinamento/aprendizado já foi adquirido, ele roda/executa sem aprender mais nada.

E se eu quiser ter acesso a dados novos? Aí você vai precisar treinar ele novamente a partir do zero no conjunto completo de dados, ou seja, não só com os dados novos mas também com os antigos e por fim descontinua com o sistema antigo substituindo pelo novo. A parte boa disso tudo é que todo esse processo de treinamento até a disponibilização pode ser automatizado.

Vale lembrar que esse tipo de coisa leva bastante tempo, então geralmente treina-se um novo sistema apenas a cada 24 horas ou semanalmente. E ah, caso esse sistema tenha recursos limitados (memória, E/S do disco, E/S de rede etc.) fazer upload de grandes quantidades de dados e usar os inúmeros recursos para treinar por dias e horas isso com toda certeza resultaria num bug do tipo showstop. Um "bug do tipo showstop" é um erro ou falha que ocorreria se o sistema tentasse processar uma quantidade muito grande de dados de uma só vez, especialmente se os recursos do sistema fossem limitados. Isso poderia causar uma variedade de problemas, como travamentos do sistema, lentidão extrema ou até mesmo a perda de dados. Portanto, nesse caso, é melhor tentar algum algoritmo que aprende de forma incremental, processando os dados em pequenos lotes ao longo do tempo, em vez de tentar processar todos os dados de uma vez.

Aprendizado online (incremental) 📈

Nesse caso, já conseguimos treinar nosso sistema incrementalmente, ou seja, fornecendo para ele as instâncias de dados de forma sequencial, individual ou em pequenos grupos, chamados de mini-batches. ~~Traduzindo: Na calmaria!~~

Cada etapa desse aprendizado é rápida e tem um custo bem mais baixo, assim o sistema consegue aprender instantaneamente os dados novos em tempo real, assim que eles entram.

Esse tipo de aprendizado é muito bom para sistemas que recebem dados em um fluxo contínuo e que precisam se adaptar a essas mudanças rápido ou de forma independente, por exemplo: preço das ações, mudança no clima.

Ou também quando seus recursos computacionais são limitados, até porque uma vez que o seu sistema aprendeu com aqueles dados ele não precisa mais deles, logo você pode descartar. (a menos que precise daqueles dados depois). O que pode economizar bastante espaço.

Os algoritmos de aprendizagem incremental também são utilizados para treinar sistemas em grandes conjuntos de dados que não cabem na memória principal de uma máquina, chamamos isso de aprendizado out-of-core. O algoritmo faz upload de parte desses dados, executa uma etapa do treinamento neles e repete esse processo até que ele tenha sido executado em todos os dados.

Um ponto importante dos sistemas de aprendizado online é a rapidez com que eles devem se adaptar a mudanças de dados, para isso usamos a taxa de aprendizado. Por exemplo: Se você definir uma alta taxa de aprendizado, o sistema vai se adaptar rapidamente a dados novos mas também vai esquecer mais rápido os dados antigos. Agora se você definir uma taxa mais baixa de aprendizado, o sistema vai ser mais "preguiçoso", assim dizendo, ele vai aprender porém numa velocidade menor.

Um grande problema/desafio nesse tipo de aprendizado é que se fornecermos dados ruins o desempenho do sistema diminui gradualmente. Para mitigar isso, precisamos monitorar de perto o sistema e parar com o aprendizado dele imediatamente.

Aprendizado baseado em instâncias VS baseado em modelo 🔍

Outra maneira de classificar esses sistemas de aprendizado de máquina é por meio da generalização.

A maioria desses sistemas trabalha com predições. Predições, no contexto de aprendizado de máquina, referem-se à capacidade de um modelo de usar informações que ele aprendeu de um conjunto de dados de treinamento para fazer uma estimativa informada ou "previsão" sobre algo. Por exemplo, se tivermos um modelo treinado para prever o preço de uma casa com base em suas características (como tamanho, número de quartos, localização, etc.), o modelo pode "prever" o preço de uma nova casa com base nessas características.

Portanto, quando dizemos "dado uma série de exemplos de treinamento, o sistema precisa conseguir fazer predições boas o suficiente para (generalizar) exemplos que nunca viu antes", estamos dizendo que o sistema deve ser capaz de aplicar o que aprendeu com os dados de treinamento para fazer previsões precisas sobre novos dados que não faziam parte do conjunto de treinamento. A capacidade de um modelo de fazer isso - de generalizar a partir de seus dados de treinamento para novos dados - é uma medida fundamental de seu desempenho.

A ideia é que ter bons rendimentos em dados de treinamento é muito bom, mas melhor ainda é ter em instâncias de dados novas.

Temos duas abordagens principais no que se diz a respeito da generalização.

Aprendizado baseado em instâncias
Aprendizado baseado em modelo

Aprendizado baseado em instância 📚

Se pararmos para analisar nós mesmos, a forma mais simples de se aprender é memorizando algo, concorda comigo? Mas se a gente aplicar algo do tipo para um filtro de spam, por exemplo, ele apenas sinalizaria todos os e-mails idênticos/iguais em relação aos e-mails já sinalizados pelos usuários. Não é a pior solução do mundo, mas também não é a melhor, rs!

Em vez de fazer isso, podemos mudar nossa abordagem, que tal nosso filtro sinalizar também os e-mails semelhantes aos conhecidos?! Isso exige o que chamamos de medida de similaridade (SM) entre dois e-mails.

Vamos pensar o seguinte, essa medida de similaridade ela poderia conter o número de palavras que eles têm em comum, dessa forma o sistema marcaria um e-mail como spam se tivesse muitas palavras em comum com um e-mail spam conhecido.

Para isso damos o nome de aprendizado baseado em instância: o sistema aprende os exemplos usando a memorização e depois generaliza para novos casos e para isso ele usa uma medida de similaridade que serve basicamente para comparar com os outros exemplos.

Aprendizado baseado em modelo 🛠️

Aqui utilizamos algoritmos que podem aprender a partir de dados e fazer previsões ou decisões.

Esses modelos são “treinados” usando conjuntos de dados históricos, onde eles identificam padrões e relações. Uma vez treinados, eles podem ser aplicados a novos dados para prever resultados.

Voltando ao nosso conjunto de dados sobre casas e seus preços. As características das casas (como tamanho, número de quartos, localização) são as entradas do modelo, e os preços são as saídas que queremos prever.

Coleta de Dados: Você reúne dados de várias casas vendidas recentemente.
Treinamento do Modelo: Você escolhe um modelo de aprendizado de máquina, como a regressão linear, e “ensina” ao modelo como o preço das casas se relaciona com suas características.
Teste do Modelo: Depois de treinado, você testa o modelo com dados de casas cujos preços você já conhece para ver se ele pode prever corretamente.
Uso do Modelo: Uma vez que o modelo está bem ajustado, você pode usá-lo para estimar o preço de uma casa nova no mercado, baseando-se nas suas características.

O modelo aprendeu a relação entre as características das casas e seus preços e agora pode fazer previsões informadas sobre novas casas.

Isso é aprendizado de máquina baseado em modelo. Ele é útil porque pode nos ajudar a tomar decisões baseadas em dados e experiências passadas.~~(queria aplicar isso na minha vida real)~~

Vou deixar o link do GitHub onde estou colocando códigos e também explicações desses meus últimos aprendizados nesse mundo muito doido de Machine Learning haha!

Qualquer duvida, vocês já sabem! Podem me perturbar.

bjs bjs e até a próxima 💟

Meus Últimos Meses Estudando Análise de Dados 🎲

Ana Laura — Mon, 08 Apr 2024 06:44:24 +0000

E aí, cês tão bem? 💟

Recentemente, eu comecei a estudar sobre análise de dados e vim aqui falar um pouco de como está sendo minha experiência.

O objetivo desse post aqui é trazer um pouco da minha percepção sobre aprender análise de dados, tendo tido contato com programação, trabalhando com desenvolvimento front-end e desenvolvimento mobile. Como tem sido a minha experiência nesses últimos 3 meses me dedicando a estudar e finalizando um estudo de caso.

O curso que fiz foi esse aqui, recomendo bastante. Achei bem didático e com toda certeza aprendi muita coisa.

Fazendo uma ponte entre os conhecimentos que eu já tinha e análise de dados, eu diria que tem muitas coisas que são parecidas, veja bem, parecidas, não iguais. Resolver problemas é um exemplo de algo que a gente já lida no nosso dia a dia como pessoa programadora. Então, toda essa parte do pensamento lógico de: fazer perguntas, de dividir um problema em várias partes. Isso também faz muita parte da análise de dados.

Então, foi muito daora poder entender isso e pensar:

po, isso eu já sabia!!

Outro tópico super importante: Comunicação. O curso tem um módulo voltado só para parte de comunicação. Saber se comunicar tanto com time como na hora de propor ideias, tirar dúvidas, enfim, se comunicar é e sempre será importante em todas as áreas.

A parte que mais gostei, com toda a certeza, foi a parte de limpar dados, mesclar dados, analisar os dados e depois responder às perguntas que foram feitas com base nos dados.

No curso, pude fazer toda parte de limpeza e análise utilizando a linguagem R. Confesso que achei bem diferente do que estava habituada, já que trabalhei com javascript, python e kotlin, que são linguagens bem diferentes. R é bem matemático, eu diria.

É muito legal você pegar um conjunto de dados, entender a história daqueles dados e propor soluções baseadas no que foi pedido, no que foi proposto. Eu pude entender também a importância dos dados e como eles são utilizados, como eles fazem parte do nosso dia a dia e como a cada dia que passa temos mais dados sendo criados.

O meu projeto final do curso/estudo de caso tinham 3 trilhas a serem seguidas, mas escolhi a trilha onde tinha uma empresa fictícia, resumidamente de aluguéis de bicicletas, e eu tinha que fazer uma análise de alguns dados desses clientes e trazer algumas soluções.

Vou deixar aqui o link do repositório no GitHub que explica com mais detalhes o que é esse projeto e lá já tem o link para a apresentação do projeto também.

Qualquer duvida, vocês já sabem! Podem me perturbar.

bjs bjs e até a próxima 💟

Complexidade de Espaço dos Algoritmos

Ana Laura — Mon, 15 Jan 2024 23:02:22 +0000

Eai, cês tão bem?

Nesse meu post falei sobre complexidade de tempo dos algoritmos e hoje pra finalizarmos esse tópico de complexidades, irei falar um pouco sobre a complexidade de espaço. Bora lá? 🌚

ps: Usarei python para explicar alguns conceitos

O que é complexidade de espaço 🪐

No post que citei acima falei sobre a complexidade de tempo, que, em resumo, diz respeito à "quantidade de tempo" que um algoritmo precisa para executar. Agora, vamos de falar sobre a complexidade de espaço, que se refere à quantidade de memória necessária para executar um algoritmo. Em termos simples, a complexidade de espaço é expressa considerando a quantidade de memória adicional utilizada em relação ao tamanho da entrada fornecida ao nosso algoritmo.

👀 Dê uma olhada no código abaixo:

def doubled_number(numbers):
    result = []
    for number in numbers:
        result.append(number * 2)
    return result

O que fazemos aqui é percorrer cada elemento do array passado como parâmetro, multiplicá-lo por dois e adicioná-lo a um novo array chamado result.

Podemos concluir, então, que se eu passar um array com 100 números, ele me retornará um novo array com 100 números. Da mesma forma, se eu passar um array com 10 elementos, o resultado será um novo array com 10 elementos.

"Então, Ana, qual conclusão tiramos disso tudo?" Quanto mais a entrada cresce, a saída também cresce e, consequentemente, o espaço ocupado por ela também aumenta. Isso implica dizer que a Complexidade de Espaço é dada por O(n).

Vamos ver outro exemplo agora:

def sum_list(numbers):
    sum = 0
    for number in numbers:
        sum += numero
    return sum

A função acima percorre uma lista de números, soma todos eles e, no final, retorna o resultado dessa soma.

A complexidade de espaço para essa função é O(1), ou seja, constante. Isso ocorre porque a função utiliza apenas uma variável adicional, sum, para armazenar todo o resultado acumulado.

Independentemente do tamanho do array de entrada, a quantidade de espaço necessária para a variável soma permanece constante.

De forma prática, a complexidade de espaço O(1) significa que o consumo de memória da função não aumenta com o tamanho do array. Mesmo se o array tiver milhões de elementos, a função ainda exigirá a mesma quantidade de espaço adicional para a variável sum.

👀 E pra finalizarmos vale super a pena dar uma olhada neste site aqui, que mostra a complexidade em um gráfico e pode ajudar a entender, especialmente em relação à notação Big O, utilizada para descrever a eficiência de algoritmos em termos de tempo e espaço. Se tiver dúvidas sobre isso, falei mais a respeito neste meu artigo aqui.

Espero ter ajudado! 😊

bjs bjs e até a próxima 💟

Entendendo RecyclerView de Uma Vez Por Todas

Ana Laura — Mon, 04 Dec 2023 16:05:38 +0000

E aí, cês tão bem?

Nos últimos dias, tenho me dedicado a estudar Android e me deparei com o seguinte desafio: entender o RecyclerView.

Então, este artigo é para você que não está entendendo muito bem como isso funciona e eu, como uma boa amante de formas diferentes de explicar coisas complexas, cá estou.

Usando RecyclerView para organizar uma festa 🥳

Para te ajudar a entender, vou precisar que você comece imaginando que vamos dar uma festa de comidas típicas do meu estado, Minas Gerais, e para isso, precisamos definir algumas coisas. Saiba que o local da festa já foi escolhido.

Precisamos decidir como organizar as mesas e servir os pratos típicos. Para isso, pensei em nos organizarmos da seguinte forma:

Precisamos definir no espaço principal onde iremos organizar as mesas e cadeiras para nossos convidados. Temos que distribuir tudo perfeitamente para que a festa seja agradável e todos possam aproveitar.
Temos um cardápio com todos os pratos que queremos servir. Vamos precisar de um chef/assistente para nos ajudar a decidir quais pratos do cardápio incluir na festa e também ajudar a organizá-los nos suportes adequados. Se decidirmos adicionar um novo prato ao cardápio, nosso Chef nos ajuda a garantir que tenhamos um suporte certo para esse prato. Ele vai gerenciar essa relação entre o cardápio e os suportes, facilitando a escolha e exibição dos pratos na festa.
Agora, pense nos pratos típicos que queremos servir. Vamos precisar de um suporte para cada prato. Cada suporte será designado para segurar um prato específico, garantindo que quando decidirmos servir algo, já temos um lugar definido para isso. Sem o suporte, teríamos que procurar constantemente onde colocar ou onde está cada prato na mesa, e isso deixaria o atendimento aos convidados menos fluído.
Pensar na disposição das mesas. Precisamos contratar um planejador de festas. Ele vai nos ajudar a decidir se queremos organizar as mesas em fileiras, círculos ou qualquer outra forma que torne a festa mais aconchegante. Se decidirmos que queremos mesas em círculo, o planejador organiza automaticamente as mesas dessa forma. Ele ajuda a criar o layout ideal para que todos os convidados possam aproveitar a festa da melhor maneira possível.

Resumindo, temos que:

Definir o espaço principal da festa;
Suporte especial para cada prato;
Assistente que organiza o cardápio nos suportes;
Planejador que decide como organizar as mesas.

E agora você deve estar pensando, mas o que isso tem a ver com RecyclerView?

Festas e RecyclerView, acredito eu, que não tenham muitas coisas em comum. Ouso dizer que são até opostos demais 😅, mas vamos entender um pouco mais onde quero chegar com essa comparação:

O RecyclerView será o nosso espaço principal da festa, o ViewHolder é o suporte especial para cada prato, o Adapter é o assistente que organiza o cardápio nos suportes, e o LayoutManager é o planejador que decide como organizar as mesas. Juntos, eles tornam a festa organizada e garantem que todos desfrutem da experiência.

Agora que entendemos um pouco mais sobre o que é o que, vamos para o código!

Código e um pouco de teoria 💻

O RecyclerView é tipo um mestre da reciclagem na tela do seu app. Sabe quando você olha para uma lista enorme no celular e pensa "poxa, será que precisava carregar tudo de uma vez?" - é aí que o RecyclerView entra.

Imagina que você está criando uma lista que não para de crescer, tipo uma lista de mensagens de chat. O RecyclerView é como o chefão dessa operação. Ele garante que só os itens que estão aparecendo na tela sejam criados, economizando bateria e tornando tudo mais rápido.

A equipe do RecyclerView inclui alguns membros importantes como já falamos anteriormente:

RecyclerView: Funciona como o componente visual responsável por posicionar e exibir a lista na tela.
ViewHolder: Serve como a referência para cada item presente na lista, desempenhando um papel crucial na reciclagem de componentes.
Adapter: Responsável por mapear os dados do modelo para cada item exibido na lista, garantindo uma conexão eficiente entre os dados e a interface.
LayoutManager: É o componente encarregado de gerenciar a disposição dos elementos na RecyclerView, proporcionando controle sobre o layout da lista.

Começamos criando nosso espaço principal, ou seja, o RecyclerView. Podemos adicioná-lo diretamente no XML ou pelo editor de layout:

<androidx.recyclerview.widget.RecyclerView  
    android:id="@+id/recyclerView"  
    android:layout_width="match_parent"  
    android:layout_height="match_parent" />

Agora podemos buscá-lo no nosso código Kotlin:

val recyclerView: RecyclerView = findViewById(R.id.recyclerView)

E já ta pronto? Ainda não!

Primeiro vamos precisar vincular nosso RecyclerView a um LayoutManager, e depois:

Vamos precisar de um conjunto de dados, depois precisamos;
Vincular o conjunto de dados a uma representação visual com o ViewHolder e, por fim;.
Vincular este dados ao RecyclerView utilizando um Adapter;

O LayoutManager é o cara responsável por organizar os itens visuais dentro do nosso RecyclerView, definindo também o critério de quando os itens devem ser "reciclados".

Para começar vamos usar o LinearLayoutManager, para listas verticais e simples.

recyclerView.layoutManager = LinearLayoutManager(this)

Agora, vamos focar nos itens da nossa lista!

Vou criar um conjunto de dados de comidas. Então, primeiro, criamos a classe Food. Lembrando que esta classe será um modelo de dados e para isso precisamos criá-la como uma data class.

data class Food(val name: String, val chef: String)

Depois temos que criar uma lista usando nosso modelo:

val FoodList = listOf(  
    Food("Feijão tropeiro", "Ana Laura"),  
    Food("Frango caipira", "Julio"),  
    Food("Pamonha", "Gabriel"),  
)

Agora, vamos para a parte de vincular o conjunto de dados a uma representação visual com o ViewHolder.

Os ViewHolders atuam como um cache para elementos visuais, armazenando referências às views no layout para otimizar a atualização da interface gráfica. (Lembre-se que estamos falando de dispositivos móveis, ou seja a capacidade é muito menor que de um computador)

São elementos que serão exibidos, exigindo a criação de uma classe ViewHolder que estende RecyclerView.ViewHolder. Esta classe recebe um parâmetro por padrão que é o itemView e também deve ter um método "bind", responsável por vincular dados, associando elementos visuais aos itens do conjunto de dados.

class FoodViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {  
    fun bind(food: Food) {  
        itemView.findViewById<TextView>(R.id.foodName).text = food.name  
        itemView.findViewById<TextView>(R.id.foodChef).text = food.chef  
    }  
}

Ah, perceba que ali a gente já selecionou esses dois ID's foodName e foodChef, mas ainda não os criamos no nosso XML. Vamos conversar sobre isso:

Agora, o que precisamos fazer é criar o layout do nosso ViewHolder, ou seja, qual será o layout de cada item do nosso RecyclerView.

Este layout é criado da mesma forma que criamos qualquer outra Activity, criando um xml de layout com o nome de food_item.xml.

<?xml version="1.0" encoding="utf-8"?>  
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    android:layout_width="match_parent"  
    android:layout_height="wrap_content"  
    android:orientation="vertical"  
    android:padding="10dp">  

    <TextView        android:id="@+id/foodName"  
        android:layout_width="match_parent"  
        android:layout_height="wrap_content"  
        android:textSize="20sp"  
        android:textStyle="bold" />  

    <TextView        android:id="@+id/foodChef"  
        android:layout_width="match_parent"  
        android:layout_height="wrap_content"  
        android:textSize="15sp" />  
</LinearLayout>

Agora que estabelecemos nosso ViewHolder, avançamos para a construção do Adapter. Nesse processo, vamos sobrescrever os métodos necessários para associar os dados do tipo Food ao nosso layout.

Imagine o Adapter como um intermediário que conecta nossos dados de comida ao layout.

Para começar, criamos a classe FoodAdapter, que recebe uma lista de objetos Food e estende a classe RecyclerView.Adapter<FoodViewHolder>.

Esta classe é como um organizador que recebe uma lista de comidas, que chamamos de "conjunto de dados", e ela é especializada para trabalhar com o nosso ViewHolder de comidas, o FoodViewHolder. É basicamente uma maneira de dizer ao sistema como os dados (comidas) devem ser exibidos no layout.

class FoodAdapter(private val foods: List<Food>) : RecyclerView.Adapter<FoodViewHolder>() {

}

Antes da gente continuar, preciso te explicar o que é o onCreateViewHolder(): Este método é acionado durante a criação do ViewHolder e é responsável por gerar os elementos visuais para cada item da lista.

O termo utilizado para descrever esse processo é "Inflate".
Em outras palavras, o método realiza a criação visual de cada elemento da lista, preparando-os para serem exibidos no RecyclerView

override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): FoodViewHolder { 
    /*estamos criando um Inflater, e gerando um inflate, que é o método que cria os elementos, tendo como primeiro parâmetro o layout do elemento que deve ser replicado. Em nosso caso, o food_item */*
    val view = LayoutInflater.from(parent.context).inflate(R.layout.food_item, parent, false)  
    return FoodViewHolder(view)  
}

👀ps: isso será um método da classe FoodAdapter

Agora, precisamos sobrescrever o método de vínculo onBindViewHolder(). Ele recebe como parâmetro o nosso ViewHolder de comidas e chama o nosso método bind() para cada um de nossos elementos de lista. O método bind é uma convenção usada para associar os dados de um item específico do conjunto de dados ao ViewHolder correspondente.

override fun onBindViewHolder(holder: FoodViewHolder, position: Int) {  

    val food = foods[position]  

    holder.bind(food)  
}

👀ps: Lembra que lá na nossa classe FoodViewHolder tem um método bind, o que será que ele faz mesmo? xD

A classe FoodAdapter herda de RecyclerView.Adapter e implementa alguns métodos abstratos necessários, como getItemCount() que retorna a quantidade de itens.

override fun getItemCount(): Int {  
    return foods.size  
}

Agora que já fizemos tudo isso, podemos vincular o Adapter ao RecyclerView que criamos lá atrás:

// essa variável aqui foi criada lá atrás
val recyclerView: RecyclerView = findViewById(R.id.recyclerView)

//criando o Adapter a partir da nossa lista de comidas
val adapter = FoodAdapter(foodList)

//vinculando o adapter ao RecyclerView
recyclerView.adapter = adapter

E fim, temos uma lista criada 🥰

Eu criei um repositório no github com o código e ~~com um desenho não muito bom~~ que eu fiz pra ajudar entender.

Se você leu até o final reage com um 💟 se não, não precisa reagir :(.

bjs bjs e até a próxima

Como Foi O Front In Floripa? 🤔

Ana Laura — Tue, 28 Nov 2023 15:10:50 +0000

Eai, como cês tão?

Hoje vim aqui pra contar um pouco da minha experiência no Front In Floripa. Modéstia parte, eu estava em ótimas companhias, uma delas era o @1cadumagalhaes, a Lys ambos criam conteúdos tech e o Anderson que é um outro amigo dev!!! Só gente BOA DEMAIS.

Então bora lá, como foi o Front In Floripa?

Networking 😎

Esses eventos são bons para fazer o famoso networking. Trocar uma ideia com o pessoal que está lá representando empresas parceiras, participantes do evento ou as pessoas que apresentaram alguma palestra, com toda certeza agrega e muito.

Lá pude conhecer algumas pessoas e trocar bastante experiência e aprendizado. Entre essas pessoas conversei com duas pessoas da Stone. Ambas muito queridas e atenciosas. Uma delas é desenvolvedora front-end, e a outra Tech Recruiter. Foi uma experiência muito legal, pois elas me forneceram várias informações sobre a Stone, como o funcionamento do processo seletivo da empresa, as tecnologias que utilizam (stacks), e falaram um pouco sobre o time técnico. Agradeço muito, meninas; sem dúvida, nossa conversa foi um diferencial no meu dia.

Sempre gostei de me comunicar e trocar experiência/ideia com outras pessoas e isso foi muito importante quando eu decidi entrar na área de tecnologia. Conversar com outras pessoas é e sempre será muito bom.
Essa troca que existe foi e ainda é fundamental na minha trajetória.

Então apenas reforçando, façam networking! 😌

Palestra - Conteúdos 🤖

Cheguei bem na hora que o Gabriel Donadel estava falando sobre React Native. A palestra foi tão boa que sai de lá com vontade e curiosidade de aprender mais sobre. Ele falou sobre a importância de aplicações "universais" aplicações que podem ser executadas em diferentes plataformas de maneira eficiente, sem a necessidade de reescrever o código para cada sistema operacional específico. Ele também falou sobre a Expo que é uma plataforma de código aberto para criar aplicativos nativos universais com React. Expo funciona em Android, iOS e na web. Se quiser saber mais sobre ta aqui o link.

Assisti também a palestra da Fernanda Kipper ela falou bastante sobre a importância da padronização para a melhora de processos em empresas grandes. Trouxe todos os prós e contras desse tipo de decisão e isso foi super legal. Pude aprender bastante sobre como funciona alguns processos em empresas com times técnicos que são enormes.

O Paulo Cesar Prado trouxe um assunto super legal e importante que são Testes A/B. Ele trouxe algumas experiência vividas na Globo em relação a esse tipo de teste, o que foi bem interessante. Também falou dos erros mais comuns ao realizar esse tipo de teste, como por exemplo: Definir métricas ruins, executar vários testes, etc. Gostei demais da palestra. Eu tinha um conhecimento bem superficial sobre o assunto, então foi um ótimo momento para aprender um pouco mais.

Code in The Dark 😈

Dando contexto sobre o que é o tal do Code in The Dark, de forma resumida é literalmente codar no escuro 😅. Você precisa desenvolver um layout proposto por eles, sem ver o que tá sendo feito ou seja, vai codando ali sem ver o resultado.

O role é fazer tudo usando apenas HTML e CSS. E ah! sem autocomplete (isso me pegou DEMAIS rs), a dúvida era: A tag style fica dentro da tag head, né?

Foi um momento legal demais, super indico viver essa experiência se um dia tiver oportunidade. Confesso que da uma certa insegurança mas ah, vai assim mesmo que é legal!

Aqui tem mais informação sobre e o editor/IDE deles é open source, vale a pena dar uma olhada, rola até de treinar ein rs :)

Pessoas lindas e legais que me acompanham aqui, queria compartilhar um pouco como foi o Front in Floripa, e pra não perder o costume:

Se você leu até o final reage com um 💟 se não, não precisa reagir :(.

bjs bjs e até a próxima.

Tentando Conquistar o Mundo da Programação: Dicas para Resolver Problemas

Ana Laura — Thu, 02 Nov 2023 05:28:59 +0000

Eai, cês tão bem?

Eu gosto muito de escrever sobre coisas que acabo vivenciando e pensando: E se eu fizer um post pra falar disso?

No meu trabalho, me deparo frequentemente com desafios que são bem comuns para quem está começando a explorar o mundo da programação. São aqueles obstáculos típicos que, de vez em quando, nos deixam um tanto desanimados na nossa jornada nesse universo meio "maluco" que é a programação.

Então, eu tô aqui hoje para conversarmos um pouco sobre essas situações e, quem sabe, eu consiga te dar uma mãozinha nessa jornada. :)

Dicas e Lembretes Essenciais 📝

É perfeitamente normal ter dúvidas, seja quando você está aprendendo ou mesmo depois de algum tempo. Ter dúvidas simplesmente significa que existe algum conhecimento que ainda não foi adquirido. Portanto, não hesite em fazer perguntas e buscar esclarecimentos sempre que necessário.
A aprendizagem muitas vezes requer repetição. Ver um conteúdo uma vez, duas vezes, ou até mesmo por vários dias seguidos não garante um conhecimento sólido sobre o assunto. É importante continuar praticando e revisando.
Evite comparar sua velocidade de aprendizado com a de outras pessoas, acredite, não vale a pena e só gera frustração. Cada um tem seu próprio ritmo de aprendizado, e o importante é progredir de acordo com suas próprias metas e necessidades.

"Travei" num desafio/problema. E agora? 🥶

Para tornar minha missão de ajudar a resolver seu desafio sem nem mesmo ver seu código mais eficaz, vou começar fazendo algumas perguntas:

Como você iniciou a resolução desse problema? ❓

Comecei a codar sem dividir em partes e estou perdido, sem saber onde está o problema. 🤯
Dividi em partes e estou enfrentando um problema em uma etapa específica. 🤧

Se você escolheu a primeira alternativa, vamos começar dividindo seu problema em partes. Essa prática é muito útil; eu pessoalmente a utilizo muito. Pego uma folha de papel e escrevo tudo o que meu programa deveria fazer, só depois parto para o código.

Para ser mais assertiva, vou dar um exemplo de como podemos fazer isso:

Desafio: Calcular a Média de uma Lista de Números 🤓

Dividindo meu problema:

Definir o Objetivo: O objetivo é calcular a média de uma lista de números.

Entrada de Dados: Identificar a entrada necessária para o problema. Neste caso, é uma lista de números.

Processamento dos Dados: Dividir o problema em etapas menores:

Inicializar uma variável total como 0 para rastrear a soma dos números.
Usar um loop para percorrer a lista de números.
Adicionar cada número à variável total.
Calcular a média dividindo o total pelo número de elementos na lista.
Retornar o valor da média.

Saída de Dados: No final, você obtém a média dos números e a imprime na tela.

Aqui nós dividimos o problema em etapas menores e ajuda a organizar a resolução do problema de maneira mais eficaz. Cada etapa lida com uma parte específica do problema, tornando-o mais "gerenciável" e fácil de implementar.

Isso foi uma das formas que eu pensei em como resolver esse desafio, mas existem outras formas. :)

Tenta resolver o desafio e depois, se quiser me conta como foi!

Se você respondeu a segunda alternativa, vem comigo que eu vou tentar te ajudar:

Compreenda o problema: Certifique-se de entender completamente o problema antes de começar a escrever código.
Divida em partes: Divida o novo problema em partes menores e bem definidas.
Faça perguntas: Se estiver travado em uma parte, faça perguntas específicas para entender a dificuldade.
Pesquisa: Busque em recursos como documentação, tutoriais, para obter informações, use alguma das perguntas feitas no tópico acima para pesquisar no Google ou até mesmo usar nosso amigo chat GPT.
Pseudocódigo: Crie um pseudocódigo ou fluxograma para visualizar a lógica da solução.
Revisão: Explique sua abordagem lógica a alguém para identificar problemas, isso me ajuda MUITO. Eu converso até meio sozinha as vezes, rs. 😅
Testes: À medida que avança na resolução do problema, teste partes individuais do seu código e, sempre que possível, exiba as saídas na tela. Isso ajuda você verificar se cada parte do código funciona conforme o esperado e a identificar problemas mais cedo. Isso acontece bastante, quando achamos que uma variável está retornando um valor, mas na realidade, está nos surpreendendo com outro.
Depuração: Utilize ferramentas de depuração para rastrear o comportamento do programa.
Seja paciente: Todos enfrentam desafios, seja persistente e paciente.
Aprenda com os erros: Veja os desafios como oportunidades de aprendizado e crescimento profissional.

O livro 'Fomos Maus Alunos' traz uma reflexão muito interessante sobre o erro. Vou deixar um trecho desse livro aqui para finalizar este conteúdo. ❤️

Faz parte da aventura chegar e dizer: Estava errado. Vou dar um exemplo. Uma pessoa se dedica à exploração de cavernas. Há uma bifurcação. Não sabe qual delas seguir. Assim, vai na sorte. Depois de muito caminhar, chega a um beco sem saída. Aquele corredor da caverna não leva a lugar algum. Ela volta e escreve à entrada da bifurcação: Beco sem saída. Essa informação é importante? É conhecimento? Importantíssima para os outros que virão depois dela. Conhecimento de que aquele caminho vai dar em nada. Aquelas palavras lhes pouparão trabalho. Um doutorando se propõe fazer uma pesquisa. Pesquisa durante cinco anos. Ao final de cinco anos, verifica que todas as suas hipóteses estavam erradas. Para mim seria perfeitamente válido que ele escrevesse, como conclusão de sua tese: Depois de cinco anos de pesquisa verifiquei que todas as hipóteses estavam erradas. Isso é conhecimento.

Até a próxima e bons estudos!

~~Se você leu até o final reage com um 💟 se não, não precisa reagir :(.~~

Comece Por Aqui: Conceitos Básicos Kotlin Parte I

Ana Laura — Sun, 29 Oct 2023 00:31:30 +0000

💟 Eai, como cês tão?

Essa é a primeira parte de um conteúdo que será dividido em duas partes, onde exploraremos a documentação do Kotlin.

Antes de criar este conteúdo, pesquisei como poderia contribuir com a tradução da documentação oficial, mas em resumo, eles incentivam traduções, porém a hospedagem e publicação da tradução são de responsabilidade do tradutor, e ela não será incorporada ao site oficial da linguagem Kotlin. Mais informações, aqui

Ressalto a importância de também consultar a documentação oficial, uma vez que essa fonte é regularmente atualizada e abriga uma vasta quantidade de informações detalhadas. Além disso, a documentação do Kotlin é maravilhosa.

A proposta dessa primeira parte é falar sobre os fundamentos do Kotlin, abordando a parte inicial e básica.

Bônus: Ao final, compartilharei alguns recursos da IDE IntelliJ que podem ajudar ainda mais na sua aprendizagem sobre a linguagem. 🤯

Ana, sobre o que vamos falar? Nesta primeira parte, vou abordar:

Por que Kotlin?
Variáveis
Tipos Básicos
Coleções
Fluxo de Controle
Funções
Bônus

Por que Kotlin?

Kotlin é uma linguagem de programação de código aberto desenvolvida pela JetBrains.

É projetada para ser compatível com o Java e é popular para o desenvolvimento de aplicativos Android.
É concisa, segura, legível e expressiva.
Resolve limitações do Java e é executada na JVM.
Destaca-se por sua segurança em relação a referências nulas.
Permite a interoperabilidade com o Java e é compatível com bibliotecas existentes.
Ampla adoção na comunidade de desenvolvimento, especialmente para aplicativos Android.

Meu primeiro "Hello, World" em Kotlin

💀 Olha só, para evitar possíveis "maldições" - já que há uma lenda que afirma que começar o aprendizado sem um simples "Hello, World!" pode dificultar a compreensão dos princípios básicos - vamos iniciar com um "Hello World" em Kotlin. ~~Não que eu acredite, mas vai que né~~

E para isso, podemos utilizar o "playground" do Kotlin, que permite que você crie e execute códigos por lá. Legal, né?

fun main() {
    println("Hello, World!")
}

Em Kotlin a palavra-chave fun é usada para declarar uma função.
A função main() é onde o seu programa começa.
O corpo de uma função é escrito entre chaves {}.
As funções println() e print() imprimem seus argumentos na saída padrão.

~~Me lembrou um pouco Python ou eu to doida?! 😅~~

Variáveis

🔹 Todo programa precisa ser capaz de armazenar dados, e as variáveis nos ajudam a fazer isso. Em Kotlin, você pode declarar:

Variáveis que não podem ser mudadas, utilizando val.
Variáveis mutáveis, ou seja, que podem ser alteradas, utilizando var.
Para atribuir um valor, usamos o operador de atribuição =.

val age = 25 //imutável

var age = 25//mutável

As variáveis podem ser declaradas no início do seu programa, fora da função main(), por exemplo. Quando você as declara dessa forma, elas são consideradas variáveis globais.

E aqui segue a recomendação de sempre declararmos variáveis utilizando val. Utilizar var somente se necessário.

Template string

🔹 Sabe aqueles momentos em que precisamos adicionar uma ou mais variáveis em uma string? Então, é ai que as templates de strings podem ser bem úteis.

Vale lembrar que em Kotlin, um valor de string é uma sequência de caracteres entre aspas duplas ". Por exemplo:

val name = "Ana Laura Reis"

As templates strings sempre começam com um $. Exemplo:

val age = 25

val name = "Ana Laura Reis"

val template = "My name is $name and I am $age years old"

Nesse exemplo, $name será substituído pelo valor da variável name e $age pelo valor da variável age.

Se quiser saber mais sobre template string, dê uma olhada aqui.

Tipos básicos

🔹 Os tipos são importantes para entendermos o que estamos armazenando em uma variável ou até mesmo quais funções e propriedades aquele dado possui.

Nos exemplos acima já foi possível vermos dois tipos, int e string. A variável name é do tipo string e age do tipo int.

O Kotlin possui a habilidade de deduzir o tipo de dados de uma variável e isso é chamado de inferência de tipo.

Quando você atribui um valor inteiro à variável age, o Kotlin infere que age possui um tipo de dado numérico, especificamente do tipo Int.

Tá Ana, e o que isso significa na prática? Isso significa que o compilador "sabe" que você pode realizar operações aritméticas, como adição, subtração, multiplicação ou divisão, com a variável age.

Essa inferência de tipo é uma das características poderosas do Kotlin, pois permite que você escreva código de forma concisa e legível, sem precisar especificar explicitamente o tipo de dados a todo momento.

No geral, Kotlin possui os seguintes tipos básicos:

Tipo	Descrição	Exemplo
`Int`	Números inteiros	`42`
`Long`	Números inteiros longos	`1234567890L`
`Float`	Números de ponto flutuante de precisão simples	`3.14f`
`Double`	Números de ponto flutuante de dupla precisão	`3.14`
`Char`	Caractere	`'a'`
`String`	Sequência de caracteres	`"Olá, mundo!"`
`Boolean`	Valor lógico (verdadeiro ou falso)	`true` ou `false`

Para saber mais sobre tipos básicos consulte a documentação.

E se eu quiser iniciar uma variável sem necessariamente atribuir um valor? 🤔

// variável declarada sem inicialização/sem valor atribuído
val age : Int

// variável inicializada/atribuindo o valor 25 à variável age
val age = 25

// declarando tipo e atribuindo valor
val name : String = "Ana"

Acho que o exemplo conseguiu explicar bem!

🧠 Agora faça os exercícios para praticar o que aprendemos até aqui

Coleções

🔹 Lembra das listas, arrays? Os famosos tipos de dados que utilizamos para agrupar uma quantidade n de dados.

Em Kotlin temos algumas estruturas de dados para agrupar itens:

Coleção	Descrição
`List`	Coleção ordenada de elementos, pode conter duplicatas. Permite acesso por índices.
`Set`	Coleção não ordenada de elementos únicos.
`Map`	Coleção de pares chave-valor, onde cada chave é única.
`ArrayList`	Implementação modificável de uma lista usando um array.
`LinkedList`	Implementação modificável de uma lista usando uma estrutura de lista encadeada.
`HashSet`	Implementação de um conjunto usando uma tabela de dispersão para armazenar elementos únicos.
`TreeSet`	Implementação de um conjunto usando uma estrutura de árvore balanceada para armazenar elementos únicos, mantendo a ordem.
`HashMap`	Implementação de um mapa usando uma tabela de dispersão para armazenar pares chave-valor, com chaves únicas.
`TreeMap`	Implementação de um mapa usando uma estrutura de árvore balanceada para armazenar pares chave-valor, mantendo a ordem.

Falaremos mais detalhadamente sobre:

List
Set
Map

Para saber mais sobre os outros tipo, consulte a documentação oficial ~~(ou comenta aqui, quem sabe crio um conteúdo sobre isso)~~

1. List

Podemos ter:

Uma coleção ordenada de elementos.
Permite elementos duplicados.
Os elementos podem ser acessados por índices.

🔹 Para criar uma lista que não pode ser modificada (List), você utiliza a função listOf() e se quiser criar uma lista que pode ser modificada (MutableList), você utiliza a função mutableListOf().

Caso queira dizer o tipo dos elementos da sua lista, você pode fazer isso usando <>, vou mostrar alguns exemplos abaixo:

// Lista imutável
val listImmutable = listOf("Ana", "Gabriel", "Maria")

//Lista mutável e tipada

val listMutable:  MutableList<String> = mutableListOf("Ana", "Gabriel", "Maria")

Podemos acessar qualquer elemento da lista através de seu índice:

val favoriteMusics = lisOf("Rap", "Funk", "Pagode")

favoriteMusics[0] // acessando o item "Rap" da minha lista

Podemos acessar o primeiro e o último elemento de uma lista utilizando as funções:

.first()
.last()

Os dois exemplos acima são funções de extensão. Em resumo, os métodos são ações diretamente ligadas a uma classe, enquanto as funções de extensão são novas ações que você pode adicionar a uma classe existente sem modificar a classe original. Eles permitem estender a funcionalidade da classe de uma forma mais flexível.

Para entender melhor sobre essas funções dê uma olhada aqui.

Outra coisa legal que conseguimos pra fazer é verificar se existe um item em uma lista utilizando in.

println("Rap" in favoriteMusics)

Também podemos adicionar e remover itens de uma lista, utilizando o .add() e .remove()

// Adiciona "Samba" no final da lista

favoriteMusics.add("Samba")

// Remove "Rap" da lista

favoriteMusics.remove("Rap")

2. Set

Uma coleção que não mantém uma ordem específica.
Como os conjuntos não são ordenados, você não consegue acessar um item através do seu índice.
Contém apenas elementos únicos, não permitindo duplicatas.

Assim como nas listas também podemos criar um set mutável ou imutável:

// Imutável 

val fruits = setOf("banana", "morango", "pêra")

//Mutável

val newFruits: MutableSet<String> = mutableSetOf("banana", "morango", "pêra", "maçã")

Ah algo interessante é que o set contêm apenas elementos únicos, todo item duplicado é descartado. 👀

Também conseguimos usar as funções add e remove para adicionarmos e removermos algum item do nosso set, caso ele seja mutável.

3. Map

Uma coleção de pares chave-valor, onde cada chave é única.
As chaves são usadas para acessar os valores associados.
Não mantém uma ordem específica para os pares chave-valor.

🔹 Podemos imaginar um map como um menu de comida. Você pode encontrar o preço (valor), encontrando a comida (chave) que deseja comer. Os mapas são úteis se você quiser procurar um valor sem usar um índice numerado, como em uma lista.

// Imutável 
val menu = mapOf("coxinha" to 2, "coquinha" to 3, "batata" to 10)

// Isso aqui nos retorna: {coxinha=2, coquinha=3, batata=10}

//Mutável 

val newMenu :  MutableMap<String, Int> = mapOf("esfirra" to 2, "coquinha" to 3, "brigadeiro" to 10)

Para acessar um valor em um Map, podemos utilizar colchetes [] com sua chave, vamos supor que eu queria acessar o valor brigadeiro do map acima.

newMenu["brigadeiro"]

Aqui também conseguimos usar as funções add e remove.😉

Se quisermos verificar se uma chave específica já existe em um map, utilizamos a função .containsKey(). Exemplo:

novoMenu.containsKey("Quibe")
//false

Se quisermos obter as chaves ou valores de um Map, usamos as propriedades keys e values:

val menu = mapOf("coxinha" to 2, "coquinha" to 3, "batata" to 10)

menu.keys // [coxinha, coquinha, batata]
menu.values // [2, 3, 10]

keys e values são exemplos de propriedades de um objeto. Vamos falar mais disso na parte 2 desse conteúdo que será sobre Classes 😊

🧠 Agora faça os exercícios para praticar o que aprendemos até aqui

Expressões condicionais

🔸 No Kotlin, podemos tomar decisões utilizando as estruturas if ou when.

~~Esse tal de when foi uma novidade 😅~~.

Na documentação é fortemente recomendado utilizar o when, veja só:

Se você tiver que escolher entre ife when, recomendamos usar when, pois isso leva a programas mais robustos e seguros.

Usando o `if`:

Para usar o if, coloque a expressão condicional entre parênteses () e a ação a ser executada se o resultado for verdadeiro entre chaves {}:

val number: Int
val check = true

if (check) {
    number = 1
} else {
    number = 2
}

println(number) // O retorno será `1`

Usando `when`:

Use when quando você tiver uma expressão condicional com várias ramificações. When pode ser usado tanto como uma declaração quanto como uma expressão.
Aqui está um exemplo de como usar when como uma declaração:
Coloque a expressão condicional entre parênteses () e as ações a serem executadas dentro de chaves {}.
Use " -> " em cada ramificação para separar cada condição de cada ação.

val text = "Hello"

when (text) {
    // Verifica se o text é igual "1"
    "1" -> println("One")
    // Verifica se o text é igual a "Hello"
    "Hello" -> println("Greeting")
    // Declaração padrão
    else -> println("Unknown")     
}
// Saída: Greeting

👽 A estrutura when em Kotlin é semelhante ao switch-case em JavaScript, por exemplo. :)

Usando o when como expressão, atribuímos isso a uma variável. Veja só:

val number: Int
val check = true

number = when {
    check -> 1
    else -> 2
}

Legal demais, né?

Se usamos o when como uma expressão, o else é obrigatório, a menos que o compilador possa detectar que todos os casos possíveis estão cobertos pelas condições implementadas.

O when também é útil quando você precisa verificar uma cadeia de expressões booleanas, vamos dar uma olhada:

val temp = 18

val description = when {
    // Se temp < 0 for true, description recebe "very cold"
    temp < 0 -> "very cold"
    // Se temp < 10 for true, description recebe "a bit cold"
    temp < 10 -> "a bit cold"
    // Se temp < 20 é true, description recebe "warm"
    temp < 20 -> "warm"
    // description recebe "hot" caso não caia em nenhuma condição acima
    else -> "hot"             
}
println(description)
// warm

Ranges

🔸 Em Kotlin, os ranges são uma maneira de definir intervalos de valores. Eles são usados principalmente com tipos que podem ser comparados, como números e caracteres.

Um range é definido usando o operador ".." (que é chamado de operador de range) e pode ser usado para criar intervalos fechados ou abertos. Vamos dar uma olhada em alguns exemplos:

val closedRange = 1..5
for (i in closedRange) {
    println(i)
}
// Isso imprimirá 1, 2, 3, 4, 5

Uma coisa daora sobre ranges é que você pode criar ranges de caracteres ou substrings de strings. Veja só:

val charRange = 'a'..'z'
for (char in charRange) {
    println(char)
}
// Isso imprimirá todas as letras minúsculas de 'a' a 'z'

Agora criando um range de substrings a partir de uma string:

val str = "Hello, Kotlin"
val substringRange = str.substring(0..4)
println(substringRange) // Isso imprimirá "Hello"

Loops

🔸 No Kotlin, temos estruturas como o while, que permite continuar uma ação até que uma determinada condição seja satisfeita, e o for, que é utilizado para iterar um número específico de vezes, executando ações.

Vamos explorar um pouco mais essas duas estruturas.

Imagine que eu queria criar um looping que itera 5 vezes. Para isso poderia fazer um laço for:

For

for (number in 1..5) { 
    print(number)
}
// irá imprimir: 12345

Eu posso querer percorrer uma lista que contém sabores de bolos:

val cakes = listOf("chocolate", "baunilha", "milho")

for (cake in cakes) {
    println(cake)
}
// Isso irá imprimir cada um dos sabores da lista `cakes`.

While

🔸 Como em outras linguagens podemos utilizar o while de duas maneiras:

Para executar um bloco de código enquanto uma expressão condicional é verdadeira. while
Para executar o bloco de código primeiro e depois verificar a expressão condicional. do-while

💠 No primeiro caso: while:

var cakesEaten = 0
while (cakesEaten < 3) {
    println("Comeu um bolo")
    cakesEaten++
}

// Comer um bolo
// Comer um bolo
// Comer um bolo

💠 No segundo caso: do-while:

var cakesEaten = 0
var cakesBaked = 0
while (cakesEaten < 3) {
    println("Comeu um bolo")
    cakesEaten++
}
do {
    println("assou um bolo")
    cakesBaked++
} while (cakesBaked < cakesEaten)
// Comer um bolo
// Comer um bolo
// Comer um bolo
// asse um bolo
// asse um bolo
// asse um bolo

No código acima, temos duas variáveis, cakesEaten e cakesBaked, que estão sendo usadas para controlar o número de bolos consumidos e assados. Bora ver o que está acontecendo passo a passo:

Inicialmente, ambas as variáveis cakesEaten e cakesBaked estão definidas como 0.
Em seguida, há um loop while que continua até que o valor de cakesEaten seja menor que 3. Dentro desse loop, a mensagem "Eat a cake" é impressa na tela usando println, e então o valor de cakesEaten é incrementado em 1.
O loop while continuará a ser executado até que cakesEaten seja igual ou maior que 3. Isso significa que o loop será executado três vezes, resultando na impressão de "Comer um bolo" três vezes e no incremento de cakesEaten para 3.
Após a saída do primeiro loop, há um segundo loop do-while. Este loop imprime a mensagem "Asse um bolo" na tela usando println, e então o valor de cakesBaked é incrementado em 1.
O loop do-while continuará a ser executado até que o valor de cakesBaked seja menor do que o valor de cakesEaten. Isso significa que o loop será executado três vezes, uma vez que cakesBaked é inicializado como 0 e cakesEaten é igual a 3 após a conclusão do primeiro loop. Portanto, o loop imprime "Asse um bolo" três vezes e incrementa cakesBaked para 3.

🧠 Agora faça os exercícios para praticar o que aprendemos até aqui

Funções

Usamos a palavra reservada fun para declarar uma função. ~~Divertido, né?🤪~~

fun hello() {
    return println("Hello, world!")
}

fun main() {
    hello()
    // Hello, world!
}

Fizemos algo parecido ~~igual~~ no início desse conteúdo, lembra?! 😅

Em Kotlin:

os parâmetros da função são escritos entre parênteses ().
cada parâmetro deve ter um tipo e vários parâmetros devem ser separados por vírgulas ,.
o tipo de retorno é escrito após os parênteses da função (), separados por dois pontos :.
o corpo de uma função é escrito entre chaves {}.~~(Igual no JavaScript rs)~~
O return é usado para sair ou retornar algo de uma função.

Veja um exemplo:

fun sum(x: Int, y: Int): Int {
    return x + y
}

fun main() {
    println(sum(1, 2))
    // 3
}

A primeira função é chamada sum e recebe dois parâmetros inteiros (x e y) e retorna um valor inteiro. O que essa função faz é simples: ela pega os valores de x e y, soma, em seguida, retorna o resultado da soma.
A segunda função é chamada main. Ela é a função de entrada do programa e é onde a execução começa. Dentro da função main, nós chamamos a função sum(1, 2), que calcula a soma de 1 e 2 (resultando em 3) e, em seguida, usamos a função "println" para imprimir o resultado.

Nomeando argumentos

Incluir nomes de parâmetros torna seu código mais fácil de ler. Se você incluir nomes de parâmetros, poderá escrevê-los em qualquer ordem.

fun printMessageWithPrefix(message: String, prefix: String) {
    println("[$prefix] $message")
}

fun main() {
    // Uses named arguments with swapped parameter order
    printMessageWithPrefix(prefix = "Log", message = "Hello")
    // Isso imprime: [Log] Hello
}

Valores de parâmetro padrão

fun printMessageWithPrefix(message: String, prefix: String = "Info") {
    println("[$prefix] $message")
}

Caso nenhum valor seja passado para o parâmetro prefix, o valor padrão será "Info".

fun main() {

    printMessageWithPrefix("Hello", "Log") 
    // [Log] Hello


    printMessageWithPrefix("Hello")        
    // [Info] Hello

    printMessageWithPrefix(prefix = "Log", message = "Hello")
    // [Log] Hello
}

👀 Você pode pular parâmetros específicos com valores padrão, em vez de omiti-los. No entanto, após pular o primeiro parâmetro, você deve nomear todos os parâmetros subsequentes.

Função sem retorno

💠 Se sua função não retorna um valor útil, o tipo de retorno dela é Unit. Unit é um tipo com apenas um valor - Unit.

Você não precisa declarar explicitamente que a função retorna Unit em seu corpo de função. Isso significa que você não precisa usar a palavra-chave return ou declarar um tipo de retorno, vamos ver alguns exemplos:

fun printMessage(message: String) {
    println(message)
    // `return Unit` ou `return` é opcional
}

fun main() {
    printMessage("Hello")
    // Hello
}

Funções `single-expression`

🔸 Para tornar nosso código mais conciso, podemos usar funções de "única expressão". Por exemplo, podemos encurtar a nossa função sum() desse jeito aqui:

// antes:

fun sum(x: Int, y: Int): Int {
    return x + y
}

// depois:

fun sum(x: Int, y: Int) = x + y

Você pode remover as chaves {} e declarar o corpo da função usando o operador de atribuição =. E devido à inferência de tipos do Kotlin, você também pode omitir o tipo de retorno. A função sum() se torna então uma única linha 😱

👀 Omissão do tipo de retorno é apenas possível quando sua função não possui corpo ({}), a menos que o tipo de retorno de sua função seja Unit.

🧠 Agora faça os exercícios para praticar o que aprendemos até aqui

💎 Bônus

Nessa parte bônus, irei explicar como fazer o download do IntelliJ IDEA gratuitamente e como aproveitar ao máximo essa ferramenta para aprimorar seus conhecimentos em Kotlin, através de prática direta na própria IDE 😻

👁️ Antes de instalar o IntelliJ IDEA, tenha certeza que o JDK está instalado na sua máquina. Você pode baixar o JDK mais recente diretamente do site da Oracle ou optar por uma distribuição OpenJDK, que é uma alternativa de código aberto. Certifique-se de fazer todas as configurações necessárias.

Baixe o IntelliJ aqui nesse link. Informação importante: A primeira opção que aparece é a Ultimate, não é essa que queremos de um scroll para baixo e faça o download da Community Edition.
Depois de baixar, siga todos os procedimentos de acordo com seu sistema operacional.

Quando você abrir o IntelliJ IDEA, provavelmente você terá algo parecido com isso daqui:

Se quisermos criar um novo projeto Kotlin, podemos clicar em new project e aqui não tem muito segredo, você deve escolher um nome para seu projeto e colocar a linguagem desejada, que no nosso caso é o Kotlin e logo após clicar em create.

Usando a IDE para aprender/praticar Kotlin 🤯

Na tela inicial, à esquerda, clique em "Learn".
Em seguida, localize e clique em "New Course" no lado direito.
Após clicar em "New Course", uma nova página será aberta. No lado esquerdo, clique em "Marketplace". Neste caso, estou fazendo o seguinte curso.

Depois de escolher, clique em Open e isso o levará para uma página que inclui uma série de desafios, veja só:

À esquerda, você encontrará uma lista de todos os desafios propostos.
No centro é onde você irá resolver esses desafios, ou seja, onde você irá codar.
À direita, você encontrará a descrição do desafio, ou seja, as instruções sobre o que precisa ser feito.

Depois que finalizar o desafio para verificar se está correto e prosseguir para o próximo, basta clicar em check.

Chegamos ao fim desta primeira parte, espero que tenham gostado!

Até a próxima e bons estudos!

~~Se você leu até o final reage com um 💟 se não, não precisa reagir :(.~~

[off-topic] Top 5 Playlists Que Eu Escuto Enquanto Estou Programando

Ana Laura — Sun, 15 Oct 2023 23:11:37 +0000

Hoje vou trazer algo meio aleatório aqui 😅 mas é que eu curto muito codar escutando música ~~(e fazer tudo também)~~. Então, pensei: por que não criar um post no dev.to para compartilhar as playlists que costumo ouvir enquanto estou programando ou até mesmo criando conteúdo.

Eu vou indicar músicas rap/trap que geralmente é estilo de música que eu mais escuto.

Vou fazer um top 5 aqui 💟

Alee Esse artista maravilhoso que na verdade não é nem o álbum, geralmente dou play em todas, descobri ele faz pouco tempo.
Flora matos - Do Lado De Flora A verdade é que a Flora se encaixa em todos os momentos da sua vida, mas esse álbum "DO LADO DE FLORA", é perfeito pra codar!
Tasha e Tracie - Diretoria Maravilhosas, se você quer se sentir incrível e determinado a resolver TODO e QUALQUER bug, escute Tasha e Tracie.
Nill - Regina Ai esse álbum, tenho poucas palavras pra ele pois amo demais!
Boombap Essa playlist de Boombap simplesmente perfeita, eu ultimamente to viciada nela escutando 39393x por dia!

Tudo que eu recomendei aqui tem o selo Ana Laura de qualidade, faça bom proveito!

bjs!

Como Habilitar o Botão de Envio apenas com Inputs Preenchidos Usando JavaScript

Ana Laura — Wed, 04 Oct 2023 18:38:22 +0000

Oi pessoal! 💟

Estes dias, peguei um freela no qual o cliente tinha alguns formulários em seu site e queria captar leads de forma mais concisa. Para isso, ele precisava que a pessoa só pudesse clicar no botão de enviar o formulário quando todos os inputs da página estivessem preenchidos.

O site era feito em WordPress e os formulários criados na RD Station eram integrados ao site no WordPress via script.

Para resolver esse problema, optei por usar JavaScript, já que os formulários da RD Station não nos oferecem essa opção na hora de editar o formulário, tive que fazer isso de forma "manual". No WordPress, conseguimos adicionar blocos de código no final da tag body do site quando usamos o editor Elementor (confesso que não sei dizer quanto a outros editores, mas deve haver algum plugin que faça isso), o que facilita minha vida em 100% na hora de fazer esse tipo de coisa.

Vamos criar um cenário aqui para facilitar o entendimento do que eu fiz. O formulário é um HTML, então vamos imaginar algo assim:


<h2>Preencha o formulário</h2>

<form action="#" method="post">
  <label for="name">Nome:</label><br>
  <input type="text" id="name" name="name"><br><br>

  <label for="email">E-mail:</label><br>
  <input type="email" id="email" name="email"><br><br>

  <label for="phone">Telefone:</label><br>
  <input type="tel" id="phone" name="phone"><br><br>

  <button type="submit" id="button">Enviar formulário</button
</form>

👀 Aqui serei mais direta, mas é super importante lembrarmos de quebrar o problema em partes, pois assim fica mais fácil de resolvermos.

Implementando a lógica 🔍

A primeira coisa que podemos fazer aqui é capturar nosso botão e desabilitá-lo, além de alterar o estilo, deixando-o com uma opacidade menor:

const button = document.getElementById('button');
button.style.opacity = 0.7;
button.disabled = true;

Depois, preciso selecionar os inputs. Há uma forma mais simples de pegar todos pela tag, por exemplo, usando o getElementsByTagName, mas no meu caso, ele estava retornando inputs de toda a página. Então, minha saída foi fazer isso aqui. Como eram apenas 3 inputs, selecionei cada um pelo ID e criei um array de inputs.

const textField = document.getElementById('name');
const emailField = document.getElementById('email');
const phoneField = document.getElementById('phone');

const formFields = [textField, emailField, phoneField]

Agora, vamos criar a função que vai fazer o trem começar a funcionar, como a gente diria na minha terra, MG!

function checkFormFields() {
 let fieldsFilled = true;

  formFields.forEach((field) => {
    if (field.value === '') {
      fieldsFilled = false;
    }
  });

}

Primeiro, criamos a variável fieldsFilled. Essa variável é a responsável por controlar se o input está preenchido ou não. Depois, percorremos nossa lista de inputs fazendo uma verificação: quando o meu input estiver vazio, a minha variável fieldsFilleddeverá ser false.

Agora, precisamos desabilitar e habilitar o nosso botão, dependendo da situação do nosso input.


function checkFormFields() {
  let fieldsFilled = true;

  formFields.forEach((field) => {
    if (field.value === '') {
      fieldsFilled = false;
    }
  });

  if (fieldsFilled) {
    button.removeAttribute('disabled');
    button.style.opacity = 1;
    button.style.cursor = "pointer";
  } else {
    button.disabled = true;
  }
}

Veja bem, agora adicionamos uma condição na nossa função: quando a minha variável fieldsFilled for true, o que significa que meu input foi preenchido, ele remove o atributo disabled, volta o meu button para a opacidade normal dele e muda também o cursor do mouse. Senão, o botão permanece desabilitado até que todos os inputs sejam preenchidos.

Ana, acabou? Não!!

Agora, para finalizar, precisamos disparar esse evento nos nossos inputs, fora da função:

formFields.forEach((field) => {
  field.addEventListener('input', checkFormFields);
});

Feito! Temos um botão desabilitado que será habilitado somente quando todos os campos forem preenchidos

DEV Community: Ana Laura

O que é um Perceptron — ou pelo menos o que eu entendi sobre ele

Mas o que é um perceptron?

Entradas e decisões

Exemplo prático: quem curte funk?

A matemática por trás da decisão

Mas o que são esses “pesos”?

E o tal do bias?

Visualizando em um gráfico

Como o perceptron aprende com os erros?

O que acontece depois de aprender?

Resumão

Você realmente entende como funciona uma IA generativa?

Como a máquina entende texto?

E como a IA gera um texto?

Mas ela é inteligente mesmo?

Quando foi que a gente parou de fazer perguntas?

Tipos de Aprendizado de Máquina

Aprendizado supervisionado/ Não Supervisionado 🎓

Aprendizado supervisionado 👩‍🏫

Aprendizado não supervisionado 🤖

Aprendizado semissupervisionado 🤝

Aprendizado por Reforço 🎮

Aprendizado em Batch e Online 📊

Aprendizado em Batch (por Ciclo) 🔄

Aprendizado online (incremental) 📈

Aprendizado baseado em instâncias VS baseado em modelo 🔍

Aprendizado baseado em instância 📚

Aprendizado baseado em modelo 🛠️

Meus Últimos Meses Estudando Análise de Dados 🎲

Complexidade de Espaço dos Algoritmos

O que é complexidade de espaço 🪐

Entendendo RecyclerView de Uma Vez Por Todas

Usando RecyclerView para organizar uma festa 🥳

Código e um pouco de teoria 💻

Como Foi O Front In Floripa? 🤔

Networking 😎

Palestra - Conteúdos 🤖

Code in The Dark 😈

Tentando Conquistar o Mundo da Programação: Dicas para Resolver Problemas

Dicas e Lembretes Essenciais 📝

"Travei" num desafio/problema. E agora? 🥶

Comece Por Aqui: Conceitos Básicos Kotlin Parte I

Por que Kotlin?

Meu primeiro "Hello, World" em Kotlin

Variáveis

Template string

Tipos básicos

Coleções

1. List

2. Set

3. Map

Expressões condicionais﻿

Usando o if:

Usando when:

Ranges

Loops

For

While

Funções

Nomeando argumentos

Valores de parâmetro padrão﻿

Função sem retorno

Funções single-expression

💎 Bônus

Usando a IDE para aprender/praticar Kotlin 🤯

[off-topic] Top 5 Playlists Que Eu Escuto Enquanto Estou Programando

Como Habilitar o Botão de Envio apenas com Inputs Preenchidos Usando JavaScript

Implementando a lógica 🔍

Expressões condicionais

Usando o `if`:

Usando `when`:

Valores de parâmetro padrão

Funções `single-expression`