A Codaqui tem o prazer de anunciar um curso especial sobre Educação Financeira, ministrado por Valnaire Nascimento, Mestre em Economia e especialista em finanças. Prepare-se para ser bem-vindo a um novo nível de consciência financeira.

Sobre o Curso​

A verdade é que ninguém nunca nos ensinou a lidar com dinheiro da forma correta. Aprendemos a trabalhar e a pagar contas, mas não a construir riqueza. Este curso foi desenhado para mudar essa realidade, pois a mudança ocorre como o primeiro passo.

O treinamento abordará desde a desconstrução de crenças limitantes até estratégias práticas de organização financeira, investimento e planejamento para o futuro.

📅 Cronograma​

O curso acontecerá em cinco encontros conduzidos por Valnaire Nascimento:

A participação acontece conforme a programação divulgada pela Codaqui. Para acompanhar inscrições e atualizações, consulte nossos canais oficiais.

Sobre a Instrutora​

Valnaire Nascimento é Mestre em Economia e Economista, formada pela Universidade Federal da Bahia (UFBA). Com graduação também em Ciências Contábeis, possui uma formação sólida e multidisciplinar que integra conhecimentos econômicos, financeiros e contábeis.

Experiência Profissional​

Com um perfil analítico e orientado a resultados, Valnaire conta com vasta experiência profissional nas áreas financeira, análise de crédito e contabilidade. Já ocupou posições de destaque como:

• Coordenadora de Contabilidade na Fundação Cultural do Estado da Bahia (Funceb)
• Analista Financeiro no IANDBEAS e na Bravo Caminhões e Ônibus
• Assessor Financeiro no Teatro Castro Alves

Filosofia de Trabalho​

"Porque, no final, não é o quanto você ganha que define sua vida financeira... é o que você faz com o que ganha."

O Que Você Vai Aprender​

• Módulo 1 - Mentalidade Financeira: Compreenda como comportamento e crenças influenciam decisões financeiras no dia a dia.
• Módulo 2 - Organização Financeira: Aprenda a controlar receitas e despesas para ter mais clareza sobre sua realidade financeira.
• Módulo 3 - Planejamento e Orçamento: Defina metas, prioridades e um orçamento aplicável à sua rotina.
• Módulo 4 - Juros e Crédito: Entenda como gerenciar crédito com responsabilidade e tomar decisões mais conscientes.
• Módulo 5 - Investimentos com Consistência: Conheça fundamentos para investir com regularidade e de acordo com seu perfil.
• Módulo 6 - Renda Passiva: Explore caminhos para construir novas fontes de renda no longo prazo.
• Módulo 7 - Planejamento de Longo Prazo: Estruture objetivos futuros com mais segurança, incluindo a análise de alternativas de previdência.

Para Quem é Este Curso?​

Este curso é ideal para:

• Pessoas que desejam parar de ser reféns do próprio salário e aprender a poupar;
• Profissionais que buscam organizar suas finanças, sair das dívidas e começar a investir;
• Qualquer pessoa interessada em alcançar a independência financeira.

A Codaqui é para todos que desejam aprender e crescer.

Como Participar?​

As inscrições estarão abertas em breve! Acesse o formulário de inscrição ou confira nossos links oficiais.

💼 LinkedIn da instrutora: linkedin.com/in/valnairenascimento

Reflexão Inicial​

• Quais crenças limitantes sobre dinheiro você tem repetido para si mesmo?
• Você sabe exatamente para onde seu dinheiro está indo todos os meses?
• Seu dinheiro está trabalhando para você ou você está trabalhando apenas para pagar contas?

Traga essas reflexões e prepare-se para transformar a sua realidade financeira!

A Associação Codaqui tem o prazer de anunciar um curso especial sobre Lógica de Programação e Python, ministrado por Paulinea, uma futura desenvolvedora apaixonada por gerar impacto social através da educação tecnológica.

Sobre o Curso​

Este material tem foco em uma abordagem simples e direta, com exemplos comentados para facilitar a compreensão. Todas as atividades práticas serão realizadas por meio de um compilador online gratuito chamado Programiz — sem precisar instalar nada no computador.

📅 Cronograma​

As aulas acontecerão às segundas e quartas-feiras, sempre às 20h30:

• 20/04/2026 (Segunda-feira)
• 22/04/2026 (Quarta-feira)
• 27/04/2026 (Segunda-feira)
• 29/04/2026 (Quarta-feira)

Sobre a Instrutora​

Paulinea está finalizando sua graduação em Análise e Desenvolvimento de Sistemas (ADS) pela PUCPR. Ela conheceu a Codaqui através do Carreira TI e se interessou fortemente pela proposta do projeto, pois estava em busca de realizar ações sociais na área de tecnologia.

Seu grande ponto forte é o ensino de Lógica de Programação e Python para iniciantes, com o objetivo de desmistificar a escrita de código e criar uma base sólida de aprendizado.

O Que Você Vai Aprender​

• Fundamentos da Lógica: Algoritmos, código binário e diferença entre linguagens de alto e baixo nível.
• Primeiros Passos no Python: Variáveis e tipos de dados (Strings, Inteiros, Flutuantes, Booleana).
• Entrada e Saída: Funções input() e print().
• Operadores: Relacionais, aritméticos e lógicos (AND, OR, NOT).
• Estruturas Condicionais: if, elif e else.
• Laços de Repetição: for com range() e while.
• Tratamento de Exceções: Blocos try e except.
• Funções: Definição com def, parâmetros e return.
• Listas e Matrizes: Índices, métodos append(), pop(), remove() e sort().
• Projeto Final: Construção completa de um Jogo da Velha funcional.

Para Quem é Este Curso?​

Esse curso é direcionado a pessoas que estão iniciando na programação — perfeito para quem nunca escreveu uma linha de código e quer descobrir como os softwares funcionam.

A Codaqui é para todos que desejam aprender e crescer, independentemente da idade ou experiência prévia.

Como Participar?​

As inscrições estarão abertas em breve! Acesse o formulário de inscrição ou confira nossos links oficiais.

• 📷 Instagram: instagram.com/paulinea.gp
• 💻 GitHub: github.com/paulineagp

Reflexão Inicial​

• Você consegue pensar na "receita" passo a passo para resolver um problema comum do seu dia a dia?
• Quais processos manuais e repetitivos da sua rotina poderiam ser automatizados por um software?
• Se você pudesse construir qualquer sistema no computador hoje, o que ele faria?

Traga essas ideias para a nossa primeira aula e prepare-se para começar a falar a língua dos computadores!

Em fevereiro de 2026, a Codaqui tem o prazer de anunciar um curso especial sobre Gestão e Produtividade, ministrado por Danilo Mesquita, empreendedor e especialista reconhecido na área.

Sobre o Curso​

O curso será dividido em três encontros que abordarão desde os fundamentos da produtividade pessoal até técnicas avançadas de gestão do tempo e resultados:

📅 Cronograma​

• 10/02 | 18/02 - Aula de Introdução
• 24/02 e 26/02 | 24/02 & 02/03 - Aulas de Aprofundamento

Sobre o Instrutor​

Danilo Mesquita é empreendedor à frente do Multificiente, plataforma dedicada a ajudar pessoas e empresas a alcançarem alta performance através da produtividade e colaboração.

Experiência Profissional​

Com mais de 25 anos de experiência em TI, Danilo construiu uma carreira sólida passando por diversas posições estratégicas, desde técnico de suporte até cargos de diretoria. Atualmente, ocupa os cargos de:

• Diretor de Operações na VEXPRO Business IT
• Diretor de Produtos e Soluções no Grupo SPRO

Especialização em Produtividade​

Desde 2013, Danilo dedica-se ao estudo e prática dos temas de produtividade e colaboração. Já realizou:

• Diversas palestras sobre o tema em várias cidades do Brasil
• Participação em grandes eventos da Microsoft Brasil
• Treinamentos em mais de 15 estados brasileiros para empresas de grande porte
• Promoção de conceitos de produtividade corporativa e colaboração com ferramentas Microsoft Office 365

Formação Acadêmica​

• Administração de Empresas - UniCEUB
• Gestão de Produtos - FGV
• Gestão Estratégica de Empresas - UNINTER (em andamento)
• Certificações em Microsoft, VMware, ITIL e Agile SCRUM

Filosofia de Trabalho​

"No que diz respeito ao empenho, ao compromisso, ao esforço, à dedicação, não existe meio termo. Ou você faz uma coisa bem feita ou não faz."
— Ayrton Senna

Danilo acredita que ser Multificiente é mais do que ser multitarefa: é saber unir eficiência e eficácia para alcançar resultados incríveis em pouco tempo. Sua abordagem integra conceitos de alta performance profissional com práticas esportivas, demonstrando que atitude de excelência permeia todas as áreas da vida.

O Que Você Vai Aprender​

Vamos atualizar em breve os tópicos específicos que serão abordados no curso. Fique atento!

Para Quem é Este Curso?​

Este curso é ideal para:

• Profissionais que desejam melhorar sua gestão do tempo e aumentar a produtividade;
• Líderes e gestores que buscam otimizar processos e resultados em suas equipes;
• Adolescentes e adultos interessados em desenvolver habilidades de organização pessoal e profissional!

A Codaqui é para todos que desejam aprender e crescer, independentemente da idade ou experiência prévia.

Como Participar?​

As inscrições já estão abertas! Acesse o formulário de inscrição:

• #Quero Estudar! - Formulário de Inscrição
• Nossos links oficiais

Mais Informações sobre o Danilo​

Para conhecer mais sobre o trabalho do Danilo Mesquita:

• 🌐 Site: multificiente.com.br
• 📱 Instagram: @danilo_mesquita
• 💼 LinkedIn: linkedin.com/in/dmesquita

Reflexão Inicial​

Antes mesmo de começar o curso, te convidamos a refletir:

• Quanto tempo você desperdiça por dia com distrações?
• Você consegue priorizar suas tarefas de forma eficiente?
• Quais são os maiores obstáculos para sua produtividade?

Traga essas reflexões para a primeira aula e prepare-se para transformar sua relação com o tempo e os resultados!

Mais do que o dinheiro, o tempo é um bem inestimável. Cuide dele!

Vale ressaltar que foi nosso primeiro ano usando completamente a ferramenta, então apesar de estarmos positivos financeiramente, encontramos alguns saldos a mais na conta e estamos tentando organizar para ter uma equivalência de 100% do saldo da nossa conta na Stone com a plataforma Open Collective.

Se você tiver qualquer dúvida ou precisar de mais informações, não hesite em participar das nossas reuniões semanais. Estamos sempre disponíveis para ajudar e esclarecer qualquer questão.

Agradecemos a todos pelo apoio contínuo e pela participação no evento. Continuaremos trabalhando para melhorar e trazer mais transparência e eficiência para nossos processos.

Dados no Open Collective

O que você vai aprender​

• Por que usar uma VM para projetos e laboratórios rápidos
• Como criar uma VM (visão geral) — foco no Azure (passos essenciais)
• Criar conta no Cloudflare e preparar o domínio
• Configurar Zero Trust / Access de forma básica
• Instalar e configurar o Cloudflare Tunnel (cloudflared) na VM
• Expor um serviço (ex.: piping server) através do túnel e testar

Motivador​

Projetos caseiros muitas vezes precisam ser acessíveis pela internet. Tradicionalmente isso exige um IPv4 público, que pode ter custo elevado ou ser limitado pelo provedor. O Cloudflare Tunnel permite que você exponha serviços locais por meio de um túnel seguro até a rede Cloudflare, sem precisar de IP público. No plano gratuito é possível reduzir custos e manter controle sobre DNS, políticas e roteamento.

Checklist rápido (pré-requisitos)​

• Conta em um provedor de nuvem (ex.: Azure) com permissão para criar uma VM.
• Conta gratuita no Cloudflare e domínio gerenciável no Cloudflare (DNS).
• Acesso SSH à VM.
  • Recomenda-se usar o painel do Provider apenas para instalar o Cloudflared, e depois usar o Browser SSH do Cloudflare.
• Ferramentas básicas: curl, sudo, systemd

Se alguma etapa não for possível (ex.: você não tem domínio), há alternativas: testar localmente com cloudflared tunnel run e usar um subdomínio temporário do Cloudflare durante o login interativo.

1 — Breve explicação: máquinas virtuais e por que usá-las​

Máquinas virtuais são instâncias isoladas que rodem um sistema operacional completo. Mesmo com arquiteturas modernas (containers, serverless), VMs ainda são úteis para:

• Ambientes persistentes para serviços de background
• Testes de rede e configurações de baixo nível
• Executar binários e ferramentas que exigem ambiente full-OS

Para este tutorial usamos uma VM como host do serviço (piping server) e do agente cloudflared que estabelece o túnel.

2 — Criando a VM (visão geral — Azure)​

2.0 - Pré-requisitos​

Instalação do Azure CLI e login na conta Azure.

az login

2.1 - Criar grupo de recurso​

az group create --name tutorial-codaqui --location eastus

2.2 - Criar a VM sem IPv4​

Para um fluxo mais controlado (e reprodutível) use um ARM template com um arquivo de parâmetros JSON — esse é o esquema esperado para o arquivo de parâmetros. Salve o JSON abaixo como vm-parameters.json e tenha o template ARM (vm-template.json) ao lado.

Exemplo do comando de deploy:

az deployment group create \
   --resource-group tutorial-codaqui \
   --template-file vm-template.json \
   --parameters @vm-parameters.json

        "virtualMachineName": {
            "type": "string"
        },
        "virtualMachineComputerName": {
            "type": "string"
        },
        "virtualMachineRG": {
            "type": "string"
        },
        "osDiskType": {
            "type": "string"
        },
        "osDiskSizeGiB": {
            "type": "int"
        },
        "osDiskDeleteOption": {
            "type": "string"
        },
        "virtualMachineSize": {
            "type": "string"
        },
        "nicDeleteOption": {
            "type": "string"
        },
        "adminUsername": {
            "type": "string"
        },
        "adminPassword": {
            "type": "secureString"
        }
    },
    "variables": {
        "nsgId": "[resourceId(resourceGroup().name, 'Microsoft.Network/networkSecurityGroups', parameters('networkSecurityGroupName'))]",
        "vnetName": "[parameters('virtualNetworkName')]",
        "vnetId": "[resourceId(resourceGroup().name,'Microsoft.Network/virtualNetworks', parameters('virtualNetworkName'))]",
        "subnetRef": "[concat(variables('vnetId'), '/subnets/', parameters('subnetName'))]"
    },
    "resources": [
        {
            "name": "[parameters('networkInterfaceName')]",
            "type": "Microsoft.Network/networkInterfaces",
            "apiVersion": "2022-11-01",
            "location": "[parameters('location')]",
            "dependsOn": [
                "[concat('Microsoft.Network/networkSecurityGroups/', parameters('networkSecurityGroupName'))]",
                "[concat('Microsoft.Network/virtualNetworks/', parameters('virtualNetworkName'))]"
            ],
            "properties": {
                "ipConfigurations": [
                    {
                        "name": "ipconfig1",
                        "properties": {
                            "subnet": {
                                "id": "[variables('subnetRef')]"
                            },
                            "privateIPAllocationMethod": "Dynamic"
                        }
                    }
                ],
                "networkSecurityGroup": {
                    "id": "[variables('nsgId')]"
                }
            }
        },
        {
            "name": "[parameters('networkSecurityGroupName')]",
            "type": "Microsoft.Network/networkSecurityGroups",
            "apiVersion": "2020-05-01",
            "location": "[parameters('location')]",
            "properties": {
                "securityRules": "[parameters('networkSecurityGroupRules')]"
            }
        },
        {
            "name": "[parameters('virtualNetworkName')]",
            "type": "Microsoft.Network/virtualNetworks",
            "apiVersion": "2024-01-01",
            "location": "[parameters('location')]",
            "properties": {
                "addressSpace": {
                    "addressPrefixes": "[parameters('addressPrefixes')]"
                },
                "subnets": "[parameters('subnets')]"
            }
        },
        
        {
            "name": "[parameters('virtualMachineName')]",
            "type": "Microsoft.Compute/virtualMachines",
            "apiVersion": "2024-03-01",
            "location": "[parameters('location')]",
            "dependsOn": [
                "[concat('Microsoft.Network/networkInterfaces/', parameters('networkInterfaceName'))]"
            ],
            "properties": {
                "hardwareProfile": {
                    "vmSize": "[parameters('virtualMachineSize')]"
                },
                "storageProfile": {
                    "osDisk": {
                        "createOption": "fromImage",
                        "managedDisk": {
                            "storageAccountType": "[parameters('osDiskType')]"
                        },
                        "diskSizeGB": "[parameters('osDiskSizeGiB')]",
                        "deleteOption": "[parameters('osDiskDeleteOption')]"
                    },
                    "imageReference": {
                        "publisher": "Canonical",
                        "offer": "0001-com-ubuntu-server-jammy",
                        "sku": "22_04-lts-gen2",
                        "version": "latest"
                    }
                },
                "networkProfile": {
                    "networkInterfaces": [
                        {
                            "id": "[resourceId('Microsoft.Network/networkInterfaces', parameters('networkInterfaceName'))]",
                            "properties": {
                                "deleteOption": "[parameters('nicDeleteOption')]"
                            }
                        }
                    ]
                },
                "securityProfile": {},
                "osProfile": {
                    "computerName": "[parameters('virtualMachineComputerName')]",
                    "adminUsername": "[parameters('adminUsername')]",
                    "adminPassword": "[parameters('adminPassword')]"
                }
            }
        }
    ],
    "outputs": {
        "adminUsername": {
            "type": "string",
            "value": "[parameters('adminUsername')]"
        }
    }
}
```

Observações:

• O template cria uma VM Ubuntu Linux (gratuita) com autenticação por senha.
• Use uma senha forte (exemplo: CoDAqui123!) ou altere no arquivo de parâmetros.
• Sem IP público, use o Azure Serial Console ou Azure Bastion para acessar a VM após o deploy.
• O Cloudflare Tunnel fará o roteamento, eliminando a necessidade de IP público fixo.

Depois do deploy, você pode conectar via console do Azure Portal (Serial Console) usando o usuário codaqui e a senha definida.

Observação: a VM precisa de saída para internet para que o cloudflared consiga estabelecer o túnel.

3 — Criar conta no Cloudflare e configurar DNS​

1. Crie uma conta gratuita em https://dash.cloudflare.com
2. Adicione seu domínio e aponte NS para o Cloudflare
3. No painel DNS, adicione um registro CNAME ou A para o subdomínio que você quer usar; mais adiante vamos mapear esse hostname para o túnel (Cloudflare criará o registro correto quando usarmos cloudflared tunnel route dns).

Dica: no plano gratuito você já tem acesso ao serviço de DNS e a funcionalidades básicas de Zero Trust (Access). Não é necessário contratar plano pago para este fluxo básico.

4 — Noções básicas de Zero Trust (opcional nessa etapa)​

O Zero Trust no Cloudflare (Access) permite proteger o acesso ao host com políticas (e.g., SSO, lista de usuários). Para um laboratório você pode:

• Criar uma aplicação em Access e exigir autenticação via GitHub/Google
• Usar políticas por endereço IP ou por identidade

Essas configurações ficam no painel "Zero Trust" (antigo Access) e podem ser aplicadas ao hostname que vamos criar.

5 — Instalar e configurar o Cloudflare Tunnel na VM​

Passos principais:

1. Instalar cloudflared
2. Logar o cloudflared na conta Cloudflare (gera um arquivo de credenciais)
3. Criar o túnel e mapear um hostname
4. Criar arquivo de configuração e rodar como serviço

Exemplo (Ubuntu/Debian):

# baixar o binário mais recente
curl -L -o cloudflared \
   https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64
chmod +x cloudflared
sudo mv cloudflared /usr/local/bin/

# fazer login (abre uma URL para autenticação no Cloudflare)
cloudflared tunnel login

# criar o túnel (gera um UUID)
cloudflared tunnel create lab-tunnel

# vincular um hostname DNS gerenciado pelo Cloudflare ao túnel
cloudflared tunnel route dns lab-tunnel app.example.com

# criar config em /etc/cloudflared/config.yml
sudo mkdir -p /etc/cloudflared
sudo tee /etc/cloudflared/config.yml > /dev/null <<'YAML'
tunnel: <TUNNEL-UUID>
credentials-file: /etc/cloudflared/<TUNNEL-UUID>.json
ingress:
   - hostname: app.example.com
      service: http://localhost:8080
   - service: http_status:404
YAML

# instalar como serviço systemd (opcional: cloudflared oferece comando helper)
sudo tee /etc/systemd/system/cloudflared.service > /dev/null <<'UNIT'
[Unit]
Description=Cloudflare Tunnel
After=network.target

[Service]
Type=simple
User=root
ExecStart=/usr/local/bin/cloudflared --config /etc/cloudflared/config.yml run
Restart=on-failure

[Install]
WantedBy=multi-user.target
UNIT

sudo systemctl daemon-reload
sudo systemctl enable --now cloudflared

Notas:

• Substitua <TUNNEL-UUID> e app.example.com pelos valores reais retornados pelos comandos.
• Se cloudflared tunnel login não puder abrir um navegador na VM, execute o login em uma máquina local e copie o arquivo de credenciais para a VM, ou use um Service Token/Account para automação.

6 — Exemplo: Deploy de um "Piping Server" local e exposição via Tunnel​

Para o exemplo vamos supor que exista um serviço HTTP simples rodando na porta 8080 (poderia ser o piping server ou qualquer app). Se você quiser testar rápido:

# exemplo rápido com Python (na VM)
python3 -m http.server 8080 --bind 127.0.0.1

Com o túnel configurado e o DNS apontado, a URL https://app.example.com ficará disponível publicamente e será roteada para a aplicação local.

Teste:

curl -I https://app.example.com

Você deve receber uma resposta HTTP 200 (ou o cabeçalho do servidor simples).

7 — Segurança e boas práticas​

• Use cloudflared tunnel route dns para que o Cloudflare gerencie o DNS do hostname
• Restrinja o acesso com Zero Trust/Access quando expor serviços administrativos
• Mantenha cloudflared atualizado
• Automatize o deploy do tunnel com scripts/secrets quando usar em produção

8 — Limitações e casos de uso​

• Cloudflare Tunnel não substitui redes privadas complexas ou balanceamento interno avançado
• Para serviços com alto throughput verifique limites do plano e latência
• Economiza custo de IP público e simplifica roteamento para pequenos serviços e laboratórios

Conclusão​

O Cloudflare Tunnel é uma solução prática para expor serviços rodando em VMs sem a necessidade de um IPv4 público dedicado. Para laboratórios e projetos pessoais ele reduz custo e adiciona camadas úteis de segurança e gestão via Cloudflare.

Se quiser, no próximo artigo podemos:

• Automatizar criação do túnel via CI/CD
• Integrar autenticação SSO (Zero Trust) ao hostname
• Expor múltiplos serviços com path-based routing

Se preferir que eu atualize também um passo a passo completo com prints, arquivos de configuração e exemplos de systemd mais avançados, me diga que eu adiciono na sequência.

Como instalar o GIT?​

📋 Pré-requisitos​

• Acesso ao terminal/linha de comando
• Privilégios de administrador (sudo)

🐧 Linux​

Distribuições baseadas no Debian (Ubuntu, Mint, etc.)​

sudo apt update && sudo apt install git

Distribuições Fedora/RHEL/CentOS​

sudo dnf install git

Arch Linux​

sudo pacman -S git

🍎 macOS​

Usando Homebrew (Recomendado)​

brew install git

Usando MacPorts​

sudo port install git

💡 Curiosidade: O Homebrew também pode ser usado no Linux como alternativa aos gerenciadores nativos!

🪟 Windows​

Opção 1: Windows Subsystem for Linux (WSL)​

1. Instalar WSL:

   wsl --install -d Debian
   

2. Configurar WSL 2 como padrão:

   wsl --set-default-version 2
   

3. Instalar Git no Debian:

   sudo apt update && sudo apt install git
   

   Veja o tópico acima de como instalar no Debian.

Opção 2: Instalação Nativa​

Download automático via PowerShell:

winget install --id Git.Git -e --source winget

Caso não funcione, você pode baixar o instalador diretamente do site oficial: git-scm.com. e instalar manualmente a versão GUI.

⚙️ Configuração Inicial​

Configurar identidade:

git config --global user.name "Seu Nome"
git config --global user.email "seuemail@exemplo.com"

No VSCode

1️⃣ Clonar um repositório para testar o funcionamento(metodo fácil):

# Institucional da codaqui por exemplo
git clone https://github.com/codaqui/institucional.git

🚀 Clonando um Repositório no VSCode​

2️⃣ No seu VSCode, clique no ícone de controle de código-fonte

3️⃣ Clique em CLONE REPOSITORY

4️⃣ Na parte inferior da barra de pesquisa, selecione CLONE FROM GITHUB

5️⃣ Será exibida a seguinte mensagem:

6️⃣ Clique em ✅ Allow

7️⃣ Faça login no GitHub 🔑

Se esta seção ainda não foi preenchida, você pode expandi-la explicando os principais recursos do SFML, como:

• Renderização gráfica: Criação de formas, sprites, texto e outros elementos visuais.
• Manipulação de áudio: Reprodução de sons e músicas.
• Gerenciamento de janelas: Criação e controle de janelas de aplicação.
• Entrada do usuário: Detecção de eventos de teclado, mouse e outros dispositivos.
• Rede: Comunicação via TCP e UDP.

Neste projeto, optei por criar um exemplo simples — um cubo 3D — com o objetivo de apresentar de forma prática o que é possível construir utilizando este framework. A ideia é fornecer uma base visual e acessível para quem está começando, demonstrando como estruturas tridimensionais básicas podem ser renderizadas com facilidade.

Este cubo serve como ponto de partida para explorações mais avançadas, como animações, interações, iluminação e composição de cenas mais complexas. A imagem abaixo ilustra o resultado da implementação e evidenciam parte do potencial que essa ferramenta oferece para o desenvolvimento gráfico.

Configuração do Ambiente para Desenvolvimento com SFML

Instalação do SFML​

Para iniciar o processo, precisamos instalar o framework SFML. A instalação varia de acordo com o sistema operacional. No caso, estou utilizando Debian 12 (image-6.1.0-34-amd64). Para instalar o SFML, execute o seguinte comando no terminal(é para funcionar em distros baseadas no debian):

sudo apt-get install libsfml-dev

Windows usando vcpkg.​

vcpkg install sfml

Arch usando pacman.​

sudo pacman -S sfml

Fedora usando dnf.​

sudo dnf install SFML-devel

Instalação do GCC/G++​

Após instalar o SFML, é necessário garantir que o compilador GCC/G++ esteja instalado. Para isso, utilize o comando:

Debian(distros baseadas no debian)​

sudo apt install build-essential

No Windows, você pode instalar o GCC/G++ utilizando o MinGW ou MSYS2:

1. MinGW(recomendo):

   • Baixe o instalador do MinGW no site oficial: MinGW.
   • Durante a instalação, selecione os pacotes para o compilador GCC/G++.

2. MSYS2:

   • Baixe e instale o MSYS2: MSYS2.
   • No terminal do MSYS2, execute o comando:

     pacman -S mingw-w64-x86_64-gcc
     

Arch Linux​

No Arch Linux, use o gerenciador de pacotes pacman para instalar o GCC/G++:

sudo pacman -S base-devel

Fedora​

No Fedora, use o gerenciador de pacotes dnf para instalar o GCC/G++:

sudo dnf groupinstall "Development Tools"
sudo dnf install gcc-c++

Criando o projeto

1. Crie um diretório para o projeto:

   mkdir meu_projeto_sfml
   cd meu_projeto_sfml
   

2. Crie um arquivo de código-fonte principal, main.cpp:

   nano main.cpp
   

3. Escreva o seguinte código básico no arquivo main.cpp para testar a integração com o SFML:

   #include "WIN.h" // Inclui o arquivo de cabeçalho da classe WIN
   
   int main()
   {
      // Cria um objeto de janela com (largura, altura, título, cor de fundo e taxa de quadros especificados)
      WIN window(800, 600, "Cubo", sf::Color::Black, 160);
   
      // Executa o loop principal da janela
      window.run();
   
      return 0; // Encerra o programa
   }
   // fontes materiais:
   // https://www.sfml-dev.org/tutorials/2.5/window-window.php
   // https://www.sfml-dev.org/tutorials/2.5/graphics-shape.php
   // https://www.sfml-dev.org/tutorials/2.5/graphics-vertex-array.php#vertex-array
   
   // calculos matematicos:
   // https://pt.wikipedia.org/wiki/Matriz_de_rota%C3%A7%C3%A3o
   

4. Crie um arquivo de código-fonte principal, CUBE.cpp:

   nano CUBE.cpp
   

5. Escreva o seguinte código básico no arquivo CUBE.cpp para testar a integração com o SFML:

   #include "CUBE.h"
   #include <cmath>
   
   // Construtor
   // Inicializa o cubo com um tamanho especificado e define sua cor padrão como branca
   Cube::Cube(float size) : color(Color::White) {
      // Define os vértices do cubo
      // Calcula metade do tamanho para posicionar os vértices em torno da origem
      float halfSize = size / 2.0f;
      vertices = {
         Vector3f(-halfSize, -halfSize, -halfSize), // Vértice 0
         Vector3f(halfSize, -halfSize, -halfSize),  // Vértice 1
         Vector3f(halfSize, halfSize, -halfSize),   // Vértice 2
         Vector3f(-halfSize, halfSize, -halfSize),  // Vértice 3
         Vector3f(-halfSize, -halfSize, halfSize),  // Vértice 4
         Vector3f(halfSize, -halfSize, halfSize),   // Vértice 5
         Vector3f(halfSize, halfSize, halfSize),    // Vértice 6
         Vector3f(-halfSize, halfSize, halfSize),   // Vértice 7
      };
   
      // Define as faces do cubo (índices dos vértices)
      // Cada face é representada por 4 índices que apontam para os vértices
      faces = {{
         {0, 1, 2, 3}, // Frente
         {4, 5, 6, 7}, // Trás
         {0, 4, 7, 3}, // Esquerda
         {1, 5, 6, 2}, // Direita
         {0, 1, 5, 4}, // Topo
         {3, 2, 6, 7}, // Fundo
      }};
   }
   
   // Atualiza a rotação do cubo
   // Aplica rotações nos eixos X, Y e Z para todos os vértices do cubo
   void Cube::rotate(float angleX, float angleY, float angleZ) {
      // Calcula os cossenos e senos dos ângulos para otimizar os cálculos
      float cosX = cos(angleX), sinX = sin(angleX);
      float cosY = cos(angleY), sinY = sin(angleY);
      float cosZ = cos(angleZ), sinZ = sin(angleZ);
   
      // Itera sobre todos os vértices para aplicar as rotações
      for (auto &vertex : vertices) {
         // Rotação em torno do eixo X
         float y = vertex.y * cosX - vertex.z * sinX;
         float z = vertex.y * sinX + vertex.z * cosX;
         vertex.y = y;
         vertex.z = z;
   
         // Rotação em torno do eixo Y
         float x = vertex.x * cosY + vertex.z * sinY;
         z = -vertex.x * sinY + vertex.z * cosY;
         vertex.x = x;
         vertex.z = z;
   
         // Rotação em torno do eixo Z
         x = vertex.x * cosZ - vertex.y * sinZ;
         y = vertex.x * sinZ + vertex.y * cosZ;
         vertex.x = x;
         vertex.y = y;
      }
   }
   
   // Desenha o cubo na janela
   // Renderiza as faces do cubo na tela
   void Cube::draw(RenderWindow &window) {
      // Obtenha o tamanho da janela para centralizar o cubo
      Vector2u windowSize = window.getSize();
      float centerX = windowSize.x / 2.0f; // Coordenada X do centro da janela
      float centerY = windowSize.y / 2.0f; // Coordenada Y do centro da janela
   
      // Define as cores para cada face do cubo
      std::array<Color, 6> faceColors = {
         Color::Red,    // Frente
         Color::Green,  // Trás
         Color::Blue,   // Esquerda
         Color::Yellow, // Direita
         Color::Cyan,   // Topo
         Color::Magenta // Fundo
      };
   
      // Itera sobre as faces do cubo
      for (size_t i = 0; i < faces.size(); i++) {
         ConvexShape polygon; // Cria um polígono convexo para representar a face
         polygon.setPointCount(4); // Cada face tem 4 vértices
         polygon.setFillColor(faceColors[i]); // Define a cor da face
   
         // Define os pontos do polígono com base nos vértices da face
         for (int j = 0; j < 4; j++) {
               Vector3f vertex = vertices[faces[i][j]]; // Obtém o vértice correspondente
               polygon.setPoint(j, Vector2f(vertex.x + centerX, vertex.y + centerY)); // Ajusta para o centro da tela
         }
   
         // Desenha o polígono na janela
         window.draw(polygon);
      }
   }
   

6. Crie um arquivo de código-fonte principal, CUBE.h:

   nano CUBE.h
   

7. Escreva o seguinte código básico no arquivo CUBE.h para testar a integração com o SFML:

   #ifndef CUBE_H
   #define CUBE_H
   
   #include <SFML/Graphics.hpp>
   #include <array>
   
   using namespace sf;
   
   // Definição da classe Cube
   class Cube {
   private:
      // Vértices do cubo (8 vértices para um cubo 3D)
      std::array<Vector3f, 8> vertices;
   
      // Faces do cubo (6 faces, cada uma definida por 4 índices de vértices)
      std::array<std::array<int, 4>, 6> faces;
   
      // Cor do cubo
      Color color;
   
      // Matriz de projeção para simular a projeção 3D para 2D
      float projectionMatrix[4][4];
   
      // Função privada que atualiza a projeção dos vértices do cubo para coordenadas 2D
      void projectVertices();
   
   public:
      // Construtor da classe Cube, que inicializa o cubo com um tamanho específico
      Cube(float size);
   
      // Função pública que atualiza a rotação do cubo em torno dos eixos X, Y e Z
      void rotate(float angleX, float angleY, float angleZ);
   
      // Função pública que desenha o cubo na janela fornecida
      void draw(RenderWindow &window);
   };
   
   #endif // CUBE_H
   

8. Crie um arquivo de código-fonte principal, WIN.cpp:

   nano WIN.cpp
   

9. Escreva o seguinte código básico no arquivo WIN.cpp para testar a integração com o SFML:

   #include "WIN.h"
   
   // Construtor
   // O construtor da classe WIN inicializa os atributos da janela, como largura, altura, título, cor de fundo e limite de quadros por segundo.
   // Além disso, inicializa o cubo com um tamanho fixo de 300 e cria a janela SFML.
   WIN::WIN(int width, int height, const std::string &title, Color backgroundColor, int frameRateLimit)
      : cube(300) // Inicializa o cubo com tamanho 300
   {
      this->width = width; // Define a largura da janela
      this->height = height; // Define a altura da janela
      this->title = title; // Define o título da janela
      this->backgroundColor = backgroundColor; // Define a cor de fundo da janela
      this->frameRateLimit = frameRateLimit; // Define o limite de quadros por segundo
      
   
      // Cria a janela SFML com as configurações especificadas
      window.create(VideoMode(width, height), title, Style::Titlebar | Style::Close);
   }
   
   // Destrutor
   // O destrutor da classe WIN é declarado, mas não possui implementação específica no momento.
   WIN::~WIN() {
      // Implementação do destrutor (vazia por enquanto)
   }
   
   // Inicializa a janela
   // Configura o limite de quadros por segundo e limpa a janela com a cor de fundo especificada.
   void WIN::initWindow() {
      window.setFramerateLimit(frameRateLimit); // Define o limite de quadros por segundo
      window.clear(backgroundColor); // Limpa a janela com a cor de fundo
   }
   
   // Loop principal da janela
   // O método run é responsável por executar o loop principal da aplicação.
   // Ele inicializa a janela, lida com eventos, atualiza o estado e renderiza o conteúdo.
   void WIN::run() {
      initWindow(); // Inicializa a janela
   
      // Loop principal da aplicação
      while (window.isOpen()) {
         handleEvents(); // Lida com os eventos da janela
         update();       // Atualiza o estado da aplicação
         render();       // Renderiza o conteúdo na janela
      }
   }
   
   // Lida com eventos
   // Este método processa os eventos da janela, como o fechamento da mesma.
   void WIN::handleEvents() {
      Event event; // Objeto para armazenar eventos
      while (window.pollEvent(event)) { // Verifica se há eventos na fila
         if (event.type == Event::Closed) { // Se o evento for de fechamento
               window.close(); // Fecha a janela
         }
      }
   }
   
   // Atualiza a janela
   // Atualiza o estado do cubo, aplicando uma rotação contínua.
   void WIN::update() {
      cube.rotate(0.01f, 0.01f, 0.01f); // Rotaciona o cubo em torno dos eixos X, Y e Z
   }
   
   // Renderiza a janela
   // Limpa a janela, desenha o cubo e exibe o conteúdo renderizado.
   void WIN::render() {
      window.clear(backgroundColor); // Limpa a janela com a cor de fundo
      cube.draw(window);             // Desenha o cubo na janela
      window.display();              // Exibe o conteúdo renderizado na janela
   }
   

10. Crie um arquivo de código-fonte principal, WIN.h:

    nano WIN.h
    

11. Escreva o seguinte código básico no arquivo WIN.h para testar a integração com o SFML:

    #ifndef WIN_H
    #define WIN_H
    
    #include <SFML/Graphics.hpp>
    #include "CUBE.h"
    
    using namespace sf;
    
    // Classe que representa a janela principal do programa
    class WIN {
    private:
       // Propriedades da janela
       RenderWindow window; // Objeto da janela SFML
       int width, height; // Largura e altura da janela
       std::string title; // Título da janela
       Color backgroundColor; // Cor de fundo da janela
       int frameRateLimit; // Limite de taxa de quadros por segundo
    
       // Objeto do cubo
       Cube cube; // Instância da classe Cube
    
    public:
       // Construtor
       WIN(int width, int height, const std::string &title, Color backgroundColor, int frameRateLimit);
       // Inicializa os atributos da classe com os valores fornecidos
    
       // Destrutor
       ~WIN();
       // Libera recursos, se necessário
    
       // Inicializa a janela
       void initWindow();
       // Configura a janela com os parâmetros fornecidos
    
       // Executa o loop principal da janela
       void run();
       // Mantém a janela aberta e gerencia o ciclo de eventos, atualização e renderização
    
       // Lida com os eventos da janela
       void handleEvents();
       // Processa eventos como entrada do teclado, mouse, etc.
    
       // Atualiza o estado da janela
       void update();
       // Atualiza os elementos da janela, como o cubo
    
       // Renderiza o conteúdo na janela
       void render();
       // Desenha os elementos na tela
    };
    
    #endif // WIN_H
    

12. Compile o código usando o g++:

g++ *.cpp -o meu_projeto -lsfml-graphics -lsfml-window -lsfml-system
./meu_projeto

Caso seja Windows

g++ *.cpp -o meu_projeto -I"path\to\vcpkg\installed\x64-windows\include" -L"path\to\vcpkg\installed\x64-windows\lib" -lsfml-graphics -lsfml-window -lsfml-system

path\to\... substitua pelo caminho correto.

No dia 22 de março, tive a oportunidade de palestrar no AWSOME WOMEN COMMUNITY SUMMIT BRASIL, abordando um tema desafiador e essencial: o papel de uma Site Reliability Engineer (SRE) em sistemas financeiros críticos. Durante a apresentação, compartilhei experiências do meu dia a dia na Stone Pagamentos, explorando desde os bastidores (backstage) até as práticas que tornam a gestão de incidentes em ambientes críticos mais segura e eficiente.

Contexto do Evento​

O AWSOME WOMEN COMMUNITY SUMMIT BRASIL foi idealizado para inspirar e empoderar mulheres na área de tecnologia. Reunindo profissionais de diversas áreas, o encontro proporcionou um espaço para o intercâmbio de conhecimentos e a discussão de temas que, muitas vezes, ficam à margem do discurso tradicional. Em um setor onde a confiabilidade dos sistemas é vital, a presença de mulheres líderes em engenharia e tecnologia reforça a importância da diversidade e da colaboração.

Preparação e Seleção de Conteúdo​

Escolha dos Tópicos​

Ao preparar a palestra, dediquei tempo para alinhar o conteúdo com os desafios enfrentados em sistemas financeiros críticos. Alguns dos principais pontos abordados foram:

• Backstage como Case: Compartilhei um case real da Stone Pagamentos, detalhando os processos e aprendizados dos bastidores na gestão de incidentes.
• Cultura Blameless: Expliquei como a ausência de culpa (blameless culture) é fundamental para incentivar a transparência e a melhoria contínua após incidentes críticos.
• Cenários Críticos de Incidentes: Demonstrei como identificar, analisar e responder a incidentes em sistemas financeiros, onde cada segundo conta.

Adequando a Linguagem​

Considerando o público predominantemente feminino, procurei transmitir os conceitos técnicos de forma acessível, enfatizando a importância da colaboração e da resiliência, e mostrando que desafios complexos podem ser vencidos com trabalho em equipe e uma postura de aprendizado constante.

Durante a Palestra​

Ao subir ao palco, fui recebida com entusiasmo e atenção. A energia do público impulsionou uma troca dinâmica de experiências e questionamentos. Alguns momentos de destaque incluíram:

• Apresentação do Backstage: Detalhei o case da Stone Pagamentos, mostrando os bastidores dos processos de resolução de incidentes em sistemas de pagamento, onde a pressão por alta disponibilidade e segurança é constante.
• Discussão sobre Cultura Blameless: Abordei como a prática de analisar erros sem buscar culpados fomenta um ambiente de inovação e aprendizagem, essencial para a evolução de processos críticos.
• Análise de Cenários Críticos: Demonstrei, por meio de exemplos práticos, como preparar e responder a incidentes, destacando a importância de planos de contingência e comunicação eficaz.

Reflexões e Lições Aprendidas​

A experiência foi enriquecedora em vários níveis:

• Empoderamento e Inclusão: Palestrar no AWSOME WOMEN COMMUNITY SUMMIT BRASIL reforçou a importância de encorajar a presença de mulheres em áreas tecnológicas e financeiras.
• Resiliência e Inovação: Compartilhar os desafios e as soluções dos bastidores demonstrou que a resiliência, aliada a uma cultura blameless, é a chave para a inovação em ambientes críticos.
• Aprendizado Coletivo: A troca de experiências não só fortaleceu a comunidade, mas também ampliou a visão sobre como transformar incidentes em oportunidades de melhoria contínua.

Conclusão​

Palestrar sobre o papel de uma SRE em sistemas financeiros críticos no AWSOME WOMEN COMMUNITY SUMMIT BRASIL foi uma experiência transformadora e inspiradora. Ao compartilhar os bastidores, a cultura blameless e os desafios dos cenários críticos, pude demonstrar que, mesmo sob pressão, a união e a busca por soluções colaborativas podem garantir a excelência operacional. Espero que este relato inspire outras mulheres a se aprofundarem no universo da engenharia de confiabilidade e a liderarem mudanças significativas em seus ambientes profissionais.

Um ponto importante a destacar é que este foi o último ano em que trabalhamos com dinheiro “legado” envolvendo CPFs e CNPJs. Isso explica a confusão que ocorreu entre as transferências via Stone e as transferências diretas entre CPFs. A partir do próximo ano, esperamos que esse processo seja muito mais simplificado e transparente.

Se você tiver qualquer dúvida ou precisar de mais informações, não hesite em participar das nossas reuniões semanais. Estamos sempre disponíveis para ajudar e esclarecer qualquer questão.

Além disso, ainda estamos aguardando o pagamento de dois patrocinadores que não foi recebido em nossa conta. Assim que esses pagamentos forem efetuados e essa pendência for resolvida, atualizaremos o saldo da Open Collective conforme o acordado.

Agradecemos a todos pelo apoio contínuo e pela participação no evento. Continuaremos trabalhando para melhorar e trazer mais transparência e eficiência para nossos processos.

Dados no Open Collective

• O limite do endereçamento de memória em uma linguagem de programação depende da arquitetura do computador e do sistema operacional em que o programa está sendo executado. Em sistemas de 32 bits, o endereçamento de memória é limitado a 4 gigabytes (2^32 bytes) de memória. Já em sistemas de 64 bits, o limite é muito maior, chegando a 18.4 milhões de terabytes (2^64 bytes) de memória.

• É importante considerar o limite de endereçamento de memória ao desenvolver um programa, especialmente quando se trabalha com grandes conjuntos de dados ou algoritmos que exigem muita memória. Se o programa exceder o limite de endereçamento de memória, pode ocorrer um estouro de memória (memory overflow) e o programa pode falhar ou apresentar comportamento inesperado.

• Para otimizar o uso da memória, é recomendado utilizar tipos de dados adequados para o tamanho dos valores que serão armazenados e liberar a memória alocada quando não for mais necessária, por meio de técnicas como a desalocação de memória (deallocating memory) ou o uso de coletor de lixo (garbage collector), dependendo da linguagem de programação utilizada.

Links: (mais aprofundado!!)

• Geeksforgeeks
• Tutorialspoint

Vídeos:

• Memory addressing - Apenas Legendado!
• Endereçamento de memória

Imagem de exemplo, endereçamento e seu funcionamento.​

0x**** são endereços de memoria, 0x representa que estão em hexadecimal.

Dentro dos endereços é possível notar a presença de 8 dígitos, no quais correspondem a 0, isso é exatamente o exemplo de tamanho de variável, nesse caso uma variável de 8 bits ou 1 byte.

Essa variável de 8 bits possui '2^8 = (256)' possibilidades de combinações de valores.

• Os valores vão:

  0 a 255 -128 a 127

O que acontece caso exceda esses 8 bits (memory overflow)?​

Simples, o valor estoura o limite de possibilidade, o que vai mudar é a percepção que cada linguagem, podem retornar erros ou simplesmente zerar a variável, pois ela só conta os 8 bits.

• Se ocorrer um "memory overflow" em uma variável de 8 bits, o valor excedente será truncado ou envolto (wraparound) para o intervalo válido. Por exemplo, se você tentar armazenar o valor 300 em uma variável de 8 bits, o valor será truncado para 44, pois 300 - 256 = 44. Isso ocorre porque 300 está fora do intervalo válido de 0 a 255.

• É importante ter cuidado com "memory overflows", pois eles podem levar a resultados inesperados e erros difíceis de depurar. É recomendado usar tipos de dados apropriados para o intervalo de valores que você espera armazenar, ou implementar verificações e tratamentos adequados para evitar "memory overflows".

De maneira matemática, segue esse fluxograma!​

Imagem demonstração matemática binária!​

Extra​

Como um hacker pode usar memory overflow como possível brecha!!​

Um hacker pode explorar uma vulnerabilidade de memory overflow para obter acesso não autorizado a um sistema ou executar código malicioso. Aqui estão algumas maneiras pelas quais isso pode ser feito:

1. Estouro de buffer: Um hacker pode enviar dados além dos limites de um buffer na memória, sobrescrevendo áreas adjacentes de memória. Isso pode levar à execução de código arbitrário ou à corrupção de dados sensíveis.

2. Injeção de código: Ao explorar um estouro de memória, um hacker pode injetar código malicioso na área de memória comprometida. Isso pode permitir que o hacker execute comandos remotos, obtenha acesso privilegiado ou execute ataques de negação de serviço.

3. Escalada de privilégios: Ao explorar uma vulnerabilidade de memory overflow, um hacker pode modificar os valores de variáveis de controle, como ponteiros de função ou permissões de acesso, para obter privilégios elevados no sistema comprometido.

4. Desvio de fluxo: Ao corromper o fluxo de execução de um programa por meio de um estouro de memória, um hacker pode redirecionar o fluxo para áreas de código malicioso. Isso pode permitir que o hacker execute ações não autorizadas ou contorne mecanismos de segurança.

Curta e Compartilhe!​

Se você chegou até aqui, peço que compartilhe com quem gosta desse tipo de conteúdo, para aumentar o engajamento e por também ser algo que é pouco falado! Meu muito obrigado!

Com mais de 8 anos de história, temos um histórico com mais de 250 eventos organizados e 7 conferências anuais, sempre apoiando e fortalecendo as comunidades e grupos existentes.

Nossa influência não se limita a fronteiras, alcançando inúmeras cidades e até mesmo países como Paraguai e Chile. Em 2021, estabelecemos uma parceria com a Codaqui, uma comunidade voltada para o público jovem. Em 2023, concluímos nossos primeiros grandes eventos em conjunto.

A edição desse ano será gratuita e os ingressos foram disponibilizados ao público desde o dia 14 de julho. Como estamos trazendo pessoas referências da nossa área e isso tem um custo, precisamos de um apoio mínimo da comunidade para cobrir os gastos.

Palestrantes​

• Jônatas Davi
• Lays Rodrigues
• Gustavo Caetano
• Prof. Anderson Burnes
• Munif Gebara
• Leonardo Elias
• Isabella Cruz de Oliveira
• Marco Ollivier
• Kelly Garcia
• Fernando Fabrício
• Marcondes Viana

Para conferir mais informações acesse o site do evento.

Transparência e Sustentabilidade​

O Open Collective oferece uma plataforma robusta e transparente para gerenciar apoios financeiros. Com recursos como relatórios detalhados de gastos, rastreamento de doações e visibilidade completa das finanças, podemos garantir maior transparência para nossos apoiadores.

Além disso, o Open Collective permite que os projetos sejam mais sustentáveis a longo prazo, facilitando a arrecadação contínua de fundos e a prestação de contas.

Maior Alcance​

Ao fazer parte do ecossistema do Open Collective, a Codaqui terá acesso a uma rede mais ampla de projetos e apoiadores. Isso nos ajudará a expandir nossa base de apoio e colaborar com outras comunidades.

O que muda para os apoiadores?​

Processo Simplificado​

Os apoiadores agora podem contribuir diretamente através da página da Codaqui no Open Collective. O processo é simples e transparente, permitindo que todos acompanhem como seus recursos estão sendo utilizados.

Novas Funcionalidades​

Com a migração, teremos acesso a recursos adicionais, como metas de financiamento por projeto e globais, recompensas para apoiadores e integração com outras ferramentas.

Conclusão​

A mudança para o Open Collective é um passo importante para a Codaqui. Estamos animados com as possibilidades que essa plataforma oferece e esperamos continuar crescendo e fortalecendo nossa comunidade.

Acesse nosso perfil no Open Collective e faça parte dessa jornada!

Espero que este post ajude a esclarecer os detalhes da transição. Se precisar de mais informações ou tiver outras dúvidas, estou à disposição! 😊🚀

Requisitos de uso​

• Linux ou UNIX
• Usar o terminal/linha de comando
• Usar comando com privilégios para mudar o proprietário

Comando para dar privilégio:

sudo 

Rodar terminal no root do sistema:

sudo su

Linux Chown Syntax

chown [Opção] [Usuário][:Grupo] [Arquivos/Diretórios] 

• [Opção] – O comando pode ser usado com ou sem opções adicionais.
• [Usuário] – O nome de usuário ou o ID de usuário numérico do novo proprietário de um arquivo.
• [:] – Use dois pontos ao alterar um grupo de um arquivo.
• [Grupo] – Alterar a propriedade do grupo de um arquivo é opcional.
• Arquivos/Diretórios – Alvo

Não necessariamente precisa de um grupo, veremos mais a baixo!!

Como alterar o proprietário de um arquivo no dia a dia?​

Terminal em root

chown Usuário0 Pasta/Arquivo

Terminal sem root

sudo chown Usuário0 Pasta/Arquivo

• Usuário0 – Nome do seu usuário.

• Pasta/Arquivo – Diretório ou Arquivo.

• Também é possível utilizar o UID(User ID) do seu usuário .

Supondo que essa pasta esteja com propriedade do Usuário1, assim você usar o comando acima, a propriedade dessa pasta passa para o Usuário0.

Como alterar o grupo de um arquivo?​

Terminal em root

chown :Grupo0 Pasta/Arquivo

Terminal sem root

sudo chown :Grupo0 Pasta/Arquivo

• Grupo0 – Nome do seu grupo.
• Pasta/Arquivo – Diretório ou Arquivo.

Imagens

Usando usuário:

Usando UID:

Mostrar permissões do diretório atual:

Pegar UID

Extra

• Ver seus grupos usando chgrp
• Pegar seu UID

sudo id -u USUARIO

A Codaqui, nascida em Maringá e integrada ao GitHub, é mais do que uma simples escola de programação – ela é uma próspera comunidade de aprendizado contínuo. 🌐🎓 Proporcionamos uma plataforma onde todos os interessados, independentemente do seu nível de experiência, podem aprender e contribuir. Em cada uma das nossas páginas, você encontrará um ícone que levará diretamente à edição dessa página, estimulando a todos a crescerem juntos na busca pelo conhecimento. 📚💡

Nosso objetivo principal é apoiar aqueles jovens que desejam no futuro criação de produtos tecnológicos, mas que, por várias razões, não tiveram acesso à educação tecnológica. Nós somos a ponte entre suas aspirações e a realização de seus sonhos. 💻🌈

Convidamos todos a explorar o mundo da tecnologia conosco, enquanto também celebramos e apoiamos o espírito do esporte em nossa comunidade. 🤗🎈 O próximo Campeonato de Skate de Marialva, que ocorrerá dia 05 de Novembro de 2023, às 15 horas, na Pista de Skate de Marialva, é uma excelente oportunidade para apoiarmos o esporte que tantos adoram e, ao mesmo tempo, convidarmos as pessoas a mergulharem na área de tecnologia com a Codaqui. 🛹🎖️🏆

Acreditamos que a educação e o esporte podem caminhar juntos, e são ferramentas capacitadoras para a juventude. Especialmente quando a educação está enraizada na tecnologia e a comunidade se une para apoiar eventos esportivos como este. 🎓🛹💼

Venha participar conosco! Desfrute do melhor do skate na Pista de Skate de Marialva e aproveite para descobrir o universo do desenvolvimento de software com a Codaqui. Educação e esporte, juntos, podem criar um futuro cheio de possibilidades! Venha fazer parte disso! 🎉🚀

O inédito Espaço Starter cumpriu a missão de introduzir o universo da programação para crianças e adolescentes.

A conferência anual DevPR, evento de atualização, network, compartilhamento de experiências e troca de conteúdo para programadores e tecnólogos chegou com tudo em 2023 na cidade de Maringá.

Sediada na Unicesumar, a grande inovação da edição foi o espaço Starter com um cronograma incrível de atividades lúdicas e dinâmicas de introdução à programação direcionado a crianças e adolescentes, parentes diretos dos inscritos na DevPR 2023.

A ideia surgiu com a organização da Codaqui e seus voluntários, em destaque Enderson Menezes e Ana Elisa Tubino. A Codaqui é uma escola de programação sem fins lucrativos disposta a democratizar o ensino sobre tecnologia e programação a jovens carentes.

O projeto da Codaqui com a DevPR para introduzir crianças e adolescentes ao universo da programação ganhou força e aconteceu!

O espaço Starter contou com uma equipe de voluntários preparados para receber toda essa galerinha com um cronograma de workshops e atividades lúdicas para três turmas divididas por idade.

A manhã começou agitada para a Turma Hopper, nomeada em homenagem à analista de sistemas criadora da linguagem de programação de alto nível, Grace Hopper. As crianças de 6 à 12 anos compreenderam a ideia de comando e algoritmo do computador através de uma atividade lúdica, competitiva e prática do Labirinto.

No período da tarde, as crianças puderam aplicar o conhecimento adquirido com o Desafio Scratch, no qual utilizaram a linguagem de programação Scratch para a criação de animações e jogos, com regras e comandos no laboratório de informática da universidade. Depois, as crianças participaram da atividade Programando Carrinhos Autônomos, na qual simularam o funcionamento do programa Arduino no computador e presenciaram o funcionamento dos carrinhos.

A Turma Turing, em tributo à Alan Turing, cientista da computação e idealizador dos conceitos de algoritmo e computador, composta por jovens de 13 a 16 anos, iniciou o cronograma com o workshop Caça aos Números com a construção de um algoritmo simples.

Mais tarde, na oficina de Jornada Criativa, cada participante teve a oportunidade de desenvolver seu primeiro site em linguagem HTML. A finalização da oficina contou como a eleição do site favorito pelos jovens.

Na Turma Lovelace, crianças de 10 a 15 anos conheceram a história da matemática Ada Lovelace, quem escreveu o primeiro algoritmo processado por uma máquina em 1842, depois, seguiram o cronograma com as atividades do Labirinto e Programando Carrinhos Autônomos e o Desafio Scratch.

Ao longo da tarde, os participantes contaram com um coffee break, com salgadinhos, bolo, refrigerante e suco, para repor as energias e continuarem com a criatividade a mil.

Para finalizar o dia de introdução à programação, as crianças e adolescentes das três turmas continuaram no ritmo de aprendizagem com mais conforto no ambiente Inspira com o filme de animação, lúdico e humorístico, Decodificando Emojis, seguido pelo desvendamento do famoso programa online Akinator com a apresentação de Mistérios da Internet.

Além das crianças e adolescentes dependentes diretos dos inscritos na conferência DevPR, o espaço Starter, organizado pela Codaqui, recebeu alunos do projeto comunitário Estrela Mãe de Paiçandu, Paraná. O espaço Starters foi sucesso total!

Ao fechamento do DevPR, algumas crianças ainda subiram ao palco principal da conferência para compartilhar a experiência incrível e inédita que tiveram e sonhos, como “eu quero ser programador”. Para sempre se lembrarem do projeto, os aspirantes mirins foram presenteados com o pato para debugar e um certificado online.

Gostaria de já fazer um agradecimento pela ajuda do Fundador da Codaqui, Enderson Menezes, que esteve me auxiliando no processo de criação desse projeto.

    - Procure por essas partes do códigos e faça oque é pedido abaixo!
      
      1° altere isso:
      ```yml
      on: 
          schedule:
            - cron: '0 13 * * *'
      
      ```
      para isso:
      
      ```yml
      on: push
      
      ```
      depois altere:
      ```bash
      chmod +X ./number.sh
      bash ./number.sh
      var=$( cat numero_final.txt )
      gh issue close $var
      
      ```
      para isso:
      
      ```bash
      #chmod +X ./number.sh
      #bash ./number.sh
      #var=$( cat numero_final.txt )
      #gh issue close $var
      
      ```
      
      2° quando terminar salve as modificações e espere o Actions validar o código, logo após a criação da primeira `Issue`, modifique o código novamente e volte como estava antes.
      
    - Para receber no E-mail leia nossa [README.md](https://github.com/codaqui/boletim-diario-seguranca/#readme), isso também é valido na sua aplicação.

=== "Com imagens"

    **1° Passo**

    - *Criar um repositório no Github!*


    ![step1](https://user-images.githubusercontent.com/63540372/220663763-e904004d-2093-4b09-9430-3e509843b4af.gif)

    **2° Passo**

    - *Criar scripts responsáveis por decodificar os dados.*
    

    ![step2](https://user-images.githubusercontent.com/63540372/220674190-36a2b387-5cc8-4814-bda0-e773bc25c8bc.gif)

    - Código usado para criação dos scripts: [script.sh](https://raw.githubusercontent.com/codaqui/boletim-diario-seguranca/main/script.sh) / [number.sh](https://raw.githubusercontent.com/codaqui/boletim-diario-seguranca/main/number.sh)!
    
    **3º Passo**

    - *Criar pasta .github e arquivo md(Corpo para gerar ISSUES).*
    
    
    ![step3](https://user-images.githubusercontent.com/63540372/220686276-87e4a0d7-15b0-4161-9660-2e23b1190d59.gif)
    
    - Aperte / depois de escrever .github para gerar uma pasta.
    - Código usado para criar o [boletim.md](https://raw.githubusercontent.com/codaqui/boletim-diario-seguranca/main/.github/boletim.md).
    
    **4° Passo**

    - *Criar pasta workflows e arquivo yml(Responsável por iniciar as tarefas).*
    
    
    ![step4](https://user-images.githubusercontent.com/63540372/220690915-99ea2900-9cc1-43de-becf-64a4d69128fa.gif)
    
    - Código usado para criar [boletim-diario.yml](https://raw.githubusercontent.com/codaqui/boletim-diario-seguranca/main/.github/workflows/boletim-diario.yml)
      
    **5° Passo**
    
    - *Para teste e funcionamento de tudo altere o arquivo yml como no gif abaixo*
    
    
    ![step5](https://user-images.githubusercontent.com/63540372/220696236-9cc17481-ea8b-4f3b-9710-df73612b1bad.gif)
    
    altere:
    ```yml
    on: 
        schedule:
          - cron: '0 13 * * *'
    
    ```
    para
    
    ```yml
    on: push
    
    ```
    E também altere:
    ```bash
    chmod +X ./number.sh
    bash ./number.sh
    var=$( cat numero_final.txt )
    gh issue close $var
    
    ```
    para
    
    ```bash
    #chmod +X ./number.sh
    #bash ./number.sh
    #var=$( cat numero_final.txt )
    #gh issue close $var
    
    ```
    - Depois de salvar espere o Actions validar o código e gerar uma nova `Issue`.
    - Em seguida altere novamente o código como o anterior do 4° passo.
    - Pronto Está tudo funcionando!
    - Para receber no E-mail leia nossa [README.md](https://github.com/codaqui/boletim-diario-seguranca/#readme), isso também é valido na sua aplicação.
         

Observações Importantes​

1° Observação​

• O código pode ser totalmente moldado por sua preferencia, só é preciso alterar o script.sh na linha abaixo

xmllint --html --xpath "/html/body/div[1]/main/section[2]/div/div/div/div/div/div[2]" boletim1.txt 1> boletim2.txt 2> /dev/null

• Especificamente tudo entre "", para isso você deve entender a estrutura da página, no qual será pego as informações.

2° Observação​

• O horário está marcado para o Actions disparar a Issue as 13h, 0GMT, 10h no horário de Brasilia!
• Você pode alterar o horário mudando o código mostrado abaixo:

  schedule:
     - cron: '0 13 * * *'

3° Observação​

• Quais quer problemas futuros com o sistema criado podem ser variados, devem ser analisados.
• Possiveis casos previstos:

1. JasonEtco/create-an-issue@v2 atualiza a maneira de gerenciar o aquivo .md na pasta .github.
2. A parte do bash realiza a tarefa sem atualizar o arquivo gerado no processo criando um erro, nesse caso você só da um push mostrado no ultimo passo mostrado acima.

4º Observação​

• Os nomes de arquivos e variáveis podem ser alteras, mas caso procure fazer isso, verifique se tudos os nomes modificados estão certos para funcionar.

Filho de peixe peixinho é! A Codaqui e a DevParaná anunciam o DevPR Starter – uma programação incrível exclusiva para dependentes, filhos, filhas, irmãos e irmãs, de 6 a 16 anos, dos participantes da Conferência DevPR 2023.

Durante o evento DevPR 2023, as crianças dependentes dos participantes terão a oportunidade de aprender programação de forma lúdica, com atividades divertidas e interativas, além de um lanche no período da tarde para recarregar as energias.

Temos uma equipe preparada e dedicada para atender as crianças e adolescentes e garantir um ambiente seguro de aprendizagem.

Como vai funcionar?​

Você que está participando do DevPR 2023 no Auditório poderá levar um dependente, e ele terá gratuitamente um evento e uma equipe disponível para ele. Para inscrição do seu ou sua dependente, acesse o portal do Sympla e inclua no carrinho o ingresso Starter (tipo A para 6 a 12 anos, ou tipo B para 13 a 16 anos).

Programação​

O Espaço Starter será divido em 4 ambientes, e você pode conferir todas as informações sobre palestrantes e atividades no site oficial do evento.

Palco Inspira​

Será aberto para todos os participantes do evento, e terá uma programação de palestras voltado para pessoas iniciantes.

Sala Invertida​

Será destinado a Workshops e atividades práticas.

Sala Hopper​

Será exclusivo para crianças de 6 a 12 anos.

Sala Turing (13 a 16 anos)​

Será exclusivo para jovens de 13 a 16 anos.

Dúvidas?​

Entre em contato por comunidade@devpr.org ou contato@codaqui.dev acesse o site oficial do evento.

Mas quem é a comunidade DevParaná?

É uma comunidade formada por desenvolvedores e desenvolvedoras do Paraná, com origem na cidade de Maringá, auxilia a promoção de meetups durante todo o ano, tendo no Meetup.com uma comunidade de quase 5000 pessoas. Toda a organização da comunidade é voluntária, assim como dos grupos de encontros filiados, e todos esses eventos durante o ano são financiados com o valor do ingressos da Conf, por isso a Conferência Anual da DevPR é atualmente o único evento não gratuito que a Comunidade organiza.

<span style:"text-align: center;">

Vamos fazer parte da história e participar da Edição 2023? Clique na imagem abaixo e você será direcionado para a página de ingressos.

A Comunidade do DevParaná é muito importante para região Norte do Paraná e tem grande relevância também nacional:

Apoie nossa comunidade! Seu patrocínio faz a diferença.

Resumo​

A Codaqui é uma escola de tecnologia sem fins lucrativos, que visa alcançar jovens e adolescentes de forma acessível, com aulas e atividades completamente digitais, que podem ser acompanhadas através de computador, tablet ou aparelho celular. Desta forma, conseguimos atingir alunos de todos os lugares do Brasil e de maior vulnerabilidade social.

Os alunos percorrem o conteúdo de forma autônoma, e recebem mentoria semanal, aplicando o conteúdo aprendido. Dessa forma, atuamos para desenvolver competências de autonomia, organização e aprendizado de conteúdo prático de desenvolvimento de software.

Baseados em Maria Montessori, adotamos um elemento importante de valorização dos alunos através de uma bolsa de estudos. Esta bolsa é uma contrapartida por 100% de presença nos encontros e aulas ou, se houver falta, esta deve ser justificada pelo responsável. A adoção desse conceito reforça nossos valores de responsabilidade, autonomia e comprometimento do aluno, além do vínculo com sua família.

Metas​

Entenda nossas metas para 2023:

Contamos com o seu apoio para conseguir alcançar as metas e impactar ainda mais jovens e adolescentes com nosso projeto, visando reduzir uma desigualdade social que só cresce, através da educação e do ensino de tecnologia, já que o mundo do trabalho se torna cada vez mais tecnológico, sem que as oportunidades de emprego e renda cheguem até a população de maior vulnerabilidade social.

Confira as contribuições e recompensas disponíveis na campanha:

Como apoiar?​

Para apoiar nossa campanha e receber suas recompensas, acesse: https://benfeitoria.com/projeto/codaqui.

Aproveite essa oportunidade de apoiar um projeto que muda vidas, e ainda receber mimos! Mas corra: é só até o dia 17/01/2023.

A Codaqui é uma escola de programação sem fins lucrativos que apoia jovens que desejam aprender a desenvolver produtos tecnológicos mas não possuem acesso a uma educação tecnológica por outros meios.

Para iniciar nossos trabalhos publicamente, depois de quase 2 anos nos organizando, gostaríamos de convidar toda comunidade para participar do Hacktoberfest com a Codaqui.

O Hacktoberfest é um evento anual que encoraja as pessoas a contribuir com projetos open source ao longo do mês de outubro.

Hacktoberfest da Codaqui​

Como participar​

Inscreva-se no Evento do Hacktoberfest​

• Registre-se em qualquer momento entre o dia 26 de setembro e o dia 31 de outubro de 2022, pelo site hacktoberfest.com utilizando sua conta do GitHub ou GitLab. Na Codaqui, nos utilizamos e recomendamos o uso do GitHub.
• Tenha 4 pull/merge requests aceitos em repositórios participantes do evento entre 1º de outubro e 31 de outubro de 2022 para completar o Hacktoberfest.
• Os 40.000 primeiros participantes a completar o Hacktoberfest poderão escolher para receber um entre dois prêmios: uma árvore plantada em seu nome, ou uma camiseta do Hacktoberfest 2022.

Escolha uma forma de contribuir​

Como colaborar criando um novo tópico em uma trilha existente?​

Como colaborar criando um novo exercício em um certificado existente?​

Como criar uma nova trilha?​

Como criar um novo certificado?​

Como auxiliar verificando se os conteúdos das trilhas permanecem online?​

Regras e Conduta​

Regras do Hacktoberfest​

• Seus Pull Requests (PR) e Merge Requests (MR) devem ser feitos dentro das datas limite do Hacktoberfest: entre 1º de outubro e 31 de outubro de 2022 (em qualquer fuso horário).
• Seus PR/MRs devem ser feitos em repositórios públicos e não arquivados. Repositórios que não estejam de acordo com os valores do Hacktoberfest serão excluídos da qualificação e os PR/MRs feitos nestes repositórios não contarão.
• Seus PR/MRs não devem ser SPAM. PR/MRs que forem marcados com uma label contendo a palavra “spam” pelos mantenedores não serão contados.
  • O Hacktoberfest usa o Node.js 16 RegEx engine com /\bspam\b/i para procurar labels de spam.
  • PR/MRs que também tenham o “hacktoberfest-accepted” label não poderão ser marcados como SPAM através de label.
  • PR/MRs que tiverem sido mergiados e não tiverem uma label contendo a palavra “invalid” não poderão ser marcados como SPAM através de label.
• PR/MRs que o sistema do Hacktoberfest detectar como SPAM também não serão contados.
• Qualquer usuário com dois ou mais PR/MRs de SPAM será desqualificado.
• Seus PR/MRs devem ser feitos em um repositório tagueado com o tópico “hacktoberfest”, ou com o label “hacktoberfest-accepted”.
• Suas PR/MRs não podem ser marcadas com o label “invalid”. PRs/MRs que forem marcados com o label “invalid” não serão contadas, a não ser que eles também estejam marcados com o label “hacktoberfest-accepted”.
  • O Hacktoberfest usa o Node.js 16 RegEx engine com /\binvalid\b/i para procurar labels de invalid.
• Suas PR/MRs devem ser mergeadas, ter o label “hacktoberfest-accepted” ou ter uma revisão com aprovação geral.
  • Suas PR/MRs não serão consideradas aceitas se forem apenas um rascunho.
  • Se sua PR/MR estiver sendo aceita para o Hacktoberfest por uma revisão com aprovação geral, ela também não pode estar encerrada.
• Assim que suas PR/MRs passarem por todas as checagens acima, será aceita para o Hacktoberfest após um período de 7 dias para revisão.
  • O Hacktoberfest continuamente avalia todas as checagens. Se o PR/MR falhar em qualquer uma das checagens durante esse período, o prazo de 7 dias será reiniciado.
  • Após os 7 dias para revisão completos, sua PR/MR será automaticamente aceita no Hacktoberfest, assumindo que ainda passe por todas as checagens. Uma vez aceita para o Hacktoberfest, eles pararão de checá-la.

Regras da Codaqui​

• Ao abrir uma Discussão, conforme orientado no “Como participar”, ela será transformada em um Pull Request e passará pela avaliação da Codaqui para que seja mergeado ou não.
• Atente-se a todas as instruções e regras de conduta da Codaqui ao fazer sua contribuição.
• Caso sua contribuição seja válida dentro de todas as regras do Hacktoberfest e da Codaqui, sua pontuação será recebida no prazo de 7 dias úteis a partir da checagem em que ela for considerada válida pela primeira vez, conforme já explicado nas regras do Hacktoberfest.

Teamplay​

• Respeite a primeira pessoa que sinalizou um problema, ela terá prioridade na resolução deste problema, e perderá a mesma se mantiver inativa por mais de 36 horas.
• Seja respeitoso com os demais ao enviar sugestões e participar de discussões. Todos estão participando com o mesmo objetivo de contribuir.

Repositórios​

Os repositórios da Codaqui que poderão receber PR/MRs durante o período do Hacktoberfest são:

• Institucional
• Certificado Python
• Certificado Javascript

Caso alguma nova trilha ou certificado seja criada por algum outro membro, o mesmo será adicionado aqui no prazo de 24 horas.

Fluxo​