Phase 03
Software-Engineering
Saubere Code-Praxis, Versionskontrolle, Code-Reviews, Tests und professionelles Engineering-Denken.
40 Artikel · Seite 1 von 2
Problemzerlegung in Android-Projekten
Du lernst, Features sauber in Teilprobleme zu zerlegen. So planst du Android-Code prüfbar und wartbar.
Pseudocode
Pseudocode hilft dir, Logik vor dem Tippen zu klären. So wird Android-Code planbarer, testbarer und leichter zu prüfen.
Datenstrukturen im Überblick
Datenstrukturen bestimmen, wie deine Android-App Daten hält, findet und verändert. Du lernst Arrays, Listen, Maps und Sets gezielt einzuordnen.
Big-O-Grundlagen
Big-O hilft dir, Laufzeit und Speicherbedarf von Android-Code einzuschätzen. Du lernst, wann Datenmengen spürbar werden.
Suchen in lokalen Android-Daten
Du lernst, wie du lokale Daten passend durchsuchst. So wählst du lineare Suche, binäre Suche oder Lookup bewusst.
Sortierung in Android-Apps
Sortierung bestimmt, welche Daten Nutzer zuerst sehen. Du lernst, wie Ordnung, Comparator und Stabilität Android-Listen verlässlich machen.
Stacks und Queues in Android verstehen
Stacks und Queues erklären LIFO und FIFO im Android-Alltag. Du erkennst sie in Navigation, Tasks und Events.
Bäume und Graphen in Android
Du lernst, wie Hierarchien und Beziehungen Android-Code strukturieren. Der Artikel zeigt dir Traversal an Navigation und Daten.
Rekursion in Kotlin und Android
Rekursion hilft dir, verschachtelte Probleme klar zu lösen. Du lernst, wann sie in Android sinnvoll ist und wann eine Schleife stabiler bleibt.
Caching Concepts in Android
Du lernst, warum Cache Daten schneller macht und zugleich Korrektheit erschwert. Der Artikel zeigt Freshness und Invalidation praxisnah.
Objektorientierte Prinzipien in Android
Du lernst, wie Kapselung, Abstraktion und Polymorphie Android-Code klarer und testbarer machen.
SOLID pragmatisch anwenden
SOLID hilft dir, Android-Code so zu strukturieren, dass Änderungen kontrollierbar bleiben und Tests leichter werden.
Funktionale Prinzipien in Android
Funktionale Prinzipien helfen dir, State-Änderungen klar zu modellieren. So werden Android-Code, Tests und Reviews leichter nachvollziehbar.
Design Patterns im Überblick
Design Patterns helfen dir, Architekturentscheidungen klar zu benennen und ihre Kosten zu verstehen.
Repository Pattern in Android
Repositorys trennen Datenquellen von deiner App-Logik. So bleibt Zugriff testbar, austauschbar und klar.
Observer Pattern in Android
Das Observer Pattern macht Zustandsänderungen sichtbar. Du erkennst es in Flow, Compose State und reaktiven Android-APIs.
Factory Pattern in Android
Factorys bündeln Objekterzeugung. So bleibt Android-Code besser konfigurierbar, testbar und entkoppelt.
Strategy Pattern in Android: Verhalten austauschbar machen
Du lernst, wie das Strategy Pattern Verhalten kapselt. So bleibt Android-Code testbar und erweiterbar.
Dependency Inversion in Android
Dependency Inversion trennt Fachlogik von konkreten Implementierungen. Du lernst, wann Interfaces Tests und Austauschbarkeit verbessern.
Strategie für Fehlerbehandlung
Du lernst, Fehler gezielt einzuordnen. So trennst du behebbare Probleme von Bugs und Abstürzen.
API Thinking in Android
API Thinking hilft dir, stabile Grenzen im Code zu gestalten. Du lernst, öffentliche Funktionen als Verträge zu behandeln.
Lesbarer Code in Android: Namen, Struktur und Absicht
Lesbarer Code zeigt klar, was deine App tut. Du lernst, wie Namen, Struktur und Absicht Android-Code wartbar machen.
Refactoring-Grundlagen
Refactoring verbessert Android-Code, ohne das sichtbare Verhalten zu ändern. Du lernst, wie Tests und kleine Schritte dabei helfen.
Technical Debt in Android-Projekten
Technical Debt entsteht durch bewusste Abkürzungen. Du lernst, Risiken zu erkennen und wartbar zu dokumentieren.