He creado una guía completa y detallada para que tus estudiantes desarrollen Shiny Apps usando Positron, el nuevo IDE con IA integrada. La guía está diseñada desde cero, pensando en quienes solo conocen RMarkdown básico.
| Sección | Contenido | Tiempo estimado |
|---|---|---|
| Parte 1 | Qué es Positron, diferencias con RStudio, el Modo Agente de IA | 10 min |
| Parte 2 | Instalación de Positron, configuración de R, extensiones recomendadas | 15 min |
| Parte 3 | Primera Shiny App en Positron, diferencias con Posit Cloud | 20 min |
| Parte 4 | Uso del Modo Agente de Copilot: crear apps, depurar errores, explicar código | 20 min |
| Parte 5 | Estructura profesional de proyectos, separar en ui.R/server.R/global.R | 15 min |
| Parte 6 | Publicar en shinyapps.io desde Positron (paso a paso) | 15 min |
| Parte 7 | Depuración profesional con breakpoints y watch | 10 min |
| Parte 8 | 3 ejercicios prácticos progresivos | 30 min |
| Parte 9 | Control de versiones con Git integrado | 10 min |
| Parte 10 | Atajos de teclado imprescindibles | 5 min |
| Anexo | Solución de problemas comunes | - |
Positron es el nuevo IDE (Entorno de Desarrollo Integrado) creado por Posit (antes RStudio). Es como RStudio, pero modernizado:
| Característica | RStudio / Posit Cloud | Positron |
|---|---|---|
| Base | Aplicación propietaria | Basado en VS Code (Visual Studio Code) |
| Lenguajes | Principalmente R | R, Python, JavaScript, TypeScript, SQL |
| IA integrada | Copilot como add-on | Copilot/GitHub Copilot integrado nativamente |
| Modo Agente | No disponible | Disponible (IA que escribe y ejecuta código por ti) |
| Extensiones | Addins de R | Miles de extensiones del marketplace de VS Code |
| Terminal | Terminal integrada | Terminal más potente, múltiples sesiones |
| Velocidad | Buena | Más rápida, más ligera |
Es una función revolucionaria donde la IA (como GitHub Copilot) no solo completa código, sino que: - Entiende tu proyecto completo - Escribe archivos completos por ti - Ejecuta comandos en terminal automáticamente - Depura errores sola - Crea estructuras de proyectos desde cero
Ejemplo:
Tú: "Crea una Shiny App que lea un CSV y muestre un histograma interactivo"
IA: Genera app.R, instala paquetes, crea la interfaz, y la ejecuta. Tú solo revisas..exe.dmg (Intel o Apple Silicon).deb o .rpmPositron necesita que R ya esté instalado en tu computador.
¿Cómo saber si tengo R? - Abre una terminal (CMD en
Windows, Terminal en Mac/Linux) - Escribe: R --version - Si
ves un número de versión, ¡está instalado!
Si NO tienes R instalado: 1. Ve a: https://cran.r-project.org/ 2. Descarga R para tu sistema operativo 3. Instálalo con las opciones por defecto
Ctrl+Shift+P (o Cmd+Shift+P en
Mac)R: Create New R TerminalPositron usa el marketplace de VS Code. Ve al icono de Extensiones (cuadrado de bloques a la izquierda) e instala:
| Extensión | Para qué sirve |
|---|---|
| R (de REditorSupport) | Syntax highlighting, autocompletado, linting |
| R Debugger | Depurar código R paso a paso |
| Rainbow CSV | Visualizar archivos CSV con colores |
| GitHub Copilot | IA que escribe código (requiere cuenta GitHub) |
| GitHub Copilot Chat | Chat con IA sobre tu código |
| Radian (opcional) | Terminal R más bonita y funcional |
Ctrl+K Ctrl+O)mi-primera-shinyapp.R (¡exactamente así, en minúsculas!)library(shiny)
# ---- UI: Lo que se ve ----
ui <- fluidPage(
titlePanel("Hola Mundo Shiny"),
sidebarLayout(
sidebarPanel(
sliderInput("n", "Número de datos:", min = 10, max = 1000, value = 100)
),
mainPanel(
plotOutput("hist")
)
)
)
# ---- SERVER: La lógica ----
server <- function(input, output) {
output$hist <- renderPlot({
hist(rnorm(input$n), col = "steelblue", main = paste("Histograma con", input$n, "datos"))
})
}
# ---- Ejecutar ----
shinyApp(ui = ui, server = server)Método 1: Desde la terminal de R
# En la consola de R dentro de Positron:
shiny::runApp("app.R")Método 2: Con atajo de teclado 1. Abre el archivo
app.R 2. Presiona Ctrl+Shift+Enter (ejecuta el
archivo completo) 3. La app se abre en tu navegador o en una pestaña
interna
Método 3: Botón Run (truco en Positron) 1. Abre
app.R 2. Ve a la terminal 3. Escribe y ejecuta:
source("app.R")
| Acción | Posit Cloud | Positron (local) |
|---|---|---|
| Ejecutar app | Botón “Run App” | shiny::runApp() o source() |
| Instalar paquetes | En consola del cloud | En terminal local |
| Archivos | En la nube | En tu computador |
| Persistencia | Se guarda automático | Tú guardas con Ctrl+S |
| Publicar | Botón “Publish” | Comando deployApp() |
Esta es la función más poderosa de Positron. Te enseño cómo usarla para acelerar el desarrollo de Shiny Apps.
Ctrl+Shift+P → “GitHub Copilot: Login”Presiona Ctrl+Alt+I (o Cmd+Ctrl+I en Mac)
para abrir el chat.
Prompt que escribes:
Crea una Shiny App que:
1. Tenga un fileInput para subir archivos CSV
2. Muestre una tabla con DT::datatable
3. Tenga un selectInput para elegir la variable X y otra para Y
4. Genere un gráfico de dispersión con ggplot2
5. Use tema bonito con bslib::page_fluidLo que hace Copilot: - Genera el archivo
app.R completo - Te sugiere instalar paquetes faltantes -
Explica cada parte del código
Prompt:
Mi app.R da este error: "Error in ..object:not found 'input$mi_tabla'"
¿Qué puede estar mal?Respuesta de Copilot:
El error indica que output$mi_tabla está intentando acceder a input$mi_tabla, pero este input no existe en tu UI. Verifica que:
1. El inputId coincida exactamente (distingue mayúsculas/minúsculas)
2. El input esté definido en la UI antes de usarlo en el serverPrompt:
Explica qué hace esta función de una Shiny App paso a paso, como si yo fuera estudiante de primer semestre:
observeEvent(input$boton_analizar, {
req(input$archivo)
datos <- read.csv(input$archivo$datapath)
output$tabla <- renderDT({ datatable(datos) })
})Respuesta esperada:
1. observeEvent: "Observa" cuando el usuario presiona el botón
2. req(): Verifica que haya un archivo antes de continuar
3. read.csv(): Lee el archivo CSV subido
4. input$archivo$datapath: Obtiene la ubicación temporal del archivo
5. renderDT(): Crea una tabla interactiva que se muestra en la UI| Comando | Qué hace |
|---|---|
/fix |
Corrige el código seleccionado |
/explain |
Explica el código seleccionado |
/tests |
Genera pruebas automáticas |
/doc |
Genera documentación |
/new |
Crea un nuevo archivo |
mi-shiny-app/
│
├── app.R # Archivo principal (puede dividirse)
├── ui.R # Interfaz de usuario (opcional, separado)
├── server.R # Lógica del servidor (opcional, separado)
├── global.R # Configuración global y carga de datos
│
├── data/ # Datos del proyecto
│ └── datos_ejemplo.csv
│
├── R/ # Funciones auxiliares
│ ├── utils.R # Funciones de utilidad
│ └── calculos.R # Funciones de cálculo
│
├── www/ # Archivos estáticos (imágenes, CSS)
│ ├── logo.png
│ └── estilos.css
│
├── tests/ # Pruebas (avanzado)
│ └── test_app.R
│
├── renv/ # Control de dependencias (avanzado)
│
└── README.md # Documentación del proyectoCuando la app crece, separar en archivos mejora la organización:
ui.R:
ui <- fluidPage(
titlePanel("Mi App"),
sidebarLayout(
sidebarPanel(
fileInput("archivo", "Sube CSV"),
selectInput("variable", "Variable:", choices = NULL)
),
mainPanel(
plotOutput("grafico"),
DTOutput("tabla")
)
)
)server.R:
server <- function(input, output, session) {
datos <- reactive({
req(input$archivo)
read.csv(input$archivo$datapath)
})
observe({
updateSelectInput(session, "variable", choices = names(datos()))
})
output$tabla <- renderDT({
datatable(datos())
})
output$grafico <- renderPlot({
req(input$variable)
hist(datos()[[input$variable]], main = input$variable)
})
}global.R (carga al inicio):
library(shiny)
library(DT)
library(ggplot2)
# Funciones compartidas
formato_dinero <- function(x) {
paste0("$", formatC(x, big.mark = ".", decimal.mark = ",", digits = 0))
}En Positron, abres cualquiera de estos archivos y ejecutas
shiny::runApp() desde la terminal.
En la terminal de Positron (pestaña Terminal abajo):
install.packages("rsconnect")En la consola de R dentro de Positron, pega y ejecuta el comando copiado:
rsconnect::setAccountInfo(
name='tu-usuario',
token='TU_TOKEN_AQUI',
secret='TU_SECRET_AQUI'
)Opción A: Comando en consola
library(rsconnect)
deployApp(
appDir = ".", # Carpeta actual
appName = "mi-app-shiny", # Nombre en shinyapps.io
appTitle = "Mi Primera Shiny App"
)Opción B: Archivo de despliegue (recomendado para clase)
Crea un archivo deploy.R en tu proyecto:
# ============================================================================
# Script de despliegue a shinyapps.io
# ============================================================================
# 1. Verificar paquetes
paquetes <- c("shiny", "shinyjs", "bslib", "DT", "plotly", "ggplot2")
for (pkg in paquetes) {
if (!requireNamespace(pkg, quietly = TRUE)) {
install.packages(pkg)
}
}
# 2. Cargar rsconnect
library(rsconnect)
# 3. Desplegar (reemplaza con tu nombre)
deployApp(
appName = "evaluador-volantes",
appTitle = "Evaluador de Volantes de Pago"
)Para publicar: abre deploy.R y ejecuta con
Ctrl+Shift+Enter.
Si todo sale bien, verás:
Preparing to deploy application...DONE
Uploading bundle for application: 1234567...DONE
Deploying bundle: 9876543 for application: 1234567 ...
Application successfully deployed to https://tu-usuario.shinyapps.io/mi-app-shiny/¡Haz clic en la URL y compártela!
Positron trae herramientas profesionales de depuración:
server <- function(input, output) {
output$grafico <- renderPlot({
# PON UN BREAKPOINT AQUÍ (clic en margen izquierdo)
req(input$variable) # Se pausa aquí
datos <- mtcars
# En consola puedes escribir: head(datos)
# Y verás los primeros datos
plot(datos[[input$variable]])
})
}Cuando la app está corriendo, Positron muestra: - Consola de R: Errores de R - Terminal: Mensajes del sistema - Output: Mensajes de Shiny
Usa Copilot Chat (Ctrl+Alt+I) y pide:
Crea una Shiny App minimalista que calcule el coeficiente de correlación entre dos variables seleccionadas del dataset mtcars.Copilot generará el código. Tú solo: 1. Crea app.R 2.
Pega el código 3. Ejecuta con shiny::runApp()
Crea desde cero:
library(shiny)
library(DT)
library(ggplot2)
ui <- fluidPage(
titlePanel("Análisis Exploratorio Automático"),
fileInput("file", "Sube un CSV"),
selectInput("x", "Variable X:", choices = NULL),
selectInput("y", "Variable Y:", choices = NULL),
plotOutput("plot"),
DTOutput("table")
)
server <- function(input, output, session) {
data <- reactive({
req(input$file)
read.csv(input$file$datapath)
})
observe({
vars <- names(data())
updateSelectInput(session, "x", choices = vars, selected = vars[1])
updateSelectInput(session, "y", choices = vars, selected = vars[2])
})
output$table <- renderDT({
datatable(head(data(), 20))
})
output$plot <- renderPlot({
req(input$x, input$y)
ggplot(data(), aes_string(x = input$x, y = input$y)) +
geom_point(color = "steelblue", size = 3) +
theme_minimal()
})
}
shinyApp(ui, server)library(shiny)
library(bslib)
library(ggplot2)
ui <- page_fluid(
theme = bs_theme(bootswatch = "minty"), # Tema pastel
title = "Dashboard de Ventas",
card(
card_header("Filtros"),
layout_column_wrap(
width = 1/3,
selectInput("region", "Región:", choices = c("Norte", "Sur", "Este", "Oeste")),
dateRangeInput("fechas", "Periodo:", start = "2024-01-01"),
actionButton("filtrar", "Aplicar", class = "btn-primary")
)
),
card(
card_header("Resultados"),
plotOutput("grafico_ventas")
)
)
server <- function(input, output) {
output$grafico_ventas <- renderPlot({
# Simulación de datos
datos <- data.frame(
mes = month.abb,
ventas = sample(1000:5000, 12)
)
ggplot(datos, aes(x = mes, y = ventas)) +
geom_col(fill = "steelblue") +
coord_flip() +
theme_minimal()
})
}
shinyApp(ui, server)1. Haces cambios en app.R
2. Guardas con Ctrl+S
3. En Source Control, ves los archivos modificados
4. Escribes un mensaje: "Agregué gráfico de barras"
5. Clic en ✓ Commit
6. Clic en ... → Push (si tienes GitHub conectado)Ctrl+J)git remote add origin https://github.com/tu-usuario/tu-repo.git
git branch -M main
git push -u origin main| Atajo | Acción |
|---|---|
Ctrl+Shift+P |
Paleta de comandos (todo) |
Ctrl+J |
Mostrar/ocultar terminal |
Ctrl+Shift+Enter |
Ejecutar archivo R completo |
Ctrl+Enter |
Ejecutar línea seleccionada |
Ctrl+Alt+I |
Abrir Copilot Chat |
Ctrl+S |
Guardar archivo |
Ctrl+Shift+T |
Nueva terminal |
Ctrl+Shift+C |
Comentar/descomentar líneas |
Ctrl+Shift+F |
Buscar en todo el proyecto |
Ctrl+K Z |
Modo Zen (sin distracciones) |
Ctrl+Shift+M |
Insertar chunk RMarkdown |
# Windows: Agregar R al PATH
# 1. Busca "Variables de entorno" en Windows
# 2. Edita "Path" del usuario
# 3. Agrega: C:\Program Files\R\R-4.x.x\bin\x64
# Mac/Linux: En terminal
export PATH="/usr/local/bin:$PATH"# Positron usa renv o packrat para detectar dependencias
# Asegúrate de cargar todos los paquetes en app.R:
library(shiny)
library(DT) # Si usas tablas
library(ggplot2) # Si usas gráficos
library(bslib) # Si usas temasAlgunos temas de bslib necesitan versión específica:
# En app.R, al inicio:
options(bslib.version = 5)Ctrl+Shift+P → “Copilot:
Sign In”Semana 1: Shiny básico en Positron
├── Día 1: Instalar Positron, crear app.R mínima
├── Día 2: Inputs y outputs
├── Día 3: Reactividad básica
└── Día 4: Publicar primera app en shinyapps.io
Semana 2: Shiny intermedio
├── Día 1: fileInput y tablas con DT
├── Día 2: Gráficos interactivos con plotly
├── Día 3: Tabs y layout con bslib
└── Día 4: Modo Agente de Copilot
Semana 3: Shiny avanzado (proyecto final)
├── Día 1: Diseño del proyecto
├── Día 2: Desarrollo con IA asistida
├── Día 3: Pruebas y depuración
└── Día 4: Publicación y documentación| Recurso | Enlace |
|---|---|
| Positron GitHub (descargas) | https://github.com/posit-dev/positron |
| Documentación Positron | https://positron.posit.co/ |
| Shiny oficial | https://shiny.posit.co/ |
| bslib (temas) | https://rstudio.github.io/bslib/ |
| shinyapps.io | https://www.shinyapps.io/ |
| GitHub Student Pack | https://education.github.com/ |
Con esta guía, tus estudiantes deberían ser capaces de: 1. Instalar y configurar Positron 2. Crear Shiny Apps desde cero 3. Usar IA asistida (Copilot) para acelerar el desarrollo 4. Publicar aplicaciones en shinyapps.io 5. Depurar errores como profesionales
¡Éxitos con Positron! Es una herramienta increíble que les abrirá muchas puertas en el mundo del análisis de datos.