DEV Community: Lucas Cruz

Primeiros Passos com Databricks para Data Warehousing

Lucas Cruz — Thu, 18 Sep 2025 18:53:19 +0000

Anotações do curso de databricks provido pela por databricks academy -

Databricks é uma plataforma de dados unificada e inteligente, que implementa o conceito de Lakehouse. A plataforma unifica o armazenamento de dados tanto brutos quanto estruturados, permite a transformação desses dados, com notebooks (que aceitam linguagens como python, scala e R) ou SQL.A plataforma também permite a criação de rotinas de dados e dashboards. Por fim ela tem diversos pontos que usam IA para execução de ações com dados.

Sumário

Ingestão de dados

Componentes centrais da plataforma -- Lakeflow -- Databricks SQL -- Mosaic AI -Funcionalidades e para quem são destinadas -Data warehousing -- Explicação de 'nó de computação' -- Arquitetura de medallion

Ingestão de dados

Formas de criar/ inserir dados no databricks:

Create table: Usando SQL
Upload UI: Subir os dados pela interface
Copy into: Usando a função de COPY do SQL
Autoloader: Um processo de carregar dados de forma automatica de alguma fonte.
Streaming tables: tabelas atualizadas em tempo real

Componentes centrais

Componentes centrais da plataforma: Lakeflow, Databricks SQL, AI/BI, Mosaic AI

Lakeflow

O Lakeflow tem três componentes principais:

lakeflow connect que conecta com várias fontes de dados.
Lakeflow DLT - (DLT, que significa Delta Live Tables, é uma funcionalidade do Databricks que simplifica a criação e o gerenciamento de pipelines de dados.)
Lakeflow Jobs: Job = tarefa automatizada e agendada

O Databricks SQL

Ferramenta para análise exploratória.
O Databricks SQL, junto com os Dashboards, centraliza consultas e visualizações. A plataforma infunde essas ferramentas com IA através de recursos como o Databricks Assistant e o Genie

O Mosaic AI

É uma ferramenta que oferece suporte end-to-end para IA tradicional e generativa.

Funcionalidades

Para equipe de dados o databricks fornece -
Notebooks
Editor SQL
Assistente de IA para geração de código
Metadados - Com descrição gerada por IA
Sistema de busca de arquivos

Para equipe de negocios

IA/BI Dashboard - Espaço para geração de dashboards com ferramenta de IA
IA/BI Genie - Espaço de chat conversasional com acesso a informação dos dados, pode-se "perguntar diretamente para os dados"

Data Warehousing

Solução centralizada para Relatórios, Análises e insights

SQL warehouses no databricks é um recurso computacional escalável e otimizado para executar SQL queries, análise de dados, criação de visualizações de dados.

Cluster size:
Refere-se ao poder computacional alocado ao SQL warehouse

Expresso em "tamanhos de camiseta", como Pequeno (Small), Médio (Medium), Grande (Large) e Extra Grande (X-Large).

Cada tamanho define o número de nós de computação e a capacidade para
processamento paralelo.

Scaling:
Garante que o SQL Warehouse aloque recursos de forma adaptativa e dinâmica.
Permitindo configurar o mínimo de clusters e o máximo
Os benefícios são que um custo eficiente - Onde só se paga pelo que se usa
E uma performance otimizada prevenindo gargalos.

Um cluster é formado por um conjunto de nós de computação.

Explicação sobre 'nó de computação'/'worker'

Cada nó de computação é uma instância de servidor na nuvem
Um ‘nó de computação’ é uma máquina virtual (VM) que possui um conjunto de recursos dedicados como CPU, Memória RAM, armazenamento, e em alguns casos GPU

O gasto computacional é calculado com DBU - Databricks Unit

Arquitetura de Medallion

É recomendado que com databricks se use a arquitetura de Medallion

Existem três camadas:

Bronze - Dados brutos, sem tratamento, aqui temos uma cópia exata dos dados de origem.

Prata - Dados tratados, limpos e organizados

Ouro - Dados prontos para uso, em aplicativos, dashboard e etc. Preparados para a area de negócios já agrupados.

A arquitetura de medallion pode ser considerada um padrão de projeto de dados.

Para acessar o curso completo: https://customer-academy.databricks.com/learn/courses/3603/get-started-with-databricks-for-data-warehousing?hash=42b6834df6bded2a210c444fa1982f59f1ec9831&generated_by=1192585

Fundamentos arquitetura de soluções de Automação

Lucas Cruz — Thu, 11 Sep 2025 15:38:27 +0000

Nos meus estudos sobre arquitetura de soluções eu coletei algumas informações e aqui compartilho.

Sumário:

Descrição da função
Responsabilidades do arquiteto de soluções em cada etapa de um desenvolvimento de automação.
Princípios de design da solução
Referências

Arquiteto de soluções

Responsável por projetar a solução e garantir que seu desenvolvimento seja feito seguindo boas práticas

Responsabilidade em cada etapa do processo de desenvolvimento da solução:

1 Início:

Avaliação da Declaração de Trabalho
Exame do ambiente e infraestrutura existente
Elaborar o rastreador de acesso de aplicativos junto com o gerente de projeto

2 Caso de Negócios e Validação Técnica:

Criar um Plano de Acesso de Aplicativo detalhado
Estimativa de esforço do ponto de vista do desenvolvimento
Auxiliar o Analista de Negócios na validação técnica de casos de uso selecionados: Identificando Dependências técnicas e Complexidades

3 Análise de Processos:

Contribuir e Revisar o PDD, que é um pré-requisito importante para o estágio de Design da Solução.
Estimar as licenças necessárias para o desenvolvimento.
Projetar o estado futuro da solução ("To-Be"). Ele fornece detalhes sobre o que está dentro e fora do escopo, desafios, gerenciamento de exceções, dados de entrada e saída.

4 Design da Solução

Na etapa de Design da Solução, a equipe de implementação se concentra na criação do Documento de Design de Solução (SDD)
Projetar e documentar a arquitetura de solução
Criar o Plano de Testes Técnicos (TTP)

4.1 Documento de design de solução - SDD

Documento formal que descreve os detalhes do projeto de solução.

Deve conter: Visão geral do processo, Arquitetura da solução e diagramas de fluxo de processo integração com aplicativos e tecnologias, tratamento de erros e gerenciamento de exceções, e considerações sobre desempenho e escalabilidade.

Objetivo: Roteiro de desenvolvimento, manutenção e melhorias, colaboração e trabalho em equipe e transferência de conhecimento.

5 Desenvolvimento e teste

Orientar desenvolvimento
Garantir altos padrões técnicos e a excelência geral da solução
Realizar regularmente revisões de código para corrigir e melhorar o desempenho do processo.

6 Teste de aceitação de usuário e hipercuidado

Realizar revisões finais do código, de acordo com as mudanças necessárias durante o UAT.
Documentar os resultados e registrar em log todos os bugs identificados durante os testes
Hipercuidado é um período limitado imediatamente após a implantação de uma solução automatizada em produção, marcado pela atenção especial dada a cada processo executado

Princípios de design da solução.

Evitar complexidade desnecessária
Escalabilidade
Manutenibilidade
Modularidade
Legibilidade
Confiabilidade
Extensibilidade

RPA - Robotic Process Automation

Lucas Cruz — Thu, 21 Aug 2025 21:09:33 +0000

O que é RPA?

Um rpa - Processo de Automação Robótica - é um tipo de software feito para automatizar processos digitais

Os processos mais indicados para serem automatizados:

repetitivos
De alto volume
Que não exigem julgamento humano ou análise complexa.

Tarefas comuns executadas por RPA:

extrair dados
preencher formulários
mover arquivos

Quais os tipos de RPA

RPA assistido:
Um rpa que é executado e acompanhado por uma pessoa, o rpa é executado na maquina que a pessoa usa.

RPA não assistido:
Um rpa que executa sem nenhuma interferência humana. Geralmente é executado em uma maquina dedicada.

Quais os ganhos com RPA

Reduz o tempo gasto em atividades de baixa complexidade que consomem muito tempo

Arquitetura comum de soluções com RPA:

Desenvolvimento (Dev Studio): onde os processos são desenhados e testados
Runner (Robô/Agent): executa os processos no ambiente de produção
Orquestrador (Orchestrator): gerencia múltiplos robôs, agendamentos e monitoramento

Ferramentas para desenvolvimento de RPA:

Botcity
UIPath
Anywhere
Blue Prism
Power Automate (Microsoft)

Crie seu primeiro RPA com BotCity

Lucas Cruz — Mon, 17 Mar 2025 08:15:22 +0000

Vídeo da execução da automação

Repositório no GitHub: https://github.com/olucascruz/oficina_rpa

Introdução

Hoje, nesta oficina, vamos colocar a mão na massa e construir juntos um RPA! Nosso projeto será uma automação web e desktop, onde veremos, na prática, como essa tecnologia pode facilitar tarefas repetitivas.

O processo que vamos desenvolver consiste em:

Acessar o Google News.
Pesquisar um tema específico.
Obter os títulos das notícias.
Abrir o Impress (na oficina presencial, utilizamos o PowerPoint).
Criar uma apresentação com esses títulos.

Meu nome é Lucas Cruz, sou desenvolvedor de RPAs e faço parte do projeto DX Academy. Atualmente, curso Sistemas de Informação e, nos últimos dois anos, desenvolvi diversos RPAs para automatizar processos e otimizar fluxos de trabalho.

A oficina foi conduzida por mim, com a colaboração do Henrique Franklin, que abordou conceitos fundamentais de RPA e mapeamento de processos. Todo o material utilizado, incluindo as apresentações, está disponível no repositório do projeto.

O que é RPA?

RPA (Robotic Process Automation) é a tecnologia que usa 'robôs' para automatizar tarefas manuais e repetitivas. Com ela, é possível aumentar a produtividade, reduzir erros e liberar tempo para atividades estratégicas. Vamos ver como isso funciona na prática!

Parte Técnica

Criando o Ambiente Virtual

Para começar, criem um ambiente virtual com o seguinte comando:

python -m venv venv

Ativem o ambiente virtual:

venv/Scripts/Activate.ps1

Instalando Dependências

Instale o Cookiecutter:

pip install cookiecutter

Em seguida, use o template da BotCity:

python -m cookiecutter https://sdk.botcity.dev/templates/python/v2.zip

Selecione a opção "ambos" (both) e dê um nome ao seu projeto.
Defina o Project ID, por exemplo:

rpa

Agora que baixamos o template da BotCity, vou explicar um pouco sobre os arquivos gerados. Entre eles, temos:

Arquivos necessários para gerar a build.
O arquivo .botproject, que permite abrir o projeto na IDE da BotCity.

Contextualização

Na indústria, uma atividade muito comum é baixar dados de um sistema e enviá-los por e-mail. Esse processo, quando feito manualmente, pode ser repetitivo e propenso a erros, tornando a automação uma solução eficiente.

Um aspecto importante das automações web é que devem ser executadas no mesmo navegador em que foram desenvolvidas. Isso ocorre porque páginas da web podem ter comportamentos distintos em diferentes navegadores, o que pode comprometer a estabilidade da automação. Embora esse problema nem sempre aconteça, é um risco que deve ser considerado.

Instalando Dependências do Projeto

Acesse a pasta do projeto:

cd rpa

Instale os pacotes necessários:

pip install -r requirements.txt

Escolhendo um WebDriver

Para iniciarmos, precisamos de um WebDriver, que permite ao nosso RPA interagir com o navegador. A escolha do driver depende do navegador que será utilizado na automação.

Aqui, utilizaremos o Geckodriver, que é o WebDriver do Firefox. Pode ser baixado em:
https://github.com/mozilla/geckodriver/releases

Outra alternativa é usar o WebDriver Manager:
https://pypi.org/project/webdriver-manager/

Atenção: O webdriver-manager pode facilitar a configuração inicial, mas também introduz uma dependência de terceiros. Isso pode gerar falhas na obtenção do WebDriver e comprometer a execução da automação. Portanto, avalie bem a melhor abordagem para o seu projeto.

Implementação

No processo manual, abriríamos o navegador, acessaríamos o Google e, então, buscaríamos pelo Google News. No entanto, ao automatizar esse fluxo, podemos otimizar o processo acessando diretamente a página desejada, tornando a automação mais eficiente.

webbot.browser("url")

então para maximizar usamos

webbot.maximize_window()

Localizando Elementos Web

Para interagir com os elementos da página, utilizamos as ferramentas de desenvolvedor do navegador para inspecioná-los e obter seus seletores. O XPath é um dos métodos mais utilizados para encontrar elementos.

Capturamos o elemento de input de pesquisa com:

webbot.find_element("xpath", by=By.XPATH)

Depois, podemos escrever no input com:

webbot.send_keys("texto")

Ou alternativamente:

webbot.click()
webbot.paste("texto")

Para enviar a pesquisa:

webbot.enter()

No código do projeto fica assim:

input_el = webbot.find_element("/html/body/div[4]/header/div[2]/div[2]/div[2]/form/div[1]/div/div/div/div/div[1]/input[2]", by=By.XPATH)
input_el.send_keys(search_text)
webbot.enter()

Para capturar os títulos da pesquisa, usamos:

title_text1 = webbot.find_element("xpath", by=By.XPATH).text

Se quisermos validar se o elemento foi encontrado corretamente, podemos imprimir o resultado:

print(title_text1)

Se não for o elemento correto, o retorno pode ser NoneType.

Para capturar os 5 e guardar esses titulos em uma lista podemos fazer da seguinte maneira

list_text_news = []

webbot.wait(2000)
news1 = webbot.find_element('/html/body/c-wiz/div/main/div[2]/c-wiz/c-wiz[1]/c-wiz/article/div[1]/div[2]/div/a', by=By.XPATH).text

news2 = webbot.find_element('/html/body/c-wiz/div/main/div[2]/c-wiz/c-wiz[2]/c-wiz/div/div[1]/c-wiz/article/div[1]/div[2]/div/a', by=By.XPATH).text

news3 = webbot.find_element('/html/body/c-wiz/div/main/div[2]/c-wiz/c-wiz[2]/c-wiz/div/div[2]/c-wiz/article/div[1]/div[2]/div/a', by=By.XPATH).text

news4 = webbot.find_element('/html/body/c-wiz/div/main/div[2]/c-wiz/c-wiz[2]/c-wiz/div/div[3]/c-wiz/article/div[1]/div[2]/div/a', by=By.XPATH).text

news5 = webbot.find_element('/html/body/c-wiz/div/main/div[2]/c-wiz/c-wiz[3]/c-wiz/article/div[1]/div[2]/div/a', by=By.XPATH).text

webbot.stop_browser()
list_text_news.append(news1)
list_text_news.append(news2)
list_text_news.append(news3)
list_text_news.append(news4)
list_text_news.append(news5)

Uma boa prática no desenvolvimento de software é sempre manter o código desacoplado. Como essa parte da automação é responsável apenas por capturar noticias do google news podemos organizá-la em uma função específica:

def get_titles_news(webbot:WebBot, search_text):

    webbot.browse("https://news.google.com/home?hl=pt-BR&gl=BR&ceid=BR:pt-419")
    webbot.maximize_window()

    input_el = webbot.find_element("/html/body/div[4]/header/div[2]/div[2]/div[2]/form/div[1]/div/div/div/div/div[1]/input[2]", by=By.XPATH)
    input_el.send_keys(search_text)
    webbot.enter()

    list_text_news = []

    webbot.wait(2000)
    news1 = webbot.find_element('/html/body/c-wiz/div/main/div[2]/c-wiz/c-wiz[1]/c-wiz/article/div[1]/div[2]/div/a', by=By.XPATH).text

    news2 = webbot.find_element('/html/body/c-wiz/div/main/div[2]/c-wiz/c-wiz[2]/c-wiz/div/div[1]/c-wiz/article/div[1]/div[2]/div/a', by=By.XPATH).text

    news3 = webbot.find_element('/html/body/c-wiz/div/main/div[2]/c-wiz/c-wiz[2]/c-wiz/div/div[2]/c-wiz/article/div[1]/div[2]/div/a', by=By.XPATH).text

    news4 = webbot.find_element('/html/body/c-wiz/div/main/div[2]/c-wiz/c-wiz[2]/c-wiz/div/div[3]/c-wiz/article/div[1]/div[2]/div/a', by=By.XPATH).text

    news5 = webbot.find_element('/html/body/c-wiz/div/main/div[2]/c-wiz/c-wiz[3]/c-wiz/article/div[1]/div[2]/div/a', by=By.XPATH).text

    webbot.stop_browser()
    list_text_news.append(news1)
    list_text_news.append(news2)
    list_text_news.append(news3)
    list_text_news.append(news4)
    list_text_news.append(news5)



    return list_text_news

Aprofundando

A página do Google News apresenta uma peculiaridade: seu conteúdo não é fixo. Além da lista de notícias, também são exibidas caixas com notícias de uma mesma fonte. Esses dois tipos de elementos não estão localizados em posições fixas, o que torna a busca pelos textos mais desafiadora.

Usar o método mencionado anteriormente não garante que a automação funcione de forma consistente. Quando isso acontece, precisamos buscar alternativas.

Uma opção seria buscar os textos usando seletores diferentes do XPath. Uma forma comum de resolver esse problema é buscar todos os elementos com uma determinada classe, utilizando o método:

webbot.find_elements("nome_da_classe", by = By.CLASS_NAME)

(Note que essa função retorna uma lista de múltiplos elementos)
No entanto, neste caso específico, esse método não funciona.

Uma forma de contornar esse problema é buscar todos os conteúdos de texto dentro das tags e, em seguida, filtrar para obter apenas as notícias. O código ficaria assim:

desta forma:

text_in_page = webbot.page_source().get_text(" | ")
list_text_in_page = text_in_page.split(" | ")
list_text_contains_search_text = list(filter(lambda value: search_text.lower() in value.lower() and "notícias sobre" not in value.lower(), list_text_in_page))

Aqui usamos um filtro que remove textos que contém "notícias sobre", pois os blocos com notícias de uma mesma fonte tem esse título.

Dessa maneira, nossa solução fica menos propensa a erros.

Ao desenvolver RPAs sempre nos deparamos com problemas que exigem soluções diferentes. A abordagem mostrada anteriormente é a forma mais geral para se buscar um elemento da página e obter seu texto. Nesta seção é mostrado uma solução melhor adaptada para esse site em específico e para está automação.

IMPORTANTE: A primeira solução foi criada na primeira vez que automatizei esse site, sem conhecer completamente seu comportamento, o que a tornava propensa a erros. Para evitar esses problemas, é fundamental realizar testes. Durante o desenvolvimento de uma automação, é comum deixá-la executando periodicamente em um período de testes, o que nos permite identificar erros, casos especiais e outros problemas. Ao corrigir essas questões, nossa solução se torna mais robusta.

Por fim a função fica assim:

def get_titles_news(webbot:WebBot, search_text:str):

    webbot.browse("https://news.google.com/home?hl=pt-BR&gl=BR&ceid=BR:pt-419")
    webbot.maximize_window()

    input_el = webbot.find_element("/html/body/div[4]/header/div[2]/div[2]/div[2]/form/div[1]/div/div/div/div/div[1]/input[2]", by=By.XPATH)
    input_el.send_keys(search_text)
    webbot.enter()
    webbot.wait(3000)

    text_in_page = webbot.page_source().get_text(" | ")
    list_text_in_page = text_in_page.split(" | ")
    list_text_contains_search_text = list(filter(lambda value: search_text.lower() in value.lower() and "notícias sobre" not in value.lower(), list_text_in_page))

    webbot.stop_browser()

    return list_text_contains_search_text

Automação Desktop

Agora que temos os títulos, vamos abrir o Impress para criar uma apresentação.

Uma maneira simples de abrir um programa no Windows via automação é:

Pressionar a tecla Windows.
Pesquisar o nome do programa.
Pressionar Enter.

Interação com Interface Gráfica

Para interagir com elementos visuais, utilizamos imagens de referência. Essas imagens podem ser capturadas manualmente ou pelo BotCity Studio que também gera o código para interagir com a imagem.

Vantagens do BotCity Studio:

Gera automaticamente o código para interagir com as imagens.
Facilita o uso de "click relativo", onde o usuário pode selecionar visualmente o local em que deseja clicar em relação à imagem identificada.

Para encontrar um elemento na interface, usamos o seguinte código:

desktop_bot.find("nome_da_imagem")

As imagens devem estar na pasta resources, que já vem configurada no template.

O código gerado pelo BotCity Studio para encontrar e clicar em um elemento é o seguinte:

if not desktop_bot.find("nome_da_imagem"):
    not_found("nome_da_imagem")
desktop_bot.click()

Se o elemento for opcional (como um popup de atualização), podemos evitar erros verificando sua existência antes de tentar clicar:

if desktop_bot.find("nome_da_imagem"):
    desktop_bot.click()

Se o item não for encontrado, a função de clique não será executada, evitando falhas na automação.

Podemos dividir a parte de criação da apresentação em uma função separada para manter o código mais organizado. O código final para a função de criação da apresentação seria:

def create_pptx(desktop_bot:DesktopBot, search_text, titles):
    desktop_bot.type_windows()
    desktop_bot.paste("LibreOffice Impress")
    desktop_bot.enter()

    if desktop_bot.find("fechar_btn"):
        desktop_bot.click()


    if not desktop_bot.find("title_field"):
        not_found("text_field")    
    desktop_bot.click()

    desktop_bot.paste(f"Principais notícias sobre: {search_text}")


    if not desktop_bot.find("text_field"):
        not_found("text_field")    
    desktop_bot.click()

    for title in titles:
        desktop_bot.paste(title)
        desktop_bot.enter()
    desktop_bot.backspace()

    desktop_bot.control_a()

    # decrease font size
    for _ in range(4):
        desktop_bot.control_key("[")

    if not desktop_bot.find("formatte_bt"):
        not_found("formatte_bt")
        return
    desktop_bot.click()

    if desktop_bot.find("list_bt"):
        desktop_bot.click()

    if desktop_bot.find("unordered_list_bt"):
        desktop_bot.click()

    desktop_bot.control_s()
    desktop_bot.wait(2000)
    desktop_bot.kb_type("novo_file")

    desktop_bot.enter()
    desktop_bot.wait(2000)

    # Close app
    desktop_bot.control_key("q")

Dicas para automação desktop

Use imagens únicas. Se um botão contém um ícone e um texto, prefira capturar a imagem com o texto para evitar confusões.
Prefira usar os atalhos do programa, se disponíveis, em vez de depender de visão computacional, pois isso tende a ser menos propenso a erros.
Use sabiamente o comando de espera, especialmente se o programa depender de algum processamento demorado.

IMPORTANTE: Imagens capturadas em determinadas telas não serão reconhecidas em telas com resoluções diferentes.

Estrutura do projeto

No final, a estrutura do projeto fica assim, com a pasta app contendo as funções tanto de acesso ao site quanto de uso do PowerPoint. Para automações mais complexas, em que vários sistemas estão envolvidos, podemos criar subpastas específicas para cada funcionalidade dentro da pasta app.

Embora não tenha sido usado neste projeto, em sistemas mais robustos, é comum criar uma pasta utils que contém funções utilitárias que são usadas em várias partes do projeto.

Com isso, finalizamos a construção do nosso RPA! Espero que esta oficina tenha sido útil para vocês e que consigam aplicar esses conhecimentos em novos projetos. Boa automação!

PS: Se você gostou desse texto, recomendo também o meu primeiro artigo sobre automação, onde compartilho o passo a passo para automatizar um editor de imagens GIMP. Confira aqui: Automatizando editor de imagens GIMP com Python/Botcity

Como normalizar banco de dados?

Lucas Cruz — Tue, 02 Apr 2024 21:21:08 +0000

Ao fim desse artigo você saberá como normalizar um banco de dados uma habilidade essencial para qualquer um que deseje desenvolver softwares com persistência de dados

O que é normalização?

A normalização é um processo para organizar e estruturar um banco de dados relacional para eliminar redundâncias e anomalias.
As formas normais são 1FN: Atomicidade de dados, 2FN: Eliminação de dependências parciais, 3FN: Eliminação de dependências transitivas. Cada uma das formas normais depende da anterior ou seja é preciso está na 1FN para ir para a 2FN.

1FN: Atomicidade de dados

As colunas devem ser atômicas ou seja indivisíveis, por exemplo, se o endereço for um dado que vai ser salvo, seguindo a 1º forma normal cada parte do endereço deve ser uma coluna:

e não apenas

|endereço|

E também caso tenha muita um valor se repita varias vezes deve-se registrá-lo em outra tabela.

Por exemplo pode se haver tabelas para: Bairro, Rua e Cidade

Bairro
| id | nome do bairro |

Rua
| id | nome da rua |

Cidade
| id | nome da cidade |

Assim na tabela endereço as colunas só referenciam o id ao invés de repetir o valor varias vezes.

2NF: Eliminação de Dependências Parciais

Primeiro precisa-se seguir a 1NF.
Os atributos da tabela devem depender de uma chave primaria completa não de forma parcial em caso de chaves conjuntas.

Se for uma tabela pedido:

Deve-se analisar qual é a chave primária, agora verificar se algum atributo não chave está dependendo de outra chave, se estiver deve ser movido para outra tabela, nesse caso o nome do cliente ficando assim:

Tabela pedido:
| id do pedido | id do cliente | Hora da entrega |

Tabela cliente:
| id do cliente | nome do cliente |

3NF: Remoção de Dependências Transitivas

Deve atender o 2NF.
Os atributos só podem depender do id e de nenhuma outra coluna.
Por exemplo se você uma tabela produto:

Tabela produto

Como a coluna de categoria do produto depende da coluna nome do produto ele deve ser movido para outra tabela e referenciado nessa:

Tabela categorias

| id da categoria | nome da categoria |

Isso promove maior organização dos dados e ajuda a evitar anomalias na modificação, inserção e exclusão de dados.

Referências:
https://pt.wikipedia.org/wiki/Normaliza%C3%A7%C3%A3o_de_dados
https://dev.to/ikauematos/conceitos-principais-sobre-normalizacao-1hpl

Fetch API: One Byte Explainer

Lucas Cruz — Fri, 29 Mar 2024 20:35:03 +0000

This is a submission for DEV Challenge v24.03.20, One Byte Explainer: Browser API or Feature.

Explainer

The fetch API allows simplified access to HTTP protocol methods, enabling client-server communication. The fetch API can be called with just one argument (path) to use the GET method, but it also supports other methods like POST, PUT, DELETE.

Additional Context

For more information you can visit the: https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API

Glam Up My Markup: Camp Activities with stars (particles)

Lucas Cruz — Fri, 29 Mar 2024 17:10:22 +0000

This is a submission for DEV Challenge v24.03.20, Glam Up My Markup: Camp Activities

What I Built

I build a interface with three principal colors, black, white and purple. The forms is purple, the blackground is black because I like dark theme, and starts white. Next to form there stars - Small circles white that move it-

Demo

github: https://github.com/olucascruz/frontendChallengeDevTo

Journey

Firstly, I selected a color palette consisting of purple, black, and white. While the form serves as the main element of the interface, I decided to add a new element for me: particles, commonly used in game development. With a basic knowledge of how to implement them, I began by creating a div to store the particles, assigning it the class 'particles', and then created additional divs to represent the particles themselves, with the class 'particle'. Initially, I attempted to position the particles randomly using the 'position: absolute' property and random margins, but soon realized that this did not produce the desired effect. After some research, I discovered that setting the position of the particles as 'position: relative' would allow me to move them using the 'top' and 'left' properties without the need for margins, resulting in the desired behavior.

The generation of random positions was implemented using JavaScript. Additionally, I created two CSS animations: one to simulate the glow of the particles and another for their movement. I noticed that when the particles glowed and moved simultaneously, the effect seemed strange. To correct this, I adjusted the speed of the animation for each particle individually, using JavaScript for this purpose.

Subsequently, I made the interface responsive. To achieve this, I used media queries to center the form when the screen was smaller and to send the particles behind the form. This configuration required that the div with the class 'particles' and the section containing the form had the 'position: absolute' property, allowing them to occupy the same space without issues.

Finally, in the form, I used a purple color with a gradient, and if you hover the mouse over it, there is a white shadow around it. The button also has this behavior, with the addition that it also changes color, and when clicked, the form disappears, and a message appears.

LICENSE CODE: MIT

Propriedades ACID de uma transação em banco de dados.

Lucas Cruz — Mon, 25 Mar 2024 01:55:26 +0000

Talvez você já tenha escutado sobre propriedades ACID de transações em banco de dados em algum lugar mas não entenda completamente sobre o que se trata, então esse artigo veio para esclarecer suas dúvidas.

O que são: As transações ACID são um conjunto de propriedades de um banco de dados relacionais que garante que as operações sejam executadas de forma segura e confiável.

Bem vamos ao significado das letras:
A = Atomicidade
C = Consistência
I = Isolamento
D = Durabilidade

Antes de seguimos para a explicação de cada propriedade acho importante dar um passo trás e explicar o que são transações e operações.

Operações

Ação específica realizada em um banco de dados, como SELECT, INSERT, UPDADE, DELETE

Transações

São unidades lógicas de trabalho que são composta por uma ou mais operações.

Atomicidade

Garante uma transação seja tratada como uma unidade indivisível todas as operações de uma transação sejam concluídas com sucesso, para que ela seja aplicada ao banco de dados.

Se durante a transação alguma operação falhar toda a transação será desfeita (rollback).
Se todas as operações derem certo então a transação é salva no banco de dados (commit).

Caso: Transação Bancária

Digamos que temos a conta A e a conta B.
A conta A faz um depósito na conta B, ou seja uma operação de UPDATE na conta A e na conta B, se uma dessas operações falharem, ambas devem ser desconsideradas.

Consistência

Garante que cada transação siga todas as regras e restrições definidas durante a criação do banco de dados sejam obedecidas. Como tipo de dado, relacionamentos por chave estrangeira entre outras devem ser seguidos para que a transação seja executada com sucesso

Isolamento

Garante que cada transação seja executada isoladamente, nenhuma transação pode interferir no funcionamento de outra.

Durabilidade

Garante que uma vez que a alteração é salva, ela permanece no banco de dados e só pode ser alterada por outra transação.

Referências
https://www.oracle.com/database/what-is-database/

https://pt.wikipedia.org/wiki/Transa%C3%A7%C3%A3o_(banco_de_dados)

Tipos em Python

Lucas Cruz — Thu, 21 Mar 2024 06:08:46 +0000

Estou fazendo um bootcamp com foco em python pela DIO e decidi compartilhar um pouco do conteúdo que estou aprendendo/revendo (como eu já programo em python a um tempo muitas coisas são revisitas).

Tipos de dados

Os tipos de dados definem as características e comportamentos de um valor para o interpretador.

IMPORTANTE: É importante entender que em python todas as variáveis são objetos e sendo objetos elas tem seus métodos.

Python é uma linguagem de tipagem dinâmica, o que significa que você pode modificar o tipo de uma variável sem fazer cerimônia como:

variable = 10 
variable = "now is a string"

Como visto no exemplo acima nem precisa citar qual é o tipo como em outras linguagens como C# que seria algo assim:

int number = 10;
float floatNumber = 5.5f;

Ok, voltando ao python, os seus tipos:

Texto -> str
Numérico -> int, float, complex

int são os números inteiros tais como: 1, 2, 3

float são números com ponto flutuante tais comos: 0.1, 0.2, 3.14159265359

PERA, algo novo para mim, o que é um complex? certamente não é algo do dia a dia, a primeira coisa que fiz ao ver isso foi perguntar ao Chat GPT. Segue a conversa abaixo::

Me: o que é um complex em python?

ChatGPT

Em Python, um complex é um tipo de dado numérico que representa um número complexo. Um número complexo é composto por uma parte real e uma parte imaginária, onde a parte imaginária é multiplicada pelo número imaginário "i", que é a raiz quadrada de -1.

Em Python, os números complexos são representados pela seguinte sintaxe:

x = <parte real> + <parte imaginária>j

Onde e são números reais, e j representa a unidade imaginária. Por exemplo:

z = 3 + 4j

Neste exemplo, z é um número complexo com parte real 3 e parte imaginária 4. Python fornece várias funções e operações para trabalhar com números complexos, incluindo operações aritméticas, como adição, subtração, multiplicação e divisão, bem como funções específicas, como abs() para calcular o módulo (ou magnitude) de um número complexo.

OK tendo a explicação de que o tipo complex permite trabalhar com números imaginários podemos seguir adiante.

Sequência -> list, tuple, range
Simplificando:
Listas = mutáveis
Tuplas = imutáveis
range = A função range do Python gera uma lista de números que geralmente são usados em muitas situações para iteração, como no loop for ou em muitos outros casos.

Mapa -> dict
Dicionário basicamente uma tabela de chave valor

dictionary = {1:"primeiro"} // o 1 é a chave  o "primeiro" o valor

Coleção -> set, frozenset

Um set é basicamente uma coleção que não permite valores duplicados, o que pode ser bastante útil.

Agora o frozenset eu realmente não uso no dia dia - após uma pesquisa descobrir que é um set só que imutável (como o nome meio que já diz)

Booleano -> bool
Pode assumir os valores os valores True (verdadeiro) ou False (falso)

Binários - bytes, bytearray, memoryview

O tipo bytes em Python representa uma sequência imutável de bytes. Ele é usado para armazenar dados binários, como imagens, arquivos de áudio, ou qualquer outro tipo de dados que não sejam de texto.

O tipo bytearray é semelhante ao tipo bytes, mas é mutável, o que significa que seu conteúdo pode ser alterado após a criação.

O tipo memoryview em Python permite acessar o conteúdo de objetos de bytes (ou outros objetos de buffer) sem fazer cópias desnecessárias na memória.
Ele fornece uma interface de baixo nível para acessar os dados armazenados em um objeto de buffer, como um objeto bytes ou bytearray, sem a necessidade de converter o objeto inteiro em outro tipo de dados.

Cadê meus zeros? Sobre tipos em banco de dados.

Lucas Cruz — Fri, 15 Mar 2024 21:25:00 +0000

Estava eu codando, mais um dia comum, quando de repente acontece um erro.

O valor que deveria ser salvo aparece na interface diferente do valor que eu digitei, nesse momento apertei ctrl+c para parar a execução do código, e rodei ele outra vez com npx expo start.

O banco de dados recarregou e ali estava outra vez o valor errado, eu estava testando a inserção de um código e como teste usei "0000000000" porém o que aparecia na lista era apenas 0.

Depois de reiniciar a segunda coisa que pensei foi que em algum lugar do código deve está convertendo para inteiro (Sim, eu estava usando JavaScript), mas ao analisar o código parecia tudo ok.

Até lembrar do tipo que estava usando no banco de dados, os Ids eram do tipo inteiro. Então tudo fez sentido! Não posso salvar dados que tenham zeros a esquerda dessa forma:

tx.executeSql(
'CREATE TABLE IF NOT EXISTS Machine (id INTEGER PRIMARY KEY, is_available INTEGER)',
[], 
()=>{console.log("successful create Machine")}, 
()=>{console.error("error: create Machine")})

Para resolver essa questão bastava modificar o tipo para texto.

tx.executeSql(
'CREATE TABLE IF NOT EXISTS Machine (id TEXT PRIMARY KEY, is_available INTEGER)',
[], 
()=>{console.log("successful create Machine")}, 
()=>{console.error("error: create Machine")})

Agora sim o app consegue adicionar itens com zeros a esquerda:

Concluindo

É sempre importante verificar os tipos de dados que está usando no banco de dados, para não ocorrer erros como este e perder seus zeros ou pior.
Apesar parecer intuitivo usar um tipo numérico como inteiro prefira usar texto quando o número que for usar não for usado para cálculos ou seja que não precisem necessariamente ser um número.
Façam testes.

Substituindo ternários por switch-case em React-Native

Lucas Cruz — Thu, 14 Mar 2024 19:29:28 +0000

Recentemente lendo alguns posts sobre react-native encontrei uma forma de melhorar um componente. Originalmente, eu o havia implementado com ternários, mas como se tratava de múltiplos estados possíveis tornava o código difícil de entender e manter.

stateModal === "wait" ? <>...</> 
: 
stateModal === edit ? <>...</> 
: 
stateModal === "delete" ? <>...</> 
:
stateModal === "finish" ? <>...</> 
: null

Basicamente eu tenho um componente de modal que tem alguns estados: wait, edit, delete, finish

A forma que encontrei para melhorar.

Definindo switch-case

const switchModalState = () => {
        switch (stateModal) {
            case "wait":
                return (
                  <>...</>
                    )    

            case "edit":
                return (
                    <>...</>
                    )

            case "delete":
                return (
                    <>...</>
                    )

            case "finish":
                return (
                    <>...</>
                )

            default:
                return (
                    <>...</>
                    )
        }


    }

Chamando função para renderizar

return(
        <Modal
        visible={modalVisible}
        animationType="slide"
        transparent={true}
        onRequestClose={() => setModalVisible(false)}
        >
            <View style={styles.modalContainer}>
                <View style={styles.modalContent}>
                    {switchModalState()}
                </View>
            </View>
        </Modal>

        )
}

Concluindo

Dessa forma fica mais simples para que outros desenvolvedores entendam o código e também facilita a manutenção, tornando mais fácil adicionar estados novos, ou editar um estado específico. Investir tempo em uma estrutura bem definida para lidar com os estados do modal não apenas facilita o trabalho para mim como desenvolvedor, mas também para qualquer pessoa que precise entender ou modificar o código no futuro.

Se quiser visualizar o código atualmente: https://github.com/olucascruz/control_equip/blob/main/src/components/ModalEditDelete.jsx

Refs:
https://dev.to/girordo/algumas-das-melhores-praticas-que-utilizo-diariamente-41c4
https://stackoverflow.com/questions/46592833/how-to-use-switch-statement-inside-a-react-component

Criando uma interface de escolha de fases em UNITY

Lucas Cruz — Sun, 10 Mar 2024 00:03:30 +0000

(Texto ainda em desenvolvimento)

Estou criando um jogo mobile e nele haverá várias fases. É sempre bom ter uma tela que mostra as fases disponíveis e as fases trancadas.

Primeiramente, antes de ir para Unity, geralmente desenho a interface no Figma, mas sinta-se à vontade para usar qualquer outra aplicação semelhante. Então, obtive esse resultado inicial:

A partir dessa ideia, vamos criar essa interface em Unity e torná-la interativa.

Primeiro, como no Unity não temos objetos de UI como círculos por padrão, irei criar uma imagem com o editor de imagens GIMP:

Então, para trazer para o Unity, toda essa parte será feita com o objeto Canvas. Os objetos interativos para selecionar fases serão botões TextMeshPro, as barras serão raw images e o texto será um TextMeshPro padrão.

A estrutura ficou da seguinte forma:

E a interface assim:

interface no simulador

A partir dessa interface pronta, é hora de pensar em uma estratégia para quando o usuário apertar o botão da fase escolhida e esse botão passar informações para a cena de jogo. Também por código, mudar o estado de disponibilidade do botão, para só permitir o clique nas fases já desbloqueadas.

Botões

Para fazer os botões funcionarem você pode usar dois objetos

Esses objetos ficam com os scripts de mudança de tela e de definir os elementos do nível, nesse caso uso para colocar a skin do enemy.

SceneHandler:

using UnityEngine;
using UnityEngine.SceneManagement;

public class SceneHandler : MonoBehaviour
{
    public void LoadScene(string nameScene)
    {
        // Carrega a cena com o nome especificado
        SceneManager.LoadScene(nameScene);
    }

    public void ResetScene()
    {
        // Obtém o nome da cena atual
        string nameCurrentScene = SceneManager.GetActiveScene().name;

        // Recarrega a cena atual pelo seu nome
        SceneManager.LoadScene(nameCurrentScene);
    }

    public void Quit()
    {
        Application.Quit();
    }
}

Aqui eu uso a função LoadScene para carregar a cena de jogo, passando o nome dela por parâmetro.

e SetLevel:

public class SetLevel : MonoBehaviour
{
    [SerializeField] private List<Sprite> skinsEnemy;
    [SerializeField] private ElementsLevel configLevel;


    public void SetConfig(int num)
    {
        if (skinsEnemy.Count == 0)
        {
            Debug.LogError("Enemy skins list is empty");
            return;
        }

        if (num < 0 || num >= skinsEnemy.Count)
        {
            Debug.LogError("Provided number is out of bounds for the enemy skins list");
            num = 0;
        }

        Sprite currentSkinEnemy = skinsEnemy[num];
        configLevel.skinPaddleNPC = currentSkinEnemy;

    }
}

Aqui eu inicio uma lista de skins e um ScriptableObject que é a estratégia que estou usando para definir a skin do inimigo.

Em cada botão eu coloco o evento de click da seguinte maneira

Escolho a skin que vai ser usada, o número sendo de 0 até o número de skins que tenho até o momento e a cena é a mesma GameOne

Definindo o ScriptableObject

Para definir o scriptableObject faça assim:

[CreateAssetMenu(fileName = "ElementsLevel", menuName = "ElementsLevel", order = 1)]
/**
 * <summary>
 * Define game params.
 * </summary>
 */
public class ElementsLevel : ScriptableObject
{
    public Sprite skinPlayer;
    public Sprite skinPaddleNPC;
}

Com esse scriptable object eu defino a skin que será usada pelo npc e dentro do nivel eu defino ela no objeto do npc usando um script 'Config Level'.

public class ConfigLevel : MonoBehaviour
{

    [SerializeField] private SpriteRenderer paddleNPC;
    [SerializeField] private ElementsLevel configLevel;

    void Start()
    {
        paddleNPC.sprite = configLevel.skinPaddleNPC;
    }

}