Você já construiu um app Shiny. Provavelmente já tem um ui <- fluidPage(...), um server <- function(input, output, session), um sliderInput conectado a um renderPlot, e viu o gráfico se atualizar quando arrastou o controle. Este curso começa exatamente onde esse "primeiro app" termina. A pergunta que guia tudo aqui não é "como faço um app reagir a um input?", e sim "como transformo um protótipo reativo em um produto — rápido, bonito, seguro, modular, versionado e implantado em produção para centenas de usuários?".

A distância entre um app de tutorial e um dashboard profissional é enorme, e ela quase nunca aparece nos materiais introdutórios. Apps reais quebram por motivos concretos: gráficos que não conversam entre si, mapas que recarregam o mundo inteiro a cada clique, tabelas que travam com 100 mil linhas, formulários sem validação que corrompem dados, credenciais hard-coded no código, CSS copiado do StackOverflow que não escala, um único app.R de 4.000 linhas impossível de manter, e o clássico "funciona na minha máquina" que morre no servidor. Este curso ataca cada um desses pontos, na ordem em que eles aparecem quando um projeto amadurece.

Formar um desenvolvedor capaz de projetar, estilizar, modularizar, documentar, versionar e implantar aplicações Shiny de nível profissional — com visualizações altamente interativas (gráficos sincronizados, mapas, redes), tabelas de alta performance, camadas de notificação/validação/segurança, identidade visual própria e uma esteira de deploy reprodutível (Docker, ShinyProxy). Ao final, você também terá noções de Shiny para Python, para atuar em projetos híbridos R/Python.

Pré-requisitos e como usá-los

Este é um curso avançado. Assumimos que você:

  • Programa em R com desenvoltura: vetores, listas, data.frame/tibble, funções, if/for, e a família apply/purrr::map. Se isso estiver enferrujado, revise a trilha de fundamentos de R do curso Machine Learning Avançado (Aulas de introdução ao R e tidyverse) — não vamos repetir a linguagem aqui.
  • Manipula e visualiza dados: dplyr, tidyr e ggplot2 no dia a dia. Vamos usá-los o tempo todo, sem reintroduzi-los.
  • Já viu Shiny pelo menos uma vez: sabe o que é ui, server, um *Input() e um render*(). Não exigimos domínio de reatividade — a arquitetura reativa faz uma recapitulação densa disso, porque é a fundação de tudo que vem depois.

Não é pré-requisito: geoespacial, redes, Docker, Golem, CSS/Sass ou Python. Tudo isso é construído do zero ao longo do curso.

Como o curso está organizado

Cada aula segue o mesmo ritmo: um problema real → a solução idiomática em R → código completo e executável → armadilhas comuns → resumo → exercícios com gabarito → referências. Os módulos progridem do conteúdo (o que o app mostra) para a forma (como ele parece e responde) e finalmente para a engenharia (como ele é mantido e implantado):

Fundação

  • A Arquitetura Reativa do Shiny — o grafo de reatividade, reactive/observe/eventReactive, isolate, req/validate e reactiveVal. A base conceitual de tudo o que vem depois.

Conteúdo — o que o app mostra

Forma — como ele parece e responde

Engenharia — como ele é mantido e implantado

Uma palavra sobre a mentalidade

Shiny tem uma fama injusta de "não escalar" e "não ser para produção". Essa fama vem de apps construídos como scripts — um bloco gigante de código reativo sem estrutura. O Shiny moderno (com bslib, módulos, golem, renv e contêineres) é uma plataforma de produção séria, usada por bancos, farmacêuticas e agências governamentais. A diferença entre o protótipo e o produto não é a linguagem — é a engenharia. É isso que você vai aprender aqui.

Este é um curso avançado de Shiny: o foco é levar apps de protótipo a produto de produção. R, tidyverse e ggplot2 são pré-requisitos e não serão reensinados — para a base de R, há a trilha do curso de Machine Learning. A reatividade é a exceção: ela é recapitulada logo na primeira aula, por ser a fundação de tudo o que vem depois. O percurso vai do conteúdo — visualizações e tabelas — para a forma, com responsividade e identidade visual, e termina na engenharia: módulos, Golem, Docker e ShinyProxy. A promessa é que você saia capaz de projetar, estilizar e implantar dashboards profissionais, com noções de Shiny em Python de quebra.

Exercícios

  1. Por que um app.R monolítico de milhares de linhas é um problema, mesmo que "funcione"?

    ✓ Resposta:

    Porque "funcionar" e "ser mantível" são coisas diferentes. Um monólito não tem fronteiras claras entre componentes, o que torna impossível testar partes isoladamente, reaproveitar UI/lógica, trabalhar em equipe sem conflitos de merge, e rastrear de onde vem um bug. Além disso, IDs de input/output colidem globalmente, o que gera bugs silenciosos. A solução — módulos Shiny e estrutura de pacote (Golem) — é o tema dos Módulos 7 e 8. Manutenibilidade é um requisito de produção, não um luxo.

  2. O curso separa "conteúdo", "forma" e "engenharia". Classifique cada item: (a) escolher uma paleta de cores da marca, (b) sincronizar um gráfico com uma tabela, (c) escrever um Dockerfile.

    ✓ Resposta:

    (a) Forma — identidade visual (identidade visual). (b) Conteúdo — como as visualizações se comportam e interagem (visualizações sincronizadas). (c) Engenharia — reprodutibilidade e implantação (implantação com Docker). Essa separação é útil porque cada camada tem ferramentas e preocupações próprias; misturá-las é uma das causas de apps difíceis de manter.

  3. Verdadeiro ou falso: "Shiny não serve para produção". Justifique.

    ✓ Resposta:

    Falso, com ressalva. Shiny escrito como script não serve para produção séria. Shiny bem-engenheirado — modularizado, versionado com renv, conteinerizado e servido por ShinyProxy/Posit Connect — roda em produção em setores regulados (finanças, saúde). A limitação histórica é de arquitetura do código e de deploy, não da tecnologia. Todo o segundo metade deste curso existe para fechar essa lacuna.

Fontes e leituras recomendadas