DEV Community: Priscila Oliveira

Como escrever uma documentação técnica que realmente funciona

Priscila Oliveira — Wed, 03 Sep 2025 20:46:58 +0000

Se tem uma coisa que muita gente desenvolvedora ainda negligencia, é a documentação técnica.
Na correria de entregar feature atrás de feature, a doc acaba virando “a última prioridade”. Só que, quando alguém novo entra no time ou quando você mesma precisa revisitar um trecho de código meses depois, a falta de documentação pesa.

O que eu fiz aqui foi reunir o que vários autores e guias renomados trazem sobre o tema e condensar num só artigo. A ideia é simples: mostrar como escrever documentação que realmente ajuda e que não fica esquecida no repositório.

O que é uma boa documentação técnica?

Não é um manual gigante cheio de burocracia.
Documentação boa precisa seguir três princípios básicos, conhecidos como os 3Cs (do MDN Blog):

Clareza: usar linguagem simples, frases curtas e um conceito por vez.
Concisão: cortar redundâncias, evitar enrolação.
Consistência: manter termos e formatação iguais do começo ao fim.

Seguindo isso, você já garante que a doc é legível e não afasta quem lê.

Por que documentar?

O guia da UC Berkeley traz um ponto importante: documentação não é só para os outros.
É também para você mesma no futuro.

Os motivos são muitos:

você vai precisar desse código em seis meses e não vai lembrar de tudo;
outras pessoas podem usar e melhorar o seu trabalho;
times inteiros conseguem colaborar de forma mais eficiente;
a ciência (e a engenharia) avançam mais quando há transparência e reprodutibilidade.

Estrutura: do simples ao avançado

O MDN reforça que a doc precisa seguir um fluxo lógico:

Começar pelo o que é.
Explicar por que existe.
Mostrar como usar.
Só depois entrar em detalhes mais avançados.

Isso evita que a pessoa leitora se perca e garante que o aprendizado seja progressivo.

O ClickUp chama a atenção para outro ponto: sempre pense no público-alvo. Não é a mesma coisa escrever para devs sêniors, para o time de produto ou para usuários finais. Ajuste o tom.

Exemplos são essenciais

O Apidog insiste em algo que faz toda diferença: traga exemplos práticos.
Não só de código, mas também de cenários de uso.

Se você está explicando um hook, mostre como importá-lo e usá-lo em um componente.
Se é uma API, traga requests e responses reais.
Isso dá confiança para quem lê e acelera a adoção.

Acessibilidade não é opcional

O artigo da Zup e o MDN batem na mesma tecla: docs precisam ser inclusivas.

Isso significa:

sempre adicionar alt text em imagens;
usar links descritivos (“veja nosso guia de estilo” e não “clique aqui”);
adotar linguagem inclusiva;
pensar em quem usa leitores de tela.

Manutenção: doc viva, não morta

Outro ponto recorrente em todos os materiais, e bem destacado no Guia Dev, é que documentação não pode ser estática.

Ela precisa ser parte do fluxo de desenvolvimento.
Algumas práticas que ajudam:

revisar a doc em cada PR;
manter a versão do código vinculada à versão da doc;
ter responsáveis claros pela atualização;
revisar periodicamente (a cada sprint, por exemplo).

Estrutura mínima recomendada

Depois de cruzar os artigos do DX Platform, da Lari Maza e do ClickUp, dá para resumir uma estrutura que funciona bem para a maioria dos casos:

Descrição – o que é e por que existe.
Localização – path no repo, feature relacionada.
Escopo e objetivos – o que o leitor vai aprender ou conseguir.
Dependências – libs internas e externas.
Estrutura/API – props, métodos, parâmetros, retorno.
Exemplos de uso – código e cenário real.
Testes – como rodar, mocks, fixtures.
Troubleshooting/FAQ – erros comuns e soluções.
Acessibilidade – checklist básico.
Métricas/Observabilidade – logs, analytics, Sentry, etc.
Versionamento e manutenção – versão, data da última atualização, responsável.
Referências – links para Figma, RFCs, APIs externas, docs de negócio.

Conclusão

Documentar bem não é burocracia. É investimento em produtividade, em reduzir retrabalho e em melhorar a experiência de quem usa e mantém o software.

Não precisa ser perfeito, mas precisa ser útil.
Se você garantir clareza, concisão, consistência, exemplos práticos e manutenção contínua, já vai estar muito à frente da média.

Referências

Como Implementar o SDK da Unico em React Native: Um Guia Completo com Bridge Nativa

Priscila Oliveira — Thu, 29 May 2025 15:34:02 +0000

TL;DR: Criei uma implementação completa de bridge nativa para integrar o SDK da Unico em aplicações React Native, incluindo captura de selfies e documentos. Este artigo documenta todo o processo, os desafios enfrentados e as soluções encontradas.

🎯 O Problema que Me Motivou

Durante o desenvolvimento de uma aplicação React Native que precisava de verificação biométrica, me deparei com um desafio frustrante: como integrar o SDK da Unico com React Native?

Os Obstáculos Encontrados:

❌ Ausência de documentação específica para React Native
❌ Falta de exemplos práticos de implementação
❌ Complexidade da bridge nativa em duas plataformas
❌ Configurações obscuras que consumiram dias

Após muito pesquisar e não encontrar recursos adequados, decidi criar uma solução completa e compartilhar com a comunidade para que outros desenvolvedores não passem pelo mesmo sufoco.

🏗️ A Arquitetura da Solução

Desenvolvi uma arquitetura robusta que combina Clean Architecture no React Native com bridges nativas otimizadas para iOS e Android.

Visão Geral da Estrutura:

📦 Projeto
├── 🤖 Android (Kotlin)
│   ├── UnicoSdkModule (Bridge principal)
│   ├── UnicoConfig (Credenciais)
│   ├── UnicoTheme (Personalização)
│   └── UnicoSdkPackage (Registro)
├── 🍎 iOS (Swift)
│   ├── UnicoSdkModule (Bridge principal)
│   ├── UnicoConfig (Credenciais)
│   ├── UnicoTheme (Personalização)
│   └── Bridge Header (Interoperabilidade)
└── ⚛️ React Native (TypeScript)
    ├── Domain (Regras de negócio)
    ├── Data (Repositórios)
    ├── Infrastructure (Serviços)
    └── Presentation (UI e Hooks)

🤖 Implementação Android: Do Zero ao Funcionamento

1. Configuração do Gradle - A Base de Tudo

O primeiro desafio foi configurar corretamente o sistema de build do Android. O SDK da Unico não está no Maven Central, então precisei adicionar o repositório específico:

// android/build.gradle (projeto)
allprojects {
    repositories {
        google()
        mavenCentral()
        // 🎯 CRÍTICO: Repositório do SDK da Unico
        maven { url "https://maven-sdk.unico.run/sdk-mobile" }
    }
}

E no android/app/build.gradle, a dependência e configuração das variáveis de ambiente:

dependencies {
    implementation "io.unico:capture:5.33.0"
    // outras dependências...
}

android {
    defaultConfig {
        // 🔑 Injeção das variáveis do .env
        buildConfigField "String", "UNICO_BUNDLE_ID", "\"${project.env.get("UNICO_BUNDLE_ID") ?: ""}\""
        buildConfigField "String", "UNICO_HOST_KEY", "\"${project.env.get("UNICO_HOST_KEY") ?: ""}\""
    }
}

2. A Bridge Principal - UnicoSdkModule.kt

Esta é a peça central que conecta JavaScript ao SDK nativo. Implementei usando handlers especializados para melhor organização:

class UnicoSdkModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {

    @ReactMethod
    fun captureSelfie(promise: Promise) {
        runOnMainThread {
            try {
                // Validações de permissão e activity
                val activity = activity ?: run {
                    promise.reject("ERROR", "Activity not found")
                    return@runOnMainThread
                }

                if (!hasPermissions()) {
                    promise.reject("PERMISSION_DENIED", "Permissão de câmera necessária")
                    return@runOnMainThread
                }

                // Configuração do SDK
                val config = UnicoConfig()
                val theme = UnicoTheme()

                AcessoBio(activity, callback)
                    .setAutoCapture(true)
                    .setSmartFrame(true)
                    .setEnvironment(Environment.UAT)
                    .setTheme(theme)
                    .build()
                    .prepareCamera(config, selfieCallback)

            } catch (e: Exception) {
                promise.reject("ERROR", "Erro geral: ${e.message}")
            }
        }
    }
}

3. Gerenciamento de Credenciais

Criei uma classe específica para gerenciar as credenciais de forma segura:

class UnicoConfig : AcessoBioConfigDataSource {
    override fun getBundleIdentifier(): String {
        return BuildConfig.UNICO_BUNDLE_ID ?: ""
    }

    override fun getHostKey(): String {
        return BuildConfig.UNICO_HOST_KEY ?: ""
    }
}

As credenciais fluem do arquivo .env → react-native-config → BuildConfig → UnicoConfig.

🍎 Implementação iOS: Swift + Objective-C

1. Configuração do CocoaPods

No iOS, o gerenciamento de dependências é feito via CocoaPods:

# Podfile
target 'MeuApp' do
  # SDK da Unico
  pod 'unicocheck-ios'
  pod 'react-native-config', :path => '../node_modules/react-native-config'

  # Setup de permissões - apenas Camera
  setup_permissions(['Camera'])
end

2. Bridge Header - Conectando Worlds

Um dos maiores desafios no iOS foi configurar corretamente o bridge header para conectar Objective-C com Swift:

// MeuApp-Bridging-Header.h
#import <React/RCTBridgeModule.h>
#import <React/RCTEventEmitter.h>
#import <React/RCTViewManager.h>
#import <React/RCTUtils.h>

3. Arquitetura com Handlers Especializados

Implementei uma arquitetura modular no iOS usando handlers especializados:

@objc(UnicoSdk)
class UnicoSdkModule: RCTEventEmitter {

    @objc
    func captureSelfie(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
        DispatchQueue.main.async {
            guard let rootViewController = RCTPresentedViewController() else {
                reject("ERROR", "Não foi possível obter o view controller", nil)
                return
            }

            let captureHandler = SelfieCaptureHandler(
                resolve: resolve, 
                reject: reject, 
                eventEmitter: self
            )
            captureHandler.startCapture(from: rootViewController)
        }
    }
}

// Handler especializado para selfie
class SelfieCaptureHandler: NSObject {
    private let resolve: RCTPromiseResolveBlock
    private let reject: RCTPromiseRejectBlock
    private weak var eventEmitter: RCTEventEmitter?

    func startCapture(from viewController: UIViewController) {
        let manager = AcessoBioManager(viewController: viewController)
        manager?.setTheme(UnicoTheme())
        manager?.setEnvironment(.UAT)
        manager?.setSmartFrame(true)
        manager?.setAutoCapture(true)
        manager?.build().prepareSelfieCamera(self, config: UnicoConfig())
    }
}

4. Configuração de Variáveis no Info.plist

No iOS, as variáveis do .env são injetadas automaticamente no Info.plist:

<!-- Info.plist -->
<key>UNICO_SDK_KEY</key>
<string>$(UNICO_SDK_KEY)</string>
<key>UNICO_BUNDLE_IDENTIFIER</key>
<string>$(UNICO_BUNDLE_IDENTIFIER)</string>

⚛️ React Native: Clean Architecture

1. Estrutura de Camadas

Implementei uma arquitetura limpa e escalável:

// Domain Layer - Regras de negócio
export enum DocumentType {
  CNH_FRENTE = 'CNH_FRENTE',
  CNH_VERSO = 'CNH_VERSO',
  RG_FRENTE = 'RG_FRENTE',
  RG_VERSO = 'RG_VERSO',
  CPF = 'CPF',
}

export type CapturedItem = {
  id: string;
  type: ActionType;
  documentType?: DocumentType;
  result: UnicoResult;
  timestamp: string;
  status: DocumentStatus;
};

// Use Case - Lógica de captura
export const executeCaptureSelfie = async (
  unicoRepository: UnicoRepository
): Promise<CapturedItem> => {
  const result = await unicoRepository.captureSelfie();

  if (!result.success || !result.data) {
    throw new Error(result.error || 'Erro na captura da selfie');
  }

  return {
    id: `selfie_${Date.now()}`,
    type: ActionType.SELFIE,
    result: result.data,
    timestamp: new Date().toISOString(),
    status: DocumentStatus.CAPTURED,
  };
};

2. Infrastructure Layer - Conexão com Nativo

// UnicoSdkService.ts - Ponte com módulos nativos
import { NativeEventEmitter, NativeModules } from 'react-native';

const { UnicoSdk: UnicoSdkModule } = NativeModules;

export const testConnection = (): Promise<string> => {
  return UnicoSdkModule.testConnection();
};

export const captureSelfie = (): Promise<UnicoResult> => {
  return UnicoSdkModule.captureSelfie();
};

export const captureDocument = (
  documentType: DocumentType
): Promise<UnicoResult> => {
  return UnicoSdkModule.captureDocument(documentType);
};

3. Presentation Layer - Hooks Especializados

// useCapture.ts - Hook para capturas
export const useCapture = () => {
  const [isLoading, setIsLoading] = useState(false);
  const { requestPermissionOrRedirect } = usePermissions();

  const captureSelfie = useCallback(async (): Promise<CapturedItem | null> => {
    try {
      const granted = await requestPermissionOrRedirect();
      if (!granted) return null;

      setIsLoading(true);
      const newItem = await useCases.captureSelfie.execute();

      Alert.alert('✅ Sucesso', 'Selfie capturada!');
      return newItem;
    } catch (error: unknown) {
      Alert.alert('Erro', (error as Error).message);
      return null;
    } finally {
      setIsLoading(false);
    }
  }, [requestPermissionOrRedirect, useCases.captureSelfie]);

  return { isLoading, captureSelfie };
};

🎨 Funcionalidades Avançadas

1. Fluxo Guiado Inteligente

Implementei um sistema de fluxo guiado que orienta o usuário através dos passos necessários:

const DEFAULT_STEPS: FlowStep[] = [
  {
    id: 'selfie',
    title: 'Capturar Selfie',
    description: 'Primeiro, vamos tirar uma selfie sua',
    icon: '🤳',
  },
  {
    id: 'cnh_frente',
    title: 'CNH Frente',
    description: 'Agora capture a frente da sua CNH',
    icon: '🪪',
  },
  {
    id: 'cnh_verso',
    title: 'CNH Verso',
    description: 'Por último, capture o verso da CNH',
    icon: '🔄',
  },
  {
    id: 'submit',
    title: 'Enviar',
    description: 'Pronto! Vamos enviar tudo para verificação',
    icon: '📤',
  },
];

2. Sistema de Eventos Nativos

Para melhor UX, implementei um sistema de eventos que permite ao React Native reagir a ações do usuário no SDK nativo:

// JavaScript - Escutando eventos nativos
import { NativeEventEmitter } from 'react-native';
const eventEmitter = new NativeEventEmitter(UnicoSdk);

eventEmitter.addListener('onErrorAcessoBio', (event) => {
  console.error('Erro do SDK:', event.code, event.description);
});

eventEmitter.addListener('onUserClosedCameraManually', () => {
  console.log('Usuário fechou a câmera');
});

3. Personalização Visual Completa

Criei classes de tema que permitem personalizar completamente a interface do SDK:

// Android
class UnicoTheme : IAcessoBioTheme {
    override fun getColorBackground(): Any = "#F1F0F8"
    override fun getColorBoxMessage(): Any = "#FFFFFF"
    override fun getColorTextMessage(): Any = "#322E50"
    // ... 14 cores personalizáveis
}

// iOS
class UnicoTheme: AcessoBioThemeDelegate {
    func getColorBackground() -> Any! {
        return UIColor(red: 0.94, green: 0.94, blue: 0.97, alpha: 1.0)
    }
    // ... mesmas cores, implementação iOS
}

🚨 Principais Desafios e Soluções

1. Gerenciamento de Permissões

Desafio: Diferentes APIs de permissão em cada plataforma.

Solução: Abstração unificada com verificação prévia:

export const ensureCameraPermission = async (): Promise<boolean> => {
  try {
    const permissions = await checkPermissions();
    return permissions.camera;
  } catch (error) {
    console.error('Erro ao verificar permissões:', error);
    return false;
  }
};

2. Thread Safety

Desafio: SDK requer UI thread, React Native executa em background thread.

Solução: Garantir execução na main thread:

// Android
private fun runOnMainThread(action: () -> Unit) {
    if (Looper.myLooper() == Looper.getMainLooper()) {
        action()
    } else {
        Handler(Looper.getMainLooper()).post(action)
    }
}

// iOS
@objc
func captureSelfie(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
    DispatchQueue.main.async {
        // Operações de UI aqui
    }
}

3. Configuração de Credenciais

Desafio: Credenciais precisam estar disponíveis em runtime sem hardcode.

Solução: Fluxo .env → react-native-config → plataforma nativa:

# .env
UNICO_BUNDLE_ID=com.empresa.app
UNICO_HOST_KEY=chave_secreta

4. Debugging Complexo

Desafio: Debuggar código que atravessa 3 camadas (JS → Bridge → SDK).

Solução: Logging detalhado em cada camada:

Log.d(TAG, "✅ AcessoBio.prepareCamera() chamado com sucesso")
Log.e(TAG, "❌ Exception geral em captureSelfie", e)

📊 Resultados Alcançados

Funcionalidades Implementadas:

✅ Captura de selfie com biometria facial
✅ Captura de documentos (CNH, RG, CPF) com frames guiados
✅ Fluxo guiado completo de verificação
✅ Gerenciamento de permissões nativo
✅ Personalização visual completa
✅ Eventos nativos para JavaScript
✅ Arquitetura escalável e testável
✅ Documentação completa com guias passo-a-passo

Métricas de Qualidade:

🎯 100% funcional em dispositivos reais
📱 Suporte completo iOS e Android
🧪 Arquitetura testável com separação de responsabilidades
📚 Documentação completa com troubleshooting
🔧 Configuração simplificada via arquivo .env

🎓 Lições Aprendidas

1. Documentação é Crucial

A falta de documentação específica para React Native custou semanas de desenvolvimento. Por isso, criei uma documentação detalhada para evitar que outros passem pelo mesmo problema.

2. Arquitetura Limpa Compensa

Investir tempo em arquitetura limpa desde o início facilitou enormemente a manutenção e extensão do código.

3. Thread Safety é Crítico

Problemas de thread causaram crashes esporádicos. Garantir execução na main thread é fundamental.

4. Testes em Dispositivos Reais

Simuladores não são suficientes para testar funcionalidades de câmera e biometria.

5. Comunidade é Poderosa

Compartilhar conhecimento gera valor exponencial para toda a comunidade.

🎯 Conclusão

Desenvolver uma bridge nativa para o SDK da Unico foi um desafio técnico complexo, mas extremamente gratificante. O resultado é uma solução robusta, bem documentada e pronta para uso em produção.

O mais importante: esta implementação agora está disponível para toda a comunidade React Native, evitando que outros desenvolvedores enfrentem os mesmos obstáculos que encontrei.

Principais Benefícios para a Comunidade:

⏰ Economia de Tempo: Semanas de desenvolvimento economizadas
📚 Conhecimento Compartilhado: Documentação completa e detalhada
🏗️ Arquitetura Sólida: Base para implementações futuras
🔧 Troubleshooting: Soluções para problemas reais
🤝 Open Source: Disponível para todos

📞 Como Contribuir

Este projeto é open source e feito para a comunidade. Se você:

✨ Tem sugestões de melhorias
🐛 Encontrou bugs ou problemas
📝 Quer melhorar a documentação
🌍 Pode traduzir para outros idiomas
💡 Tem ideias para novas funcionalidades

Sua contribuição é muito bem-vinda!

Links Úteis:

📂 Repositório: GitHub - SDK Unico Bridge
📚 Documentação Completa: Guias detalhados para iOS e Android
🐛 Issues: Reporte problemas ou sugira melhorias
💬 Discussões: Participe da comunidade

Se este artigo te ajudou, considere:

⭐ Dar uma estrela no repositório
📤 Compartilhar com outros desenvolvedores
💬 Deixar feedback nos comentários
🤝 Contribuir com melhorias

Segurança em Aplicativos Móveis: Da Teoria à Prática em Sistemas Financeiros

Priscila Oliveira — Fri, 14 Mar 2025 19:37:05 +0000

Introdução

No panorama digital atual, aplicativos móveis se tornaram o principal ponto de contato entre empresas e seus clientes. Com mais de 6 bilhões de usuários de smartphones no mundo, a segurança desses aplicativos se tornou uma preocupação crítica - especialmente quando lidamos com dados sensíveis e transações financeiras.

Após três anos trabalhando no desenvolvimento de aplicativos financeiros e realizando estudos aprofundados sobre segurança móvel, aprendi que a segurança não é um recurso opcional, mas sim o alicerce sobre o qual todo o sistema é construído. Neste artigo, compartilho insights sobre as melhores práticas de segurança tanto para aplicativos híbridos quanto nativos, com um foco especial no setor financeiro onde as consequências de falhas de segurança são particularmente severas.

Fundamentos da Segurança Mobile: Nativos vs. Híbridos

Aplicativos Nativos

Aplicativos nativos são desenvolvidos especificamente para uma plataforma (iOS ou Android) usando linguagens como Swift, Objective-C, Java ou Kotlin. Do ponto de vista de segurança, oferecem:

Vantagens:

Acesso direto a recursos de segurança de hardware: Como TEE (Trusted Execution Environment), enclaves seguros e armazenamento de chaves protegido.
Melhor desempenho de criptografia: Operações criptográficas geralmente são mais eficientes.
Controle preciso sobre permissões: Acesso refinado aos recursos do sistema.

Desafios:

Manutenção separada: Configurações e implementações de segurança devem ser mantidas separadamente para cada plataforma.
Inconsistências entre plataformas: Recursos de segurança podem variar significativamente entre iOS e Android.

Aplicativos Híbridos

Desenvolvidos com tecnologias web (JavaScript, HTML, CSS) e empacotados para execução em múltiplas plataformas usando frameworks como React Native, Flutter ou Ionic, os aplicativos híbridos apresentam:

Vantagens:

Base de código única: Redução do risco de inconsistências de segurança entre plataformas.
Atualizações mais rápidas: Patches de segurança podem ser implementados mais rapidamente.
Ecossistema crescente: Bibliotecas de segurança cada vez mais robustas.

Desafios:

Camada adicional de abstração: Pode limitar o acesso a recursos de segurança nativos.
Dependência de bridges: A integração com recursos de segurança nativos depende de bridges que podem ter vulnerabilidades.
Surface de ataque maior: Pelo uso de frameworks e bibliotecas de terceiros.

Vetores de Ataque Comuns

Independentemente da abordagem de desenvolvimento, aplicativos móveis enfrentam diversos vetores de ataque:

1. Armazenamento Inseguro de Dados

Dados armazenados localmente sem criptografia apropriada são um dos problemas mais comuns. Em ambos os tipos de aplicativo, é crucial implementar:

Criptografia forte para dados em repouso
Uso de armazenamento seguro (Keychain no iOS, Keystore no Android)
Minimização de dados sensíveis armazenados localmente

Exemplo prático: Em um aplicativo React Native, substituir AsyncStorage por react-native-encrypted-storage para dados sensíveis:

// Inseguro
AsyncStorage.setItem('userToken', token);

// Seguro
import EncryptedStorage from 'react-native-encrypted-storage';

await EncryptedStorage.setItem(
    "userToken",
    JSON.stringify({
        token,
        expiration: Date.now() + 3600000
    })
);

2. Comunicação Insegura

Dados em trânsito representam outro ponto vulnerável significativo:

Uso inconsistente de HTTPS
Falta de certificate pinning
Validação inadequada de certificados

Exemplo prático: Implementação de SSL Pinning em Swift para iOS:

class CustomURLSessionDelegate: NSObject, URLSessionDelegate {
    func urlSession(_ session: URLSession, didReceive challenge: URLAuthenticationChallenge, completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void) {

        guard let serverTrust = challenge.protectionSpace.serverTrust,
              let certificates = SecTrustCopyCertificateChain(serverTrust) as? [SecCertificate],
              let remoteCertificateData = SecCertificateCopyData(certificates[0]) as Data?,
              let localCertificateData = NSDataAsset(name: "MyCertificate")?.data else {
            completionHandler(.cancelAuthenticationChallenge, nil)
            return
        }

        if remoteCertificateData == localCertificateData {
            completionHandler(.useCredential, URLCredential(trust: serverTrust))
        } else {
            completionHandler(.cancelAuthenticationChallenge, nil)
        }
    }
}

3. Autenticação e Autorização Fracas

A gestão de identidade permanece um desafio constante:

Falta de autenticação multifator
Políticas fracas de senhas
Tokens de sessão com validade excessiva

Exemplo prático: Implementação de timeout de sessão em React Native:

const useSessionTimeout = (navigation, timeoutMinutes = 5) => {
  const [lastActivity, setLastActivity] = useState(Date.now());
  const [isActive, setIsActive] = useState(true);

  const resetTimeout = useCallback(() => {
    setLastActivity(Date.now());
    setIsActive(true);
  }, []);

  useEffect(() => {
    const checkInactivity = setInterval(() => {
      const now = Date.now();
      const inactiveTime = now - lastActivity;

      if (inactiveTime > timeoutMinutes * 60 * 1000 && isActive) {
        setIsActive(false);
        // Limpar dados sensíveis
        secureStorage.removeItem('session');
        // Redirecionar para login
        navigation.navigate('Login', { 
          sessionExpired: true 
        });
      }
    }, 30000);

    return () => clearInterval(checkInactivity);
  }, [lastActivity, timeoutMinutes, isActive, navigation]);

  // Listener para atividade do usuário
  useEffect(() => {
    const subscription = AppState.addEventListener('change', nextAppState => {
      if (nextAppState === 'active') {
        resetTimeout();
      }
    });

    return () => subscription.remove();
  }, [resetTimeout]);

  return resetTimeout;
};

Segurança Específica para Aplicativos Financeiros

Trabalhando especificamente com aplicativos financeiros nos últimos três anos, identifiquei camadas adicionais de segurança que são indispensáveis neste setor:

1. Detecção de Dispositivos Comprometidos

Aplicativos financeiros devem detectar e responder a ambientes potencialmente hostis:

Verificação de jailbreak/root
Detecção de emuladores
Identificação de ferramentas de hooking/debugging

Exemplo prático: Implementação com React Native

import JailMonkey from 'react-native-jail-monkey';

const SecurityCheck = () => {
  useEffect(() => {
    const checkDeviceSecurity = async () => {
      const isJailBroken = JailMonkey.isJailBroken();
      const canMockLocation = JailMonkey.canMockLocation();
      const isDebuggedMode = __DEV__ || JailMonkey.isDebuggedMode();

      if (isJailBroken || canMockLocation || isDebuggedMode) {
        Alert.alert(
          "Ambiente Inseguro Detectado",
          "Este dispositivo foi identificado como potencialmente inseguro. Por razões de segurança, algumas funcionalidades estão limitadas.",
          [{ text: "Entendi", style: "cancel" }]
        );

        // Limitar funcionalidades sensíveis
        store.dispatch(restrictFeatures(['transfers', 'investments']));
      }
    };

    checkDeviceSecurity();
  }, []);

  return null; // Componente invisível
};

2. Criptografia em Várias Camadas

Para aplicativos financeiros, uma camada única de criptografia raramente é suficiente:

Criptografia em nível de aplicativo (end-to-end)
Criptografia em nível de transporte (TLS/SSL)
Criptografia em nível de armazenamento (dados em repouso)

Exemplo prático: Criptografia em camadas para transações financeiras:

// Camada 1: Criptografia de dados sensíveis antes do envio
const encryptTransaction = async (transactionData) => {
  // Gerar chave efêmera para esta transação específica
  const ephemeralKey = await generateEphemeralKey();

  // Criptografar dados com chave efêmera
  const encryptedPayload = await encryptWithAES(
    JSON.stringify(transactionData),
    ephemeralKey
  );

  // Criptografar chave efêmera com chave pública do servidor
  const encryptedKey = await encryptWithRSA(
    ephemeralKey,
    SERVER_PUBLIC_KEY
  );

  return {
    payload: encryptedPayload,
    key: encryptedKey
  };
};

// Camada 2: Enviar via HTTPS com certificate pinning
const sendSecureTransaction = async (transaction) => {
  const encryptedData = await encryptTransaction(transaction);

  // A biblioteca já implementa SSL pinning
  return secureFetch('https://api.bank.com/transactions', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(encryptedData),
    sslPinning: {
      certs: ['certificate-hash-1', 'certificate-hash-2']
    }
  });
};

3. Verificações de Integridade

Aplicativos financeiros devem garantir que não foram adulterados:

Verificação de assinatura do aplicativo
Detecção de injeção de código
Verificação de integridade de recursos críticos

Exemplo nativo em Kotlin:

fun verifyAppIntegrity(context: Context): Boolean {
    try {
        // Verificar assinatura do aplicativo
        val packageInfo = context.packageManager.getPackageInfo(
            context.packageName,
            PackageManager.GET_SIGNATURES
        )

        val signatures = packageInfo.signatures
        val signatureBytes = signatures[0].toByteArray()
        val messageDigest = MessageDigest.getInstance("SHA")
        val digest = messageDigest.digest(signatureBytes)
        val signatureHex = digest.joinToString("") { 
            "%02x".format(it) 
        }

        // Comparar com assinatura conhecida
        return signatureHex == EXPECTED_SIGNATURE
    } catch (e: Exception) {
        Log.e("Security", "Falha na verificação de integridade", e)
        return false
    }
}

4. Conformidade Regulatória

O setor financeiro possui exigências regulatórias específicas:

PCI-DSS: Para aplicativos que processam dados de cartão
Requisitos do Banco Central: Varia por país (BACEN no Brasil, etc.)
KYC/AML: Requisitos de identificação e combate à lavagem de dinheiro

Estes requisitos frequentemente demandam:

Auditoria detalhada de transações
Gestão segura de dados pessoais
Processos documentados de segurança

Implementação Prática: Abordagem em Camadas

Com base na minha experiência, a segurança efetiva em aplicativos financeiros requer uma abordagem em camadas:

Camada 1: Proteção em Desenvolvimento

Análise estática de código (ESLint com plugins de segurança)
Verificação de dependências vulneráveis (yarn audit, OWASP Dependency-Check)
Revisões de código com foco em segurança

Camada 2: Proteção em Runtime

Detecção de ambiente inseguro
Ofuscação de código crítico
Proteção contra debugging e análise de memória

Camada 3: Proteção de Rede

SSL Pinning
Criptografia de payload
Monitoramento de anomalias de comunicação

Camada 4: Proteção de Dados

Criptografia de dados sensíveis
Minimização de exposição de dados
Limpeza de memória após uso de dados confidenciais

Ferramentas e Frameworks Recomendados

Para ferramentas específicas que têm funcionado bem para aplicativos financeiros:

Para Aplicativos Nativos:

iOS: Keychain Services, CryptoKit, App Attest
Android: Android Keystore, SafetyNet Attestation API

Para Aplicativos Híbridos:

React Native:
- react-native-keychain para armazenamento seguro
- react-native-ssl-pinning para comunicação segura
- react-native-jailbreak-detection para verificação de ambiente
Flutter:
- flutter_secure_storage para armazenamento seguro
- trust_fall para detecção de jailbreak/root
- dio com configuração de certificados para SSL pinning

Verificação de Segurança Automatizada

A automação de verificações de segurança no pipeline de CI/CD é crucial:

MobSF (Mobile Security Framework)

Ferramenta de análise estática e dinâmica para aplicativos móveis, identificando vulnerabilidades comuns.
OWASP Dependency-Check

Verifica dependências contra bases de dados de vulnerabilidades conhecidas.
SonarQube com Regras de Segurança

Análise contínua de código com foco em problemas de segurança.

Lições dos Três Anos em Aplicações Financeiras

Após três anos desenvolvendo aplicativos financeiros e realizando estudos aprofundados na área de segurança, aprendi algumas lições valiosas:

A segurança é contextual

O que é seguro para um aplicativo de entretenimento pode ser completamente inadequado para um aplicativo bancário. Conheça seu contexto.
A experiência do usuário vs. segurança é um falso dilema

Com design cuidadoso, é possível criar aplicativos altamente seguros que ainda sejam amigáveis. A autenticação biométrica é um excelente exemplo disso.
Atualizações regulares são cruciais

Os atacantes evoluem constantemente. Sua segurança também deve evoluir.
A segurança é uma equipe multidisciplinar

Desenvolvedores, designers, gerentes de produto e equipes de infraestrutura precisam colaborar para criar um sistema verdadeiramente seguro.

Conclusão

A segurança em aplicativos móveis, especialmente no setor financeiro, não é apenas uma questão de implementação técnica – é uma mentalidade que deve permear todo o ciclo de desenvolvimento. Seja na escolha entre desenvolvimento nativo ou híbrido, o mais importante é estabelecer camadas robustas de proteção e mantê-las em constante evolução.

Nos meus três anos trabalhando com aplicativos financeiros, vi que as organizações mais bem-sucedidas são aquelas que tratam a segurança não como um item de checklist, mas como um valor fundamental que orienta todas as decisões de design e desenvolvimento.

Este artigo reflete minhas experiências pessoais desenvolvendo aplicativos para o setor financeiro e os estudos que realizei na área de segurança móvel. As práticas e recomendações compartilhadas são baseadas tanto na implementação prática quanto em pesquisas na área, mas as necessidades específicas de segurança podem variar de acordo com o contexto de cada aplicação.

Mobile Application Security: From Theory to Practice in Financial Systems

Priscila Oliveira — Fri, 14 Mar 2025 19:35:05 +0000

Introduction

In today's digital landscape, mobile applications have become the primary point of contact between companies and their customers. With over 6 billion smartphone users worldwide, the security of these applications has become a critical concern - especially when dealing with sensitive data and financial transactions.

After three years of working on developing financial applications and conducting in-depth studies on mobile security, I've learned that security is not an optional feature but rather the foundation upon which the entire system is built. In this article, I share insights on security best practices for both hybrid and native applications, with a special focus on the financial sector, where the consequences of security failures are particularly severe.

Mobile Security Fundamentals: Native vs. Hybrid

Native Applications

Native applications are developed specifically for a platform (iOS or Android) using languages such as Swift, Objective-C, Java, or Kotlin. From a security perspective, they offer:

Advantages:

Direct access to hardware security features: Such as TEE (Trusted Execution Environment), secure enclaves, and protected key storage.
Better cryptographic performance: Cryptographic operations are generally more efficient.
Precise control over permissions: Fine-grained access to system resources.

Challenges:

Separate maintenance: Security settings and implementations must be maintained separately for each platform.
Inconsistencies between platforms: Security features can vary significantly between iOS and Android.

Hybrid Applications

Developed with web technologies (JavaScript, HTML, CSS) and packaged for execution on multiple platforms using frameworks such as React Native, Flutter, or Ionic, hybrid applications present:

Advantages:

Single codebase: Reduced risk of security inconsistencies across platforms.
Faster updates: Security patches can be implemented more quickly.
Growing ecosystem: Increasingly robust security libraries.

Challenges:

Additional abstraction layer: This may limit access to native security features.
Dependency on bridges: Integration with native security features depends on bridges that may have vulnerabilities.
Larger attack surface: Due to the use of third-party frameworks and libraries.

Common Attack Vectors

Regardless of the development approach, mobile applications face various attack vectors:

1. Insecure Data Storage

Data stored locally without appropriate encryption is one of the most common problems. In both types of applications, it is crucial to implement:

Strong encryption for data at rest
Use of secure storage (Keychain on iOS, Keystore on Android)
Minimization of sensitive data stored locally

Practical example: In a React Native application, replace AsyncStorage with react-native-encrypted-storage for sensitive data:

// Insecure
AsyncStorage.setItem('userToken', token);

// Secure
import EncryptedStorage from 'react-native-encrypted-storage';

await EncryptedStorage.setItem(
    "userToken",
    JSON.stringify({
        token,
        expiration: Date.now() + 3600000
    })
);

2. Insecure Communication

Data in transit represents another significant vulnerability:

Inconsistent use of HTTPS
Lack of certificate pinning
Inadequate certificate validation

Practical example: Implementation of SSL Pinning in Swift for iOS:

class CustomURLSessionDelegate: NSObject, URLSessionDelegate {
    func urlSession(_ session: URLSession, didReceive challenge: URLAuthenticationChallenge, completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void) {

        guard let serverTrust = challenge.protectionSpace.serverTrust,
              let certificates = SecTrustCopyCertificateChain(serverTrust) as? [SecCertificate],
              let remoteCertificateData = SecCertificateCopyData(certificates[0]) as Data?,
              let localCertificateData = NSDataAsset(name: "MyCertificate")?.data else {
            completionHandler(.cancelAuthenticationChallenge, nil)
            return
        }

        if remoteCertificateData == localCertificateData {
            completionHandler(.useCredential, URLCredential(trust: serverTrust))
        } else {
            completionHandler(.cancelAuthenticationChallenge, nil)
        }
    }
}

3. Weak Authentication and Authorization

Identity management remains a constant challenge:

Lack of multi-factor authentication
Weak password policies
Session tokens with excessive validity periods

Practical example: Implementation of session timeout in React Native:

const useSessionTimeout = (navigation, timeoutMinutes = 5) => {
  const [lastActivity, setLastActivity] = useState(Date.now());
  const [isActive, setIsActive] = useState(true);

  const resetTimeout = useCallback(() => {
    setLastActivity(Date.now());
    setIsActive(true);
  }, []);

  useEffect(() => {
    const checkInactivity = setInterval(() => {
      const now = Date.now();
      const inactiveTime = now - lastActivity;

      if (inactiveTime > timeoutMinutes * 60 * 1000 && isActive) {
        setIsActive(false);
        // Clear sensitive data
        secureStorage.removeItem('session');
        // Redirect to login
        navigation.navigate('Login', { 
          sessionExpired: true 
        });
      }
    }, 30000);

    return () => clearInterval(checkInactivity);
  }, [lastActivity, timeoutMinutes, isActive, navigation]);

  // Listener for user activity
  useEffect(() => {
    const subscription = AppState.addEventListener('change', nextAppState => {
      if (nextAppState === 'active') {
        resetTimeout();
      }
    });

    return () => subscription.remove();
  }, [resetTimeout]);

  return resetTimeout;
};

Specific Security for Financial Applications

Working specifically with financial applications over the past three years, I've identified additional layers of security that are indispensable in this sector:

1. Detection of Compromised Devices

Financial applications must detect and respond to potentially hostile environments:

Jailbreak/root detection
Emulator detection
Identification of hooking/debugging tools

Practical example: Implementation with React Native

import JailMonkey from 'react-native-jail-monkey';

const SecurityCheck = () => {
  useEffect(() => {
    const checkDeviceSecurity = async () => {
      const isJailBroken = JailMonkey.isJailBroken();
      const canMockLocation = JailMonkey.canMockLocation();
      const isDebuggedMode = __DEV__ || JailMonkey.isDebuggedMode();

      if (isJailBroken || canMockLocation || isDebuggedMode) {
        Alert.alert(
          "Insecure Environment Detected",
          "This device has been identified as potentially insecure. For security reasons, some features are limited.",
          [{ text: "Understood", style: "cancel" }]
        );

        // Limit sensitive features
        store.dispatch(restrictFeatures(['transfers', 'investments']));
      }
    };

    checkDeviceSecurity();
  }, []);

  return null; // Invisible component
};

2. Multi-Layer Encryption

For financial applications, a single layer of encryption is rarely sufficient:

Application-level encryption (end-to-end)
Transport-level encryption (TLS/SSL)
Storage-level encryption (data at rest)

Practical example: Layered encryption for financial transactions:

// Layer 1: Encrypt sensitive data before sending
const encryptTransaction = async (transactionData) => {
  // Generate ephemeral key for this specific transaction
  const ephemeralKey = await generateEphemeralKey();

  // Encrypt data with ephemeral key
  const encryptedPayload = await encryptWithAES(
    JSON.stringify(transactionData),
    ephemeralKey
  );

  // Encrypt ephemeral key with server's public key
  const encryptedKey = await encryptWithRSA(
    ephemeralKey,
    SERVER_PUBLIC_KEY
  );

  return {
    payload: encryptedPayload,
    key: encryptedKey
  };
};

// Layer 2: Send via HTTPS with certificate pinning
const sendSecureTransaction = async (transaction) => {
  const encryptedData = await encryptTransaction(transaction);

  // The library already implements SSL pinning
  return secureFetch('https://api.bank.com/transactions', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(encryptedData),
    sslPinning: {
      certs: ['certificate-hash-1', 'certificate-hash-2']
    }
  });
};

3. Integrity Checks

Financial applications must ensure they have not been tampered with:

Application signature verification
Code injection detection
Verification of critical resource integrity

Native example in Kotlin:

fun verifyAppIntegrity(context: Context): Boolean {
    try {
        // Verify application signature
        val packageInfo = context.packageManager.getPackageInfo(
            context.packageName,
            PackageManager.GET_SIGNATURES
        )

        val signatures = packageInfo.signatures
        val signatureBytes = signatures[0].toByteArray()
        val messageDigest = MessageDigest.getInstance("SHA")
        val digest = messageDigest.digest(signatureBytes)
        val signatureHex = digest.joinToString("") { 
            "%02x".format(it) 
        }

        // Compare with known signature
        return signatureHex == EXPECTED_SIGNATURE
    } catch (e: Exception) {
        Log.e("Security", "Integrity verification failed", e)
        return false
    }
}

4. Regulatory Compliance

The financial sector has specific regulatory requirements:

PCI-DSS: For applications that process card data
Central Bank Requirements: Varies by country (BACEN in Brazil, etc.)
KYC/AML: Identification and anti-money laundering requirements

These requirements often demand:

Detailed transaction auditing
Secure management of personal data
Documented security processes

Practical Implementation: Layered Approach

Based on my experience, effective security in financial applications requires a layered approach:

Layer 1: Development Protection

Static code analysis (ESLint with security plugins)
Vulnerable dependency checking (yarn audit, OWASP Dependency-Check)
Security-focused code reviews

Layer 2: Runtime Protection

Insecure environment detection
Critical code obfuscation
Protection against debugging and memory analysis

Layer 3: Network Protection

SSL Pinning
Payload encryption
Communication anomaly monitoring

Layer 4: Data Protection

Encryption of sensitive data
Data exposure minimization
Memory cleanup after using confidential data

Recommended Tools and Frameworks

For specific tools that have worked well for financial applications:

For Native Applications:

iOS: Keychain Services, CryptoKit, App Attest
Android: Android Keystore, SafetyNet Attestation API

For Hybrid Applications:

React Native:
- react-native-keychain for secure storage
- react-native-ssl-pinning for secure communication
- react-native-jailbreak-detection for environment verification
Flutter:
- flutter_secure_storage for secure storage
- trust_fall for jailbreak/root detection
- dio with certificate configuration for SSL pinning

Automated Security Verification

Automating security checks in the CI/CD pipeline is crucial:

MobSF (Mobile Security Framework)

Static and dynamic analysis tool for mobile applications, identifying common vulnerabilities.
OWASP Dependency-Check

Checks dependencies against databases of known vulnerabilities.
SonarQube with Security Rules

Continuous code analysis focused on security issues.

Lessons from Three Years in Financial Applications

After three years of developing financial applications and conducting in-depth studies in the area of security, I've learned some valuable lessons:

Security is contextual

What is secure for an entertainment application may be completely inadequate for a banking application. Know your context.
User experience vs. security is a false dilemma

With careful design, it is possible to create highly secure applications that are still user-friendly. Biometric authentication is an excellent example of this.
Regular updates are crucial

Attackers constantly evolve. Your security must evolve too.
Security is a multidisciplinary team

Developers, designers, product managers, and infrastructure teams need to collaborate to create a truly secure system.

Conclusion

Security in mobile applications, especially in the financial sector, is not just a matter of technical implementation – it's a mindset that should permeate the entire development cycle. Whether choosing between native or hybrid development, the most important thing is to establish robust layers of protection and keep them constantly evolving.

In my three years working with financial applications, I've seen that the most successful organizations are those that treat security not as a checklist item, but as a core value that guides all design and development decisions.

This article reflects my personal experiences developing applications for the financial sector and the studies I've conducted in the area of mobile security. The practices and recommendations shared are based on both practical implementation and research in the field, but specific security needs may vary according to the context of each application.

Swift Simplified: A Complete Guide for Beginners

Priscila Oliveira — Wed, 12 Mar 2025 16:37:43 +0000

If you've heard about iPhone app development but thought programming was "just for nerds," this article is for you! We'll explain the fundamental concepts of Swift without complicated terminology, using examples from your everyday life.

What is Swift, anyway?

Swift is the programming language created by Apple to develop applications for iPhone, iPad, and Mac. Think of it as a language you use to "talk" to the computer and tell it what to do.

Data Types: The Containers of Programming

When we organize things at home, we use different types of containers: boxes for shoes, jars for food, and drawers for documents. In Swift programming, we also have other "containers" for different types of information.

Integers (Int)

What it is: A container for numbers without decimal places.

In real life: Like a people counter on a bus – you only have whole numbers (there's no such thing as half a person).

// Declaring age
let age = 25

// Counting items in a shopping cart
var itemsInCart = 5
itemsInCart = itemsInCart + 2 // Now we have 7 items

Decimal Numbers (Double)

What it is: A container for numbers with decimal places.

In real life: Like a scale that shows your weight with precision (72.5 kg).

// Price of a product
let shirtPrice = 49.90

// Calculating the total price with a discount
let discount = 5.50
let finalPrice = shirtPrice - discount // 44.40

Text (String)

What it is: A container for letters, words, and texts.

In real life: Like a label you put on things.

// A contact's name
let friendName = "Carlos"

// Complete address
let address = "123 Flower Street, Spring Garden"

True or False (Bool)

What it is: A container that only accepts two values: true or false.

In real life: Like a light switch – it's either on or off.

// Checking if the store is open
let storeOpen = true

// Checking if there's a parking spot available
let parkingAvailable = false

// Using it to make decisions
if storeOpen {
    print("Let's go shopping!")
} else {
    print("We need to come back another day.")
}

Type Safety: The Party Bouncer

Swift has a system we call "type safety." Think of it as a bouncer at the door of a VIP party.

In real life: If the party is adults-only, the bouncer won't let children in. Similarly, Swift doesn't allow you to put one type of data where another type should go.

var personName = "Julia"
// personName = 42 // ERROR! We can't put a number where text should be

Type Inference: The Smart Detective

Swift can "guess" what type of data you're using without you having to say it explicitly.

In real life: It's like when someone brings a covered dish to dinner, and by the smell, you already know it's lasagna without having to look.

// Swift understands this is text
var city = "New York" 

// Swift understands this is a decimal number
var temperature = 28.5 

// Swift understands this is an integer
var population = 12000000

UInt8: The Mini-Box for Small Numbers

UInt8 is a special type for integers between 0 and 255.

In real life: It's like a thermometer that only measures from 0 to 100 degrees. It has a limit, but it's perfect for its specific function.

let red: UInt8 = 255   // Red component of an RGB color
let green: UInt8 = 128 // Green component
let blue: UInt8 = 0    // Blue component

Practical use: On digital screens, colors are formed by mixing red, green, and blue (RGB), each ranging from 0 to 255. UInt8 is perfect for representing these colors.

Tuples: The Organized Tote Bag

Tuples allow you to group different values into a single package.

In real life: Like a lunch box with dividers, where each compartment holds a different type of food.

// Person's information
let person = (name: "Anna", age: 29, profession: "Architect")

// Accessing specific information
print("Name: \(person.name)")
print("Age: \(person.age)")

Practical use: When you fill out a form with your personal data, the combination of all this information could be represented as a tuple in Swift.

Optionals: The Mysterious Gift Box

An Optional is a unique concept in Swift. It's like a box that may contain a value or be empty.

In real life: You asked for a birthday present but weren't sure if you'd actually get one. The Optional represents this uncertainty.

// Declaring an Optional (note the '?' symbol)
var gift: String?

// Initially, we don't know if we'll get a gift
gift = nil // 'nil' means "nothing," "empty"

// Later, we get the gift!
gift = "Watch"

How to open the gift box safely (Optional Binding)

To use an Optional, we need to check if it contains something.

In real life: Before using a gift, you must check if you actually got something and what it is.

// Using 'if let' to safely check and unwrap
if let myGift = gift {
    print("Yay! I got a \(myGift)!")
} else {
    print("I didn't get a gift this time...")
}

Forcing the gift open (Forced Unwrapping)

A more direct (and dangerous) way to open the box exists.

In real life: It's like tearing off the wrapping without checking if there's anything inside. If it's empty, you'll be disappointed.

// CAUTION: Only use when you're sure there's a value
let myGift = gift! // The '!' symbol forces it open

When to use: Only when you're 100% sure the Optional contains a value. For example, if you just checked, it's not nil.

Gifts that unwrap themselves (Implicitly Unwrapped Optionals)

Some Optionals are declared to unwrap automatically.

In real life: Like gifts where the wrapping dissolves by itself when you go to use them.

// The '!' symbol in the declaration indicates automatic unwrapping
var surprise: String! = "A trip!"

// Can be used directly, without unwrapping
print("My surprise is \(surprise)")

When to use: Rarely. Only in specific situations where you know a value that's initially absent will definitely be present before it's used.

Type Aliases: Nicknames for Types

Type Aliases allow you to give more meaningful or shorter names to existing types.

In real life: Like calling your grandmother "grandma" instead of her full name.

// Creating a nickname for a complex type
typealias Contacts = [String: String]

// Now it's easier to understand what this variable contains
var contactList: Contacts = [
    "John": "555-123-4567",
    "Mary": "555-987-6543"
]

Practical use: In messaging apps, you could use a Type Alias to clarify that a dictionary represents a list of contacts and their phone numbers.

Real-World Practical Examples

Shopping List App

// List of items to buy (String)
var shoppingList = ["Milk", "Bread", "Eggs", "Fruits"]

// Price of each item (Double)
let milkPrice = 4.50
let breadPrice = 6.75
let eggsPrice = 12.00
let fruitsPrice = 8.30

// Quantity of each item (Int)
var milkQuantity = 2
var breadQuantity = 1
var eggsQuantity = 1
var fruitsQuantity = 3

// Calculating the total
let total = (milkPrice * Double(milkQuantity)) +
          (breadPrice * Double(breadQuantity)) +
          (eggsPrice * Double(eggsQuantity)) +
          (fruitsPrice * Double(fruitsQuantity))

// Checking if we have enough money (Bool)
let availableMoney = 50.00
let hasEnoughMoney = availableMoney >= total

// Using Optional for an item we might want to buy
var additionalItem: String? = nil

// Deciding to buy the additional item
additionalItem = "Chocolate"

// Checking if we decided to buy the additional item
if let item = additionalItem {
    print("I'll also buy \(item)")
    shoppingList.append(item)
}

User Profile App

// User information as a tuple
let profile = (
    name: "Martha Smith",
    age: 32,
    profession: "Designer",
    city: "San Francisco"
)

// Privacy settings as booleans
let showAge = false
let publicProfile = true
let receiveNotifications = true

// Optional information (which might not be filled in)
var phone: String? = nil
var personalWebsite: String? = "www.marthadesign.com"

// Displaying the profile while respecting privacy
print("Name: \(profile.name)")

if showAge {
    print("Age: \(profile.age)")
}

print("Profession: \(profile.profession)")
print("City: \(profile.city)")

// Checking optional information
if let site = personalWebsite {
    print("Website: \(site)")
}

if let phoneNumber = phone {
    print("Phone: \(phoneNumber)")
} else {
    print("Phone not provided")
}

Conclusion

Swift might seem complex at first glance, but its fundamental concepts reflect situations we encounter in everyday life. The language was designed to be safe and prevent common errors, while still offering flexibility to developers.

Think of data types as different containers, Optionals as boxes that might be empty, and tuples as compartmentalized lunch boxes. With these analogies in mind, you've already taken the first step to understanding Swift programming, even without previous technology experience!

And remember: just as you didn't learn to ride a bicycle by just reading about it, the best way to learn Swift is by practicing. Start with simple examples and increase the complexity as you become more comfortable.

Swift Descomplicado: Guia Completo para Leigos

Priscila Oliveira — Wed, 12 Mar 2025 16:26:22 +0000

Vamos explicar os conceitos fundamentais da linguagem Swift sem usar terminologia complicada, com exemplos que você encontra no seu dia a dia.

O que é Swift, afinal?

Swift é a linguagem de programação criada pela Apple para desenvolver aplicativos para iPhone, iPad e Mac. Pense nela como um idioma que você usa para "conversar" com o computador e dizer a ele o que fazer.

Tipos de Dados: As Caixinhas da Programação

Quando organizamos coisas em casa, usamos diferentes tipos de recipientes: caixas para sapatos, potes para alimentos, gavetas para documentos. Na programação Swift, também temos diferentes "recipientes" para diferentes tipos de informação.

Números Inteiros (Int)

O que é: Recipiente para números sem casas decimais.

Na vida real: Como um contador de pessoas em um ônibus – só temos números inteiros (não existe meia pessoa).

// Declarando idade
let idade = 25

// Contando itens em um carrinho de compras
var itensNoCarrinho = 5
itensNoCarrinho = itensNoCarrinho + 2 // Agora temos 7 itens

Números Decimais (Double)

O que é: Recipiente para números com casas decimais.

Na vida real: Como uma balança que mostra seu peso com precisão (72,5 kg).

// Preço de um produto
let precoCamiseta = 49.90

// Calculando o preço total com desconto
let desconto = 5.50
let precoFinal = precoCamiseta - desconto // 44.40

Texto (String)

O que é: Recipiente para letras, palavras e textos.

Na vida real: Como uma etiqueta que você coloca nas coisas.

// Nome de um contato
let nomeAmigo = "Carlos"

// Endereço completo
let endereco = "Rua das Flores, 123 - Jardim Primavera"

Verdadeiro ou Falso (Bool)

O que é: Recipiente que só aceita dois valores: verdadeiro ou falso.

Na vida real: Como um interruptor de luz – ou está ligado, ou está desligado.

// Verificando se a loja está aberta
let lojaAberta = true

// Verificando se tem vaga no estacionamento
let temVagaDisponivel = false

// Usando para tomar decisões
if lojaAberta {
    print("Vamos às compras!")
} else {
    print("Precisamos voltar outro dia.")
}

Segurança de Tipos: O Fiscal da Festa

Swift tem um sistema que chamamos de "segurança de tipos" (type safety). Pense nele como um segurança na porta de uma festa VIP.

Na vida real: Se a festa é só para adultos, o segurança não deixa crianças entrarem. Da mesma forma, Swift não permite que você coloque um tipo de dado no lugar errado.

var nomePessoa = "Júlia"
// nomePessoa = 42 // ERRO! Não podemos colocar um número onde deveria ter texto

Inferência de Tipos: O Detetive Esperto

Swift consegue "adivinhar" qual tipo de dado você está usando sem que você precise dizer explicitamente.

Na vida real: É como quando alguém traz um prato coberto para um jantar, e pelo cheiro você já sabe que é lasanha, sem precisar olhar.

// Swift entende que isso é texto
var cidade = "São Paulo" 

// Swift entende que isso é um número decimal
var temperatura = 28.5 

// Swift entende que isso é um número inteiro
var população = 12000000

UInt8: A Mini-Caixinha para Números Pequenos

UInt8 é um tipo especial para números inteiros entre 0 e 255.

Na vida real: É como um termômetro que só mede de 0 a 100 graus. Tem um limite, mas é perfeito para sua função específica.

let vermelho: UInt8 = 255 // Componente vermelho de uma cor RGB
let verde: UInt8 = 128    // Componente verde
let azul: UInt8 = 0       // Componente azul

Uso prático: Nas telas digitais, as cores são formadas pela mistura de vermelho, verde e azul (RGB), cada um variando de 0 a 255. UInt8 é perfeito para representar essas cores.

Tuplas: A Sacola Organizada

Tuplas permitem agrupar diferentes valores em um único pacote.

Na vida real: Como uma marmita com divisórias, onde cada compartimento guarda um tipo de comida.

// Informações de uma pessoa
let pessoa = (nome: "Ana", idade: 29, profissão: "Arquiteta")

// Acessando informações específicas
print("Nome: \(pessoa.nome)")
print("Idade: \(pessoa.idade)")

Uso prático: Quando você preenche um formulário com seus dados pessoais, a combinação de todas essas informações poderia ser representada como uma tupla em Swift.

Optionals: A Caixa de Presente Misteriosa

Um Optional é um conceito único do Swift. É como uma caixa que pode conter um valor ou estar vazia.

Na vida real: Como aquela vez que você pediu um presente de aniversário, mas não tinha certeza se realmente ganharia. O Optional representa essa incerteza.

// Declarando um Optional (note o símbolo '?')
var presente: String?

// Inicialmente, não sabemos se ganharemos um presente
presente = nil // 'nil' significa "nada", "vazio"

// Mais tarde, ganhamos o presente!
presente = "Relógio"

Como abrir a caixa de presente com segurança (Optional Binding)

Para usar um Optional, precisamos verificar se ele contém alguma coisa.

Na vida real: Antes de usar um presente, você precisa verificar se realmente ganhou algo e o que é.

// Usando 'if let' para verificar e desembrulhar com segurança
if let meuPresente = presente {
    print("Oba! Ganhei um \(meuPresente)!")
} else {
    print("Não ganhei presente desta vez...")
}

Forçando a abertura do presente (Forced Unwrapping)

Existe uma forma mais direta (e perigosa) de abrir a caixa.

Na vida real: É como rasgar o embrulho sem verificar se tem algo dentro. Se estiver vazio, você vai se decepcionar.

// CUIDADO: Só use quando tiver certeza que há um valor
let meuPresente = presente! // O símbolo '!' força a abertura

Quando usar: Apenas quando você tem 100% de certeza que o Optional contém um valor. Por exemplo, se você acabou de verificar que ele não é nil.

Presentes que se desembrulham sozinhos (Implicitly Unwrapped Optionals)

Alguns Optionals são declarados para se desembrulharem automaticamente.

Na vida real: Como presentes em que o embrulho se desfaz sozinho quando você vai usar.

// O símbolo '!' na declaração indica desembrulho automático
var surpresa: String! = "Uma viagem!"

// Pode usar diretamente, sem desembrulhar
print("Minha surpresa é \(surpresa)")

Quando usar: Raramente. Apenas em situações específicas onde você sabe que um valor inicialmente ausente estará definitivamente presente antes de ser usado.

Type Aliases: Apelidos para os Tipos

Type Aliases permitem dar nomes mais significativos ou mais curtos para tipos existentes.

Na vida real: Como chamar sua avó de "vovó" em vez do nome completo dela.

// Criando um apelido para um tipo complexo
typealias Contatos = [String: String]

// Agora é mais fácil de entender o que essa variável contém
var listaDeContatos: Contatos = [
    "João": "11 97777-8888",
    "Maria": "11 96666-7777"
]

Uso prático: Em aplicativos de mensagem, você poderia usar um Type Alias para deixar claro que um dicionário representa uma lista de contatos e seus números de telefone.

Exemplos Práticos do Mundo Real

Aplicativo de Lista de Compras

// Lista de itens para comprar (String)
var listaDeCompras = ["Leite", "Pão", "Ovos", "Frutas"]

// Preço de cada item (Double)
let precoLeite = 4.50
let precoPao = 6.75
let precoOvos = 12.00
let precoFrutas = 8.30

// Quantidade de cada item (Int)
var quantidadeLeite = 2
var quantidadePao = 1
var quantidadeOvos = 1
var quantidadeFrutas = 3

// Calculando o total
let total = (precoLeite * Double(quantidadeLeite)) +
          (precoPao * Double(quantidadePao)) +
          (precoOvos * Double(quantidadeOvos)) +
          (precoFrutas * Double(quantidadeFrutas))

// Verificando se temos dinheiro suficiente (Bool)
let dinheiroDisponivel = 50.00
let temDinheiroSuficiente = dinheiroDisponivel >= total

// Usando Optional para um item que talvez queiramos comprar
var itemAdicional: String? = nil

// Decidindo comprar o item adicional
itemAdicional = "Chocolate"

// Verificando se decidimos comprar o item adicional
if let item = itemAdicional {
    print("Também vou comprar \(item)")
    listaDeCompras.append(item)
}

Aplicativo de Perfil de Usuário

// Informações do usuário como tupla
let perfil = (
    nome: "Marta Silva",
    idade: 32,
    profissao: "Designer",
    cidade: "Rio de Janeiro"
)

// Configurações de privacidade como booleanos
let mostrarIdade = false
let perfilPublico = true
let receberNotificacoes = true

// Informações opcionais (que podem não estar preenchidas)
var telefone: String? = nil
var sitePessoal: String? = "www.martadesign.com.br"

// Exibindo o perfil respeitando a privacidade
print("Nome: \(perfil.nome)")

if mostrarIdade {
    print("Idade: \(perfil.idade)")
}

print("Profissão: \(perfil.profissao)")
print("Cidade: \(perfil.cidade)")

// Verificando informações opcionais
if let site = sitePessoal {
    print("Site: \(site)")
}

if let tel = telefone {
    print("Telefone: \(tel)")
} else {
    print("Telefone não informado")
}

Conclusão

Swift pode parecer complexo à primeira vista, mas seus conceitos fundamentais refletem situações que encontramos no dia a dia. A linguagem foi projetada para ser segura e impedir erros comuns, ao mesmo tempo em que oferece flexibilidade para os desenvolvedores.

Pense nos tipos de dados como diferentes recipientes, nos Optionals como caixas que podem estar vazias, e nas tuplas como marmitas compartimentadas. Com essas analogias em mente, você já deu o primeiro passo para entender programação Swift, mesmo sem experiência prévia em tecnologia!

E lembre-se: assim como você não aprendeu a andar de bicicleta apenas lendo sobre o assunto, a melhor forma de aprender Swift é praticando. Comece com exemplos simples e vá aumentando a complexidade conforme se sente mais confortável.

Big O Notation: Explicação Simples para Quem Não É Expert (Ainda!)

Priscila Oliveira — Thu, 06 Mar 2025 21:33:54 +0000

Se você já ouviu falar de Big O Notation, mas sente que isso é um bicho de sete cabeças, este artigo é para você. Vamos desmistificar esse conceito de forma simples, prática e sem matemática complicada. No final, você vai entender por que ele é importante e como usá-lo no dia a dia como desenvolvedor.

O que é Big O Notation?

Big O é uma ferramenta usada para medir a eficiência de algoritmos. Ele nos ajuda a entender como o tempo de execução ou o uso de memória de um algoritmo cresce à medida que a entrada aumenta.

Pense assim: se um programa roda rápido para 10 dados, ele continuará rápido para 1 milhão? O Big O nos dá uma forma de responder essa pergunta.

Por que o Big O é importante?

Imagine que você está construindo um aplicativo que precisa buscar informações em uma lista enorme. Se seu código não for eficiente, pode funcionar bem em testes pequenos, mas travar quando for para produção.

O Big O ajuda a prever problemas antes que eles aconteçam, tornando seu código mais escalável e performático.

Principais Tipos de Big O (Com Exemplos Simples em JavaScript)

Vamos analisar cada caso com o que fazer e o que evitar, usando exemplos em JavaScript.

O(1) - Tempo Constante

O que fazer (código eficiente)

function acessarPrimeiroItem(array) {
    return array[0]; // Sempre pega o primeiro item, independente do tamanho do array
}

Por que isso é bom?

A operação sempre ocorre no mesmo tempo, não importa se o array tem 10 ou 1 milhão de elementos.
O acesso direto a índices específicos é super rápido.

O que evitar (código ineficiente)

function acessarPrimeiroItemErrado(array) {
    for (let i = 0; i < array.length; i++) {
        if (i === 0) {
            return array[i];
        }
    }
}

Por que isso é ruim?

Criamos um loop desnecessário, tornando a função O(n) quando poderia ser O(1).
Com grandes entradas, esse código desperdiça processamento à toa.

💡 Dica: Sempre que possível, prefira acessos diretos em vez de loops desnecessários.

O(n) - Tempo Linear

O que fazer (código eficiente)

function imprimirElementos(array) {
    for (let item of array) {
        console.log(item);
    }
}

Por que isso é bom?

O código percorre o array uma única vez, garantindo eficiência.
Se houver 100 ou 1.000 elementos, a função cresce proporcionalmente.

O que evitar (código ineficiente)

function imprimirElementosErrado(array) {
    for (let i = 0; i < array.length; i++) {
        for (let j = 0; j < 1; j++) { // Loop extra sem necessidade
            console.log(array[i]);
        }
    }
}

Por que isso é ruim?

Um loop extra não faz sentido aqui e adiciona complexidade sem necessidade.
Mesmo que o loop interno rode apenas uma vez, ele pode confundir outras pessoas que leiam seu código.

💡 Dica: Evite loops desnecessários e mantenha a estrutura do código limpa.

O(n²) - Tempo Quadrático

O que fazer (código eficiente)

function encontrarPares(array) {
    for (let i = 0; i < array.length; i++) {
        for (let j = i + 1; j < array.length; j++) {
            console.log(array[i], array[j]); // Só imprime pares únicos
        }
    }
}

Por que isso é melhor?

O loop interno começa em i + 1, reduzindo pela metade o número de execuções.
Se há formas de reduzir loops aninhados, sempre vale a pena explorar.

O que evitar (código ineficiente)

function encontrarParesErrado(array) {
    for (let i = 0; i < array.length; i++) {
        for (let j = 0; j < array.length; j++) {
            console.log(array[i], array[j]); // Exibe pares repetidos
        }
    }
}

Por que isso é ruim?

O loop interno recomeça do zero a cada iteração, gerando muitas comparações desnecessárias.
Se o array tiver 1.000 elementos, serão 1.000.000 de operações!

💡 Dica: Sempre que precisar de loops aninhados, pergunte-se "posso reduzir isso?".

O(log n) - Tempo Logarítmico

O que fazer (código eficiente - busca binária)

function buscaBinaria(array, alvo) {
    let inicio = 0;
    let fim = array.length - 1;

    while (inicio <= fim) {
        let meio = Math.floor((inicio + fim) / 2);
        if (array[meio] === alvo) {
            return true;
        } else if (array[meio] < alvo) {
            inicio = meio + 1;
        } else {
            fim = meio - 1;
        }
    }
    return false;
}

Por que isso é ótimo?

A cada iteração, eliminamos metade dos elementos.
Um array com 1 milhão de elementos pode ser pesquisado com apenas 20 iterações!

O que evitar (código ineficiente - busca linear em vez de binária)

function buscaLinear(array, alvo) {
    for (let item of array) {
        if (item === alvo) {
            return true;
        }
    }
    return false;
}

Por que isso é ruim?

Se o array for grande, pode precisar percorrer todos os elementos antes de encontrar a resposta.
Para dados ordenados, a busca binária é muito mais eficiente.

💡 Dica: Se o seu conjunto de dados estiver ordenado, sempre prefira a busca binária ao invés de uma busca linear.

Veja uma tabela que mostra de forma simples a eficiencia de cada um:

| Notação      | Exemplo Típico               | Escalabilidade               |
|--------------|------------------------------|------------------------------|
| **O(1)**     | Acessar um item em um array  | 🚀 Super rápido              | 
| **O(log n)** | Busca binária                | 🔥 Muito eficiente           |
| **O(n)**     | Percorrer um array           | ⚡ Razoável                   |
| **O(n²)**    | Loops aninhados              | 🐢 Lento em grandes entradas |

Conclusão

Agora que você viu o que fazer e o que evitar, fica mais fácil aplicar o Big O Notation no seu código. Aqui estão os principais aprendizados:

Prefira O(1) sempre que possível (acessos diretos são mais rápidos).
Evite loops desnecessários e sempre questione se um O(n²) pode ser otimizado.
Se os dados forem ordenados, use busca binária (O(log n)) em vez de percorrer tudo (O(n)).
Código eficiente não é apenas rápido, mas também limpo e fácil de entender.

Ao escrever um algoritmo, pare e pense na eficiência dele. Seu código não precisa ser apenas funcional, mas também rápido e escalável!

Automação de Daily no Slack com GitHub Actions e Python

Priscila Oliveira — Fri, 28 Feb 2025 19:31:45 +0000

📌 Introdução

Se você trabalha com metodologias ágeis, sabe como as dailies são essenciais para manter o time alinhado. Mas e se você pudesse automatizar o lembrete e a escolha do apresentador de cada dia?

O DailyBot resolve isso! 🎉

Ele é um bot automatizado para Slack, que anuncia diariamente a reunião e seleciona automaticamente quem será o próximo apresentador. Tudo isso rodando de forma totalmente automatizada com Python, GitHub Actions e a API do Slack.

Este artigo vai te guiar pelo passo a passo para criar, configurar e automatizar o DailyBot no seu time!

O projeto original se encontra no Github, fique à vontade para abrir issues e pull requests no GitHub!

🛠 Tecnologias Utilizadas

Vamos usar as seguintes ferramentas para implementar o bot:

Python 3.9 → Para programar o bot.
Slack API → Para postar mensagens no canal do time.
GitHub Actions → Para rodar o bot automaticamente todos os dias úteis.
Requests (Python) → Para enviar requisições à API do Slack.

📂 Estrutura do Projeto

O projeto segue uma estrutura organizada para facilitar a manutenção:

.
├── .github/workflows/       # Configuração do GitHub Actions
│   ├── ci.yaml              # Workflow para execução automatizada
├── scripts/                 # Diretório para scripts Python
│   ├── daily_slack.py       # Script responsável pelo envio da mensagem para o Slack
├── .gitignore               # Arquivo para ignorar arquivos desnecessários no repositório
├── LICENSE                  # Licença do projeto
├── README.md                # Documentação do projeto

Agora, vamos ao código! 💻

📢 Criando o Bot no Slack

Antes de rodarmos o DailyBot, precisamos criar um bot no Slack para gerar as credenciais necessárias.

1️⃣ Criando um App no Slack

Acesse 🔗 Create a Slack App.
Clique em "Create New App" e escolha "From Scratch".
Dê um nome ao seu bot (exemplo: DailyBot) e selecione o workspace do seu time.
Vá até OAuth & Permissions e adicione os seguintes escopos:
- chat:write → Para enviar mensagens no canal.
- chat:write.public → Para postar em canais públicos.
- users:read → Para listar os membros do time.
Instale o aplicativo no workspace e copie o Bot User OAuth Token (SLACK_TOKEN).

Agora que o bot já está no Slack, vamos programá-lo! 🛠️

⚙️ Configurando o Script em Python

Crie o arquivo scripts/daily_slack.py e adicione o seguinte código:

import requests
import os
from datetime import datetime

# Obtendo as variáveis de ambiente
SLACK_TOKEN = os.getenv("SLACK_TOKEN")
CHANNEL_ID = os.getenv("CHANNEL_ID")
SLACK_MEMBERS = os.getenv("SLACK_MEMBERS").split(",")

# Calculando o apresentador do dia
execution_number = datetime.utcnow().timetuple().tm_yday  
next_index = (execution_number - 1) % len(SLACK_MEMBERS)  
presenter = f"<@{SLACK_MEMBERS[next_index]}>"

# Mensagem para o Slack
message = (
    f"🎤 Olá pessoal! \n"
    f"Quem apresentará hoje: {presenter}!"
)

# Configuração da API do Slack
url = "https://slack.com/api/chat.postMessage"
headers = {"Authorization": f"Bearer {SLACK_TOKEN}", "Content-Type": "application/json"}
data = {"channel": CHANNEL_ID, "text": message}

# Enviando a mensagem para o Slack
response = requests.post(url, json=data, headers=headers)
print("Mensagem enviada:", response.json())

🔍 Como Funciona a Lógica do Script?

Esse script segue uma lógica simples e eficiente para alternar automaticamente o apresentador da daily.

✅ Passo a passo:

Carregamos as variáveis de ambiente → O token do bot (SLACK_TOKEN), o ID do canal (CHANNEL_ID) e a lista de membros (SLACK_MEMBERS).
Calculamos o dia do ano atual → O execution_number retorna um valor de 1 a 365.
Selecionamos o próximo apresentador → Usamos o operador módulo % para percorrer ciclicamente a lista de membros.
Criamos a mensagem com o apresentador do dia → O Slack usa <@userID> para mencionar um usuário.
Enviamos a mensagem usando a API do Slack.

Exemplo prático:

Se a lista de apresentadores for:

export SLACK_MEMBERS="U12345,U67890,U54321"

O apresentador será alternado conforme o dia do ano:

Dia do Ano	Apresentador
1 (Jan)	U12345
2 (Jan)	U67890
3 (Jan)	U54321
4 (Jan)	U12345 (reinicia)

Essa abordagem garante que o bot sempre escolhe o próximo da fila, sem repetições ou sorteios aleatórios. 🔄

🔄 Automatizando com GitHub Actions

Agora, vamos configurar o GitHub Actions para rodar esse bot automaticamente todos os dias úteis.

📌 Criando o Workflow `.github/workflows/ci.yaml`

Crie o arquivo .github/workflows/ci.yaml e adicione:

name: Daily Slack Notification

on:
  schedule:
    - cron: "30 12 * * 1-5" # Executa às 12:30 (UTC) de segunda a sexta
  workflow_dispatch: # Permite execução manual via GitHub Actions

jobs:
  daily-slack-notification:
    name: Enviar Notificação para o Slack
    runs-on: ubuntu-latest

    steps:
      - name: Checkout do repositório
        uses: actions/checkout@v4

      - name: Configurar Python
        uses: actions/setup-python@v4
        with:
          python-version: "3.9"

      - name: Instalar dependências
        run: pip install requests

      - name: Executar script Python
        run: python scripts/daily_slack.py

📌 Como funciona esse Workflow?

✔️ Execução automática → O cron agendado faz o bot rodar de segunda a sexta às 12:30 UTC.

✔️ Execução manual → Você pode rodar a ação manualmente via GitHub Actions.

✔️ Instalação automática de dependências → O bot instala requests antes de rodar o script.

🎯 Conclusão

Agora você sabe como:

✅ Criar um bot no Slack para anunciar dailies.

✅ Escrever um script Python para enviar mensagens automaticamente.

✅ Configurar um workflow no GitHub Actions para automação diária.

✅ Alternar automaticamente o apresentador da daily com uma lógica eficiente.

Agora sua equipe nunca mais esquecerá a daily e quem irá apresenta-la! 🚀

Se tiver dúvidas ou sugestões, deixe um comentário. Se gostou do artigo, compartilhe com seu time! 😊🔥

Como criar um aplicativo React Native eficiente e fluido

Priscila Oliveira — Wed, 22 Jan 2025 18:52:00 +0000

Construir um aplicativo React Native que ofereça uma experiência ágil e responsiva é essencial para conquistar os usuários. Seja ao lidar com funcionalidades dinâmicas, interfaces detalhadas ou dados em grande escala, investir na otimização do desempenho é fundamental. Neste guia, exploraremos soluções práticas para tornar seu aplicativo mais rápido e eficiente.

Principais fatores que comprometem o desempenho

Identificar as causas de lentidão no app é o primeiro passo para resolver os problemas. Aqui estão alguns motivos comuns:

Renderizações excessivas: Quando componentes são re-renderizados sem necessidade, o consumo de CPU pode aumentar, afetando a fluidez.

Exemplo prático:

import React, { useState } from 'react';
import { View, Text, Button } from 'react-native';

const Counter = React.memo(({ count }) => {
  return <Text>Contagem: {count}</Text>;
});

const App = () => {
  const [counter, setCounter] = useState(0);
  const [unrelated, setUnrelated] = useState(false);

  return (
    <View>
      <Counter count={counter} />
      <Button title="Incrementar" onPress={() => setCounter((prev) => prev + 1)} />
      <Button title="Ação não relacionada" onPress={() => setUnrelated(!unrelated)} />
    </View>
  );
};


export default App;

Uso inadequado de memória: Armazenar muitos dados ou manter componentes pesados ativos pode sobrecarregar o dispositivo.

Exemplo prático:

import React, { useState } from 'react';
import { View, Text, Button } from 'react-native';

const App = () => {
  const [imageUri, setImageUri] = useState(null);

  const loadImage = () => {
    const uri = 'https://placekitten.com/300/300';
    setImageUri(uri);
  };

  return (
    <View>
      <Button title="Carregar Imagem" onPress={loadImage} />
      {imageUri && <Text>Imagem carregada de: {imageUri}</Text>}
    </View>
  );
};

export default App;

Complexidade nos componentes: Estruturas complicadas ou não otimizadas impactam o tempo de resposta, especialmente em dispositivos com hardware limitado.

Exemplo prático:

import React from 'react';
import { View, Text, Button } from 'react-native';

const Header = () => <Text>Bem-vindo ao App!</Text>;

const Footer = () => <Text>Obrigado por usar o App!</Text>;

const App = () => {
  return (
    <View>
      <Header />
      <Button title="Clique Aqui" onPress={() => alert('Ação executada!')} />
      <Footer />
    </View>
  );
};

export default App;

Gerenciamento ineficiente de dados: Carregar muitos registros simultaneamente pode causar travamentos e atrasos.

Exemplo prático:

import React, { useState } from 'react';
import { View, Text, Button } from 'react-native';

const App = () => {
  const [content, setContent] = useState('');

  const fetchData = async () => {
    const response = await fetch('https://api.adviceslip.com/advice');
    const data = await response.json();
    setContent(data.slip.advice);
  };

  return (
    <View>
      <Button title="Carregar Dica" onPress={fetchData} />
      {content && <Text>{content}</Text>}
    </View>
  );
};

export default App;

Chamadas de API mal planejadas: Buscar informações em excesso ou de forma desordenada reduz a velocidade geral do app.

Exemplo prático:

import React, { useState } from 'react';
import { View, Button, Text } from 'react-native';

const App = () => {
  const [quote, setQuote] = useState('');

  const getQuote = async () => {
    const response = await fetch('https://api.quotable.io/random');
    const data = await response.json();
    setQuote(data.content);
  };

  return (
    <View>
      <Button title="Buscar Citação" onPress={getQuote} />
      {quote && <Text>{quote}</Text>}
    </View>
  );
};

export default App;

Listas otimizadas com FlatList: Ao trabalhar com listas extensas, é importante evitar renderizações desnecessárias. O componente FlatList é ideal para gerenciar grandes volumes de dados, garantindo que apenas os elementos visíveis sejam carregados.

Exemplo prático:

import React from 'react';
import { FlatList, View, Text } from 'react-native';

const items = Array.from({ length: 300 }, (_, i) => ({
  key: String(i),
  label: `Item ${i + 1}`,
}));

const App = () => {
  return (
    <FlatList
      data={items}
      renderItem={({ item }) => (
        <View style={{ padding: 10 }}>
          <Text>{item.label}</Text>
        </View>
      )}
      initialNumToRender={20} // Controla o número de itens iniciais renderizados
      keyExtractor={(item) => item.key}
    />
  );
};

export default App;

*Estratégias adicionais:
*

Utilize getItemLayout para acelerar a rolagem ao informar as dimensões dos itens.
Ajuste windowSize para configurar quantos itens adicionais devem ser carregados fora da área visível.

Melhore a renderização com React.memo: O React.memo é uma ferramenta valiosa para evitar renderizações desnecessárias em componentes que recebem props imutáveis ou mudam com pouca frequência.

Exemplo de aplicação:

import React, { memo } from 'react';
import { View, Text } from 'react-native';

const InfoBox = memo(({ title }) => {
    return (
    <View style={{ marginBottom: 10 }}>
      <Text>{title}</Text>
    </View>
  );
});

const App = () => {
  const items = ["Dado 1", "Dado 2", "Dado 3"];

  return (
    <View>
      {items.map((item, index) => (
        <InfoBox key={index} title={item} />
      ))}
    </View>
  );
};

export default App;

Benefícios:

Ideal para componentes que recebem apenas valores fixos.
Evita renderizações desnecessárias, melhorando o uso de recursos.

Evite recalcular valores: Cálculos complexos podem ser otimizados usando useMemo e useCallback, garantindo que os resultados sejam armazenados e reutilizados até que algo relevante mude.

Cenário comum:

import React, { useMemo } from 'react';
import { View, Text } from 'react-native';

const App = ({ numbers }) => {
  const sum = useMemo(() => {
    console.log("Calculando...");
    return numbers.reduce((acc, n) => acc + n, 0);
  }, [numbers]);

  return (
    <View>
      <Text>Total: {sum}</Text>
    </View>
  );
};

export default App;

Vantagens:

Reduz a sobrecarga em cálculos recorrentes.
Facilita a leitura e organização do código.

**Gerencie imagens de forma inteligente: **Carregar imagens pode ser um dos aspectos mais pesados do seu aplicativo. Ferramentas como react-native-fast-image ajudam a implementar caching de maneira eficiente.

Configuração:

import React from 'react';
import FastImage from 'react-native-fast-image';

const App = () => (
  <FastImage
    style={{ width: 100, height: 100 }}
    source={{
      uri: 'https://placekitten.com/100/100',
      priority: FastImage.priority.normal,
    }}
  />
);

export default App;

Por que é importante:

Economiza recursos ao reutilizar imagens carregadas anteriormente.
Melhora a experiência do usuário ao reduzir o tempo de exibição.

Execute animações de forma fluida: Animações podem ser um desafio para a performance. Configurar useNativeDriver: true permite que as animações sejam processadas na thread nativa, garantindo transições mais suaves.

Exemplo de animação simples:

import React, { useRef } from 'react';
import { Animated, Button, View } from 'react-native';

const App = () => {
  const scale = useRef(new Animated.Value(1)).current;

  const animate = () => {
    Animated.spring(scale, {
      toValue: 1.5,
      friction: 3,
      useNativeDriver: true,
    }).start(() => {
      Animated.spring(scale, {
        toValue: 1,
        useNativeDriver: true,
      }).start();
    });
  };

  return (
    <View>
      <Animated.View style={{ transform: [{ scale }], width: 100, height: 100, backgroundColor: 'blue' }} />
      <Button title="Animação" onPress={animate} />
    </View>
  );
};

export default App;

Recomendações:

Prefira threads nativas para evitar travamentos em animações complexas.
Use bibliotecas como react-native-reanimated para recursos adicionais.
Conclusão
Com essas estratégias, é possível criar um aplicativo React Native mais ágil e eficiente. Escolha as soluções que se adaptam melhor ao seu projeto, sempre equilibrando otimização e manutenção do código. Um app bem projetado é a chave para conquistar seus usuários e se destacar no mercado!

Debuggin no VS code com React Native Tools

Priscila Oliveira — Fri, 19 Jul 2024 18:33:15 +0000

Debugging com React Native Tools no VS Code

Hoje vou ensinar um meio de fazer debugging no React Native Expo + VS Code de forma fácil e sem precisar colocar um monte de console.log no código da sua aplicação.

Instalando as Ferramentas

Primeiro de tudo, vamos instalar a extensão "React Native Tools" no VS Code.

Abra o VS Code.
Vá até a aba de extensões (ícone de quadrado com um tracinho).
Pesquise por "React Native Tools".
Clique em "Install" e pronto, extensão instalada!

Configurando o Ambiente

Com a extensão instalada, agora vamos configurar o ambiente pra debugar. Vamos criar um arquivo launch.json dentro da pasta .vscode no seu projeto. Esse arquivo diz ao VS Code como iniciar e anexar o debugger ao seu app React Native.

Abra o seu projeto no VS Code.
Vá até a aba "Run and Debug" (ícone de um play com um inseto).
Clique em "create a launch.json file".
Escolha "Node". (Aqui não fará tanta diferença)

Isso vai gerar um arquivo launch.json básico. Clique no botão de Add configuração.

1.Selecione React Native

2.Attach to application

3.Application in direct mode (Hermes)

Hermes Engine

Ele irá pedir o localhost o qual você devera digital o valor que aparece em seu terminal.

ex: 192.168.20.15

E também irá pedir a porta que por padrão no CLI é: 8081 porém se estiver o expo pode ser 1900 (basta olhar no seu terminal :) )

Seu arquivo JSON deve se parecer com isso aqui:

{
  linkid=xxxx
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Attach to Hermes application",
      "request": "attach",
      "type": "reactnativedirect",
      "cwd": "${workspaceFolder}",
      "address": "192.168.20.15",
      "port":1900
    },
    {
      "type": "node",
      "request": "launch",
      "name": "Launch Program",
      "skipFiles": ["<node_internals>/**"],
      "program": "${file}"
    }
  ]
}

Com isso, já estamos prontos pra debugar tanto no Android quanto no iOS.

Utilizando o Debugger

Agora com tudo configurado, bora ver como usar o debugger de fato.
Na aba do debbuger:
Selecione o mesmo nome que esta no arquivo JSON e de play :)

Dicas Extras

Hot Reloading: Certifique-se de que o Hot Reloading está ativado. Isso permite que você veja as mudanças no código instantaneamente sem precisar reiniciar o app.
React DevTools: Instale o React DevTools pra inspecionar a árvore de componentes e o estado. Isso é super útil pra entender como o estado do seu app tá mudando.

Pronto! Agora você já sabe como configurar e utilizar o debugger do React Native Tools no VS Code. 🚀

Como trabalhar com várias contas do git em uma única máquina

Priscila Oliveira — Mon, 27 May 2024 15:25:28 +0000

Você já se encontrou em uma situação onde precisa ter mais de uma conta Git configurada na mesma máquina? Talvez você precise de uma conta pessoal e outra para a empresa.

Nesses casos, não é interessante ter um usuário global configurado na máquina, pois isso poderia acarretar no problema de fazer um commit com a conta errada para um projeto específico.

Antes de mais nada, vamos configurar duas chaves SSH, uma para cada perfil.

Criando a chave SSH

Abra o seu terminal e digite o seguinte comando:

ssh-keygen -t rsa -b 4096 -C "your_email@example.com"

Isso cria uma nova chave SSH, usando o e-mail fornecido como rótulo.

> Generating public/private ALGORITHM key pair.

Quando for solicitado a "Inserir um arquivo no qual salvar a chave", você pode pressionar Enter para aceitar o local padrão do arquivo.
Porém recomendo mudar o nome do arquivo pois teremos 2 chaves distintas.

> Enter a file in which to save the key (/Users/YOU/.ssh/id_rsa_nome_aqui): [Press enter]

Depois de pressionar enter provavelmente aparcerá a frase a seguir:

> Enter passphrase (empty for no passphrase): [Type a passphrase]

Você pode optar por não usar uma senha para suas chaves SSH. Se preferir adicionar uma senha, digite-a e pressione Enter. Caso contrário, apenas pressione Enter sem digitar nada.

Repita o mesmo procedimento para a segunda chave.

Não se esqueça de adicionar cada chave à sua conta do GitHub ou outro serviço que você esteja utilizando.

Configurando a Chave para Repositórios Distintos

Vamos criar dois aliases para facilitar a configuração do Git.

O que é um "alias"?

Um alias é uma maneira de definir comandos personalizados para economizar tempo e digitar menos.

Abra seu terminal com o editor de sua preferência. Aqui, usaremos o Vim.

$ vim ~/.zshrc

Se você também usa o Vim, pressione "a" para entrar no modo de inserção e cole o seguinte:

# ALIAS CONFIG GIT
alias gcg="git config --edit --global"
alias gcl="git config --edit --local"

Pressione Esc e digite:

:wq!

Agora, recarregue seu arquivo de configuração do seu terminal:

souce ~/.zshrc

Vá até o diretório do seu repositório e abra o terminal a partir dele. Digite:

$ gcl

Isso abrirá o arquivo .git/config do repositório no qual você está. Configure-o da seguinte forma:

[core]
        sshCommand = ssh -i ~/.ssh/sua-chave-ssh -F /dev/null
        repositoryformatversion = 0
        filemode = true
        bare = false
        logallrefupdates = true
        ignorecase = true
        precomposeunicode = true
[remote "origin"]
        url = git@github.com:seu-username/seu-repo
        fetch = +refs/heads/*:refs/remotes/origin/*
[branch "main"]
        remote = origin
        merge = refs/heads/main
[credential]
        username = Seu-username
[user]
        email = seuemail@teste.com
        name = Seu Nome

"~/seu-caminho/seu-repositorio/.git/config" 19L,

Dentro [core] coloque:
sshCommand = ssh -i ~/.ssh/sua-chave-ssh -F /dev/null

Logo a baixo nas últimas linhas coloque:

[credential]
        username = Seu-username
[user]
        email = seuemail@teste.com
        name = Seu Nome

Dessa forma, o repositório específico utilizará as credenciais configuradas.

Não se esqueça de recarregar o arquivo de configuração

source ~/.zshrc

Para atualizar o terminal.

Lembre-se de repetir esse processo para cada repositório em sua máquina.

Espero que isso tenha ajudado!

Como a Comunicação Assertiva Pode Ser o Seu Diferencial no Home Office

Priscila Oliveira — Tue, 21 Nov 2023 21:48:27 +0000

Estava um dia procurando alguns livros sobre comunicação para colocar no meu PDI até que achei este livro: "Comunicação Assertiva" da escritora Débora Brum, e pensei o como seria top compartilhar este conhecimento, e por este motivo estou escrevendo este artigo. Então sem enrolação bora para o que interessa.

Estamos vivendo em uma época em que falar claro e direto faz toda a diferença. Com a pandemia, muita gente teve que adaptar a rotina pro home office, e nesse novo esquema, saber se comunicar bem se tornou uma peça chave. Em 2020, rolou um estudo mostrando que as empresas estão de olho nas chamadas "soft skills", e a que está entre as top é a habilidade de se comunicar.
Ser assertivo é mais que passar um recado; é sobre botar pra fora suas ideias de um jeito que seja fácil de entender, mas sem passar por cima dos sentimentos dos outros. Quando o escritório é a sua casa, essa jogada se torna ainda mais essencial, já que o papo que antes era cara a cara, agora é por tela.
Vamos lá, por que essa tal de comunicação assertiva é chave no home office?

1. Conexão de Verdade: Ao invés de mensagens frias, seu líder marca um bate-papo por vídeo para trocar uma ideia e ver como você está. É uma troca mais humana, isso ajuda a fortalecer os laços e mostra que, mesmo à distância, vocês são uma equipe e podem contar um com os outros.

2. Direto ao Ponto: Tempo é ouro. Está naquela call de planejamento e o pessoal manda a real, sem aquela enrolação. "Olha o prazo é esse, precisamos disso". Transparência, pra ninguém perder tempo e todo mundo saber o que precisa fazer.

3. Deu Ruim? Resolve: Lá está você, codando tranquilo, e de repente: pah! Um bug aparece. Ao invés de ficar batendo a cabeça por horas, você joga no grupo: "Galera, olha esse bug aqui. Bora pensar em como resolver?". Daí todo mundo entra no jogo pra não deixar o barco afundar.

4. Reunião que Flui: Nada de reunião que vira série da Netflix com várias temporadas, né? O pessoal se junta, cada um fala seu ponto sem enrolação. Tem espaço pra todo mundo dar o pitaco e pronto. Rapidamente tá todo mundo de volta ao trabalho, com a missão clara.

5.Apresentação que Pega: Você precisa mostrar o protótipo daquele app que você está desenvolvendo. Então, prepara uns slides massa, fala com empolgação, faz umas demos e até rola umas piadas pra manter a atenção da galera. O objetivo é fazer com que até quem tá de boa em casa fique ligado no que você está falando.

Beleza, e como que a gente melhora essa tal habilidade?
Tomar consciência de ti: Conhecer suas emoções é o que você precisa, é o primeiro passo pra uma comunicação top.
Entenda seu Público: Digamos que você tá lançando um app novo. Não adianta falar do mesmo jeito que você falaria com a galera tech com que não entende nada de tecnologia, certo? Você tem que entender quem tá usando seu produto pra falar a língua deles.
Preparo é Tudo: Tá marcada aquela reunião com um investidor potencial? Não vai na cara e na coragem não. Estuda o perfil dele, o que ele já investiu antes, o que pode chamar a atenção e monta a tua estratégia de abordagem.
Ouvido Afinado: Sabe quando você tá numa conversa e percebe que a outra pessoa já tá pensando na resposta antes mesmo de você terminar de falar? Não seja essa pessoa. Escuta atentamente e faz perguntas que mostram que você tá interessado no que o outro tem a dizer.
Positividade no Ar: Nada de chegar nos seus devs com um "Os bugs estão acabando com a gente". Vira o jogo e diz "Cada bug que a gente resolve deixa nosso app com mais potencial". Mantenha a vibe lá em cima, isso anima a equipe a superar os obstáculos.
Prática Leva à Perfeição: Cada call, cada demonstração é uma chance de melhorar. Errou? Sem stress, analisa onde pode melhorar e vai de novo. Com o tempo, você vai ficar craque em comunicar suas ideias de um jeito que todo mundo entende e curte.

Resumindo, ser assertivo é meio que o ingrediente secreto pra se dar bem trabalhando de casa. Melhora não só como a gente se entende profissionalmente, mas também cria um clima mais tranquilo pra todo mundo. Então, escolhe bem suas palavras e como você as entrega, porque isso muda o jogo. Dominar a comunicação assertiva é garantia de sucesso e uma vida mais tranquila no home office.