Seminar R und RStudio – Intensivseminar Softwareentwicklung und Shiny

Seminarbeschreibung

Ein interaktives Analysewerkzeug benötigt mehr als eine ansprechende Oberfläche. Dieses Intensivseminar baut die fachliche Berechnung als klar gegliederten R-Code auf, sichert sie durch Tests ab und macht sie anschließend über Shiny bedienbar. Ein gemeinsames Projekt reduziert Wiederholungen zwischen Programmierung, Paketbau und Anwendungsentwicklung.

Die Kernthemen der drei Fachseminare Fortgeschrittene Programmierung, Paketentwicklung und Shiny werden in einem abgestimmten Arbeitsablauf zusammengeführt. Die Verdichtung setzt sichere eigene Programmierpraxis in R voraus. Detailfragen zu komplexer Metaprogrammierung, umfangreichen Testinfrastrukturen und großen Shiny-Architekturen bleiben den jeweiligen Vertiefungen vorbehalten. Der Server wird für die Bereitstellungsübung vorbereitet.

Zielgruppe

Erfahrene R-Anwender, Entwickler und Data Scientists, die wartbare Analysewerkzeuge mit interaktiver Oberfläche entwickeln möchten.

Voraussetzungen

Sicheres R mit eigenen Funktionen, Listen, dplyr und ggplot2 sowie erster Fehlerbehandlung. Erfahrung mit mehrteiligen Skripten und grundlegender Terminalnutzung. Erste Shiny- oder Git-Erfahrung ist hilfreich. Ein Einstieg in die Programmierung von Grund auf ist nicht vorgesehen.

Lernziele

• Fachlogik, Eingabeprüfung und Darstellung in klar getrennten Einheiten entwickeln.
• Wiederverwendbare Funktionen in einem dokumentierten R-Paket bündeln.
• Tests und automatisierte Checks mit einem nachvollziehbaren Git-Ablauf verbinden.
• Eine modulare Shiny-Oberfläche erstellen und mit dokumentierten Abhängigkeiten bereitstellen.

Inhaltsübersicht

1. Funktionen und Programmschnittstellen
2. Iteration und Automatisierung
3. Debugging und Leistung
4. R-Paket und Dokumentation
5. Tests und Paketprüfung
6. Git, Abhängigkeiten und CI
7. Shiny und Reaktivität
8. Benutzbare Oberfläche und Eingabeprüfung
9. Module und Anwendungstests
10. Kontrollierte Bereitstellung

Seminarinhalte

Funktionen und Programmschnittstellen

Die Anwendung erhält klar definierte fachliche Bausteine.

• Argumente, Rückgaben, Typen und Gültigkeitsbereiche bewusst gestalten.
• Globale Zustände vermeiden und Seiteneffekte begrenzen.
• Eingaben anhand fachlicher Regeln prüfen.

Iteration und Automatisierung

Wiederkehrende Datenläufe werden parameterisiert ausgeführt.

• Vektorisierung, Schleifen und Listenverarbeitung passend einsetzen.
• Konfiguration von Berechnung trennen und mehrere Eingaben kontrolliert verarbeiten.
• Rscript, Umgebungsvariablen, Protokolle und Exit-Codes in einem kleinen Ablauf nutzen.

Debugging und Leistung

Fehler und Engpässe werden anhand nachvollziehbarer Befunde bearbeitet.

• Warnungen und Fehler gezielt behandeln sowie RStudio-Debuggingwerkzeuge einsetzen.
• Eine fehlerhafte Verarbeitung mit einem minimalen Beispiel eingrenzen.
• Profiling zur Auswahl einer gezielten Laufzeitverbesserung verwenden.

R-Paket und Dokumentation

Die Fachlogik wird unabhängig von der Oberfläche installierbar.

• Paketstruktur, DESCRIPTION und NAMESPACE aufbauen.
• Öffentliche und interne Funktionen unterscheiden.
• Mit roxygen2 Argumente, Rückgaben und ausführbare Beispiele dokumentieren.

Tests und Paketprüfung

Verhalten und bekannte Randfälle werden dauerhaft prüfbar.

• Normalfälle, Grenzfälle und erwartete Fehler mit testthat absichern.
• Zufall und externe Abhängigkeiten in Tests kontrollieren.
• R CMD check ausführen und relevante Meldungen bearbeiten.

Git, Abhängigkeiten und CI

Änderungen werden nachvollziehbar zusammengeführt und geprüft.

• Branches, Commits und einen einfachen Merge-Konflikt bearbeiten.
• Paketabhängigkeiten und renv-Projektumgebung auseinanderhalten.
• Einen vorbereiteten CI-Workflow für Tests und Paketprüfung anpassen.

Shiny und Reaktivität

Die Oberfläche steuert kontrollierte Berechnungen.

• UI und Serverlogik mit Eingaben, Tabellen und Diagrammen verbinden.
• Reactive Expressions, Renderfunktionen und Observer gezielt verwenden.
• Berechnungen ereignisbezogen auslösen und Sitzungszustände trennen.

Benutzbare Oberfläche und Eingabeprüfung

Die Anwendung bleibt auch bei ungültigen Eingaben verständlich.

• Ein konsistentes Layout mit bslib gestalten.
• Mit req und validate fehlende oder unzulässige Werte behandeln.
• Uploads anhand von Struktur, Format und Umfang prüfen.

Module und Anwendungstests

Die Oberfläche bleibt überschaubar und überprüfbar.

• Einen Anwendungsteil in ein Modul mit eigenem Namensraum auslagern.
• Fachliche Paketfunktionen aus der Serverlogik aufrufen.
• Serverlogik mit testServer prüfen und einen vorbereiteten Oberflächentest ausführen.

Kontrollierte Bereitstellung

Die Anwendung wird außerhalb des Entwicklungsprojekts gestartet.

• Konfiguration, Systemvoraussetzungen und Paketstände dokumentieren.
• Die Anwendung auf einem vorbereiteten Shiny Server bereitstellen.
• Zwei getrennte Sitzungen, Protokolle und den Umgang mit einem Anwendungsfehler prüfen.

Praxisprojekt

1. Eine bestehende Analyse in klare Funktionen und Konfiguration zerlegen.
2. Ein kleines Paket mit Dokumentation und Tests erstellen.
3. Eine Änderung über Git zusammenführen und den vorbereiteten CI-Lauf prüfen.
4. Eine Shiny-Oberfläche entwickeln, die die Paketfunktionen verwendet.
5. Die Anwendung modularisieren, testen und auf der vorbereiteten Umgebung starten.