Wenn du beim Programmieren ganz von vorne anfängst, brauchst du keine verstreuten Tipps — du brauchst einen klaren Pfad, ein praktisches Set an Werkzeugen und ein Projekt, das beweist, dass du das Gelernte anwenden kannst. Dieses Tutorial bietet einen strukturierten Fahrplan, kuratierte Ressourcen und eine Schritt-für-Schritt-Anleitung zum Erstellen deines ersten echten Projekts. Es richtet sich an motivierte Lernende, die einen ernsthaften Plan ohne Füllmaterial wollen: Du wirst verstehen, was du lernen musst, in welcher Reihenfolge, mit welchen Werkzeugen und wie du Fortschritt misst. Am Ende hast du einen funktionierenden Habit-Tracker, den du vorzeigen kannst, Tests, die ihn robust halten, und ein portfolio-reifes Repository, das echte Fähigkeiten demonstriert.

Mindset und Lernstrategie

• Lerne durch Machen. Lesen und Zuschauen reicht nicht. Messe Fortschritt an ausgelieferten Features, nicht an gelesenen Seiten.
• Nutze spaced repetition und Retrieval Practice. Nachdem du ein Konzept gelernt hast, schließe den Tab und schreibe es aus dem Gedächtnis auf. Selbsttests verankern Ideen.
• Konzentriere dich auf Feedback-Loops. Schreibe kleine Programme, führe sie aus, lies Fehlermeldungen, behebe sie, wiederhole. Enge Zyklen schlagen lange Lernblöcke.
• Akzeptiere Fehler. Führe ein „Bug-Journal“ mit Bug, Ursache, Lösung und wie man ihn künftig verhindert. Dein zukünftiges Ich wird es dir danken.
• Plane Konsistenz über Intensität. 60–90 Minuten täglich schlagen 6 Stunden einmal pro Woche. Baue Momentum auf.
• Entwickle mentale Modelle. Merk dir nicht nur Syntax; verstehe das Modell (wie Speicher aussieht, wie Daten fließen, wie Funktionen einander aufrufen).

Der Fahrplan: Ein 12-Wochen-Plan

Du kannst diesen Plan komprimieren oder ausdehnen, aber halte seine Struktur: Grundlagen → Kernfähigkeiten → Werkzeuge → Projekt → Verfeinerung.

• Wochen 0–1: Orientierung und Setup
  • Wähle eine primäre Sprache (Python oder JavaScript empfohlen).
  • Installiere deine Werkzeuge: Editor (VS Code), Git, Sprachruntime und ein Testframework.
  • Absolviere 5–10 kleine Übungen, um Syntax und Ein-/Ausgabe (print, Variablen, Bedingungen, Schleifen) zu lernen.
• Wochen 2–3: Kernprogrammierung
  • Funktionen, Datenstrukturen (Listen/Arrays, Dicts/Objects, Sets), Schleifen vs. Comprehensions, grundlegende Algorithmen.
  • Schreibe winzige Hilfsprogramme: Einen Einheitenskonverter, einen einfachen Taschenrechner, einen Dateizusammenfasser.
• Wochen 4–5: Datenstrukturen und Algorithmen (Essentials)
  • Sortieren und Suchen, Zeitkomplexität (Big O) auf hohem Niveau, Stacks/Queues/Maps/Sets.
  • Implementiere ein paar Algorithmen von Hand, löse dann 10–15 Übungsaufgaben.
• Woche 6: Werkzeuge und Workflows
  • Disziplin bei Versionskontrolle (Branches, Commits, Pull Requests).
  • Linter, Formatter, Tests, Debugging, Logging.
• Wochen 7–8: Spezialisierungs-Sampler
  • Web (HTML/CSS/JS) oder Daten (pandas/NumPy/Matplotlib) oder CLI-Automatisierung.
  • Baue ein Mikroprojekt in deiner gewählten Richtung.
• Wochen 9–10: Erstes echtes Projekt (Habit-Tracker)
  • Entwurf, Scaffold, inkrementelle Implementierung von Features mit Tests.
• Woche 11: Verfeinerung
  • Refaktorieren, Dokumentation hinzufügen, UX verbessern, Fehlerbehandlung härten, einfache Analysen ergänzen.
• Woche 12: Veröffentlichen und Reflektieren
  • Deployment (CLI-Packaging oder statisches Hosting), README schreiben, teilen, Feedback sammeln, Lektionen notieren.

Tipp: Wenn du nur 30 Tage hast, komprimiere, indem du die Breite reduzierst, nicht die Qualität. Behalte das Projekt und Tests; verringere die Anzahl der Nebenübungen.

Wahl deiner ersten Programmiersprache

Wähle eine primäre Sprache und bleibe mindestens drei Projekte lang dabei, bevor du dich neu orientierst.

• Python
  • Warum: Freundliche Syntax, starkes Ökosystem für Daten und Scripting, viele Lernressourcen.
  • Gut geeignet für: Datenanalyse, Automatisierung, Prototyping, Backend-APIs.
  • Werkzeuge: Python 3.12+ oder aktuellste Version, virtuelle Umgebungen, pytest, black/ruff.
• JavaScript (optional später TypeScript)
  • Warum: Läuft überall (Browser + Node.js), sofort sichtbare Ergebnisse, riesiges Ökosystem.
  • Gut geeignet für: Webentwicklung, interaktive UIs, Full-Stack mit Node.
  • Werkzeuge: Node.js LTS (20/22), npm oder pnpm, ein Test-Runner (Vitest/Jest), ESLint, Prettier.
• Andere (optionale Wahl je nach Ziel)
  • C#: Starke Tools unter Windows, Spieleentwicklung (Unity), Unternehmensanwendungen.
  • Go: Einfache Concurrency und deploybare Binaries für Backend-Services.
  • Rust: Systemprogrammierung mit Sicherheit; steilere Lernkurve.

Faustregel: Wenn du unsicher bist, wähle Python für Daten/Automatisierung oder JavaScript für Web.

Kernkonzepte, die du beherrschen musst

• Daten und Typen: Zahlen, Strings, Booleans, Arrays/Listen, Objekte/Dicts, Sets.
• Kontrollfluss: Bedingungen, Schleifen, Iterationsmuster, List-Comprehensions oder map/filter.
• Funktionen: Parameter, Rückgabewerte, pure vs. impure, Seiteneffekte, kleine funktionale Entwürfe.
• Datenstrukturen: Arrays/Listen, Hash-Maps (Dict/Object), Sets; kenne ihre Kosten.
• Komplexität: Frage dich „wie wächst die Laufzeit ungefähr?“. Nutze O(1), O(n), O(n log n) als grobe Richtwerte.
• Modularität: Dateien, Imports und Trennung von Verantwortlichkeiten.
• Zustand und Mutabilität: Pass-by-Value vs. Pass-by-Reference; unveränderliche vs. veränderliche Daten.
• I/O: Lesen/Schreiben von Dateien, JSON parsen, Fehlerbehandlung.
• Testing: Unit-Tests für Kernlogik; arrange–act–assert; teste Happy-Paths und Randfälle.

Lerne diese Konzepte „bis zur Beherrschung“. Du solltest in der Lage sein, eine Funktion aus dem Gedächtnis neu zu implementieren und zu erklären, wie Speicher/Zustand bei jeder Zeile aussieht.

Üben: Von Übungen zu Projekten

• Beginne mit strukturierten Drills
  • Rekreiere Built-ins: max, min, unique, flatten.
  • Löse „Kata“ unter Zeitdruck (25-Minuten-Pomodoro).
• Gehe zu gezielten Aufgaben über
  • 10–15 praktische Aufgaben: CSV parsen, Daten filtern, Durchschnitte berechnen, JSON transformieren.
• Lese Code, schreibe ihn nicht nur
  • Überfliege ein Library-README; lies ein kleines Open-Source-Modul; kommentiere, was jede Funktion macht.
• Implementiere nach einer Spezifikation
  • Vorgegeben: „Akzeptiere eine Liste von Transaktionen, gib monatliche Summen zurück“ — schreibe zuerst Tests, dann Code, um sie zu erfüllen.
• Baue Lernschleifen ein
  • Nach jeder Sitzung schreibe 3 Bullet-Points: Was ich gelernt habe, was mich verwirrte, was ich als Nächstes versuchen will.

Tooling-Stack einrichten

Starke Werkzeuge multiplizieren dein Lernen. Verbringe eine fokussierte Sitzung damit, ein schlankes, zuverlässiges Setup zu konfigurieren.

• Editor: VS Code mit Erweiterungen
  • Kern: Python- oder JavaScript-Erweiterung, ESLint/ruff, Prettier/Black, GitLens, eine Test-Runner-Erweiterung.
  • Aktiviere „Format on Save“ und „Trim trailing whitespace“.
• Terminal und Shell
  • macOS/Linux: nutze bash/zsh mit einer einfachen Prompt; Windows: Windows Terminal + WSL oder PowerShell.
• Git und GitHub
  • git config --global user.name "Your Name"
  • git config --global user.email "you@example.com"
  • Erstelle für jedes Projekt ein neues Repo; committe früh und oft.
• Sprach-Runtimes
  • Python: Von python.org installieren oder pyenv verwenden; erstelle eine virtuelle Umgebung (python -m venv .venv; source .venv/bin/activate).
  • Node.js: LTS über Node Version Manager (nvm) installieren; npm oder pnpm für Abhängigkeiten verwenden.
• Testing, Linting, Formatting
  • Python: pytest + coverage, black (Formatter), ruff (Linter).
  • JS: Vitest oder Jest, ESLint, Prettier.
• Debugging
  • Lerne Breakpoints und Step-Through in VS Code, nutze print/log für schnelle Checks und inspiziere Variablen im Debugger.

Kuratierte Ressourcen, die wirklich helfen

• Interaktive Kurse
  • freeCodeCamp: JavaScript, Algorithmen, responsive Webdesign.
  • Codecademy oder Scrimba: geführte JS-Front-End-Pfade.
  • Real Python: praxisnahe Python-Tutorials.
• Bücher
  • „Automate the Boring Stuff with Python“ (praktisch, Python).
  • „Eloquent JavaScript“ (konzeptionelle Tiefe, JS).
• Dokumentation und Referenzen
  • Offizielle Docs (python.org, MDN Web Docs für JS/HTML/CSS).
• Übungsplattformen
  • Exercism: Mentor-Feedback und testgetriebene Übungen.
  • LeetCode: Wähle „easy“ praktische Probleme; nutze es sparsam und gezielt.
• Communities
  • Reddit r/learnprogramming, Stack Overflow (stelle gute, minimale Fragen), lokale Meetups, Discord-Server für deine Sprache.

Nutze die 80/20-Regel: Für jede Stunde Lesen/Schauen, verbring mindestens zwei Stunden mit Bauen oder Lösen.

Dein erstes Projekt: Baue einen Habit-Tracker

Du baust einen einfachen Habit-Tracker, mit dem du Gewohnheiten erstellen, sie täglich markieren und Streaks visualisieren kannst. Du kannst ihn als Kommandozeilen-App (Python) oder kleine Web-App (HTML/CSS/JS) umsetzen. Starte mit einem MVP und erweitere ihn danach.

Was du lernen wirst

• Datenmodellierung, Dateispeicherung oder localStorage, grundlegende Eingabevalidierung.
• Modulares Design, einfache Analytik (Streaks), Testing.
• Packaging oder Deployment (CLI-Installation oder statisches Hosting).

MVP-Funktionen

• Erstelle eine Gewohnheit mit Name und Frequenz (täglich oder bestimmte Wochentage).
• Liste Gewohnheiten und den Status für heute.
• Markiere eine Gewohnheit als heute erledigt.
• Zeige Streaks (aufeinanderfolgende erfüllte Tage).
• Persistiere Daten zwischen Ausführungen (JSON-Datei oder browser localStorage).

Stretch-Funktionen (später)

• Vergebungsregeln für verpasste Tage, wöchentliche Zusammenfassungen, Diagramme, Erinnerungen, CSV-Export, Tagging.

Datenmodell

Einfach und flexibel. Verwende ISO-Daten (YYYY-MM-DD) für Konsistenz.

• Habit
  • id: string oder integer
  • name: string
  • frequency: "daily" oder ein Array von Wochentagsindizes [0–6]
  • created_at: ISO-Datum-String
  • history: Liste von ISO-Daten, an denen abgehakt wurde
• Storage
  • JSON-Struktur mit einer Liste von Habits und Metadaten.

Example JSON: { "habits": [ { "id": 1, "name": "Exercise", "frequency": "daily", "created_at": "2025-01-01", "history": ["2025-01-01", "2025-01-02"] } ], "last_opened": "2025-01-03" }

Architektur planen

• Module
  • storage: Lade-/Speicher-Wrapper für JSON oder localStorage.
  • models: Habit-Klasse oder Hilfsfunktionen für plain objects.
  • services: Business-Logik (Habit hinzufügen, Abschluss markieren, Streak berechnen).
  • ui: CLI-Kommandos oder Web-UI.
• Schlüssel-Funktionen
  • add_habit(name, frequency)
  • list_habits()
  • mark_done(habit_id, date=today)
  • streak(habit, today=today)

Repository einrichten

• Repo erstellen
  • git init habit-tracker
  • Füge ein README.md mit Projektzweck und Nutzung hinzu.
• Für Python-CLI
  • Erstelle src/ mit Modulen, tests/ für pytest und eine main.py.
  • python -m venv .venv; source .venv/bin/activate; pip install pytest black ruff
• Für Web-JS
  • npm init -y; npm install --save-dev vite eslint prettier vitest
  • Erstelle index.html, src/main.js, src/storage.js, src/services.js, src/ui.js und tests.

Inkrementell implementieren

Arbeite in dünnen vertikalen Slices: Mach ein Kommando komplett von Anfang bis Ende lauffähig, bevor du das nächste ergänzt.

• Slice 1: Daten laden und speichern
• Slice 2: Habit hinzufügen
• Slice 3: Habits auflisten
• Slice 4: Als erledigt markieren
• Slice 5: Streaks berechnen

Pseudocode zur Streak-Berechnung: function streak(history, today):

history is a set of ISO dates when the habit was completed

count = 0 current = today while current in history: count += 1 current = current - 1 day return count

Python-Beispiel: Kernlogik

from future import annotations from datetime import date, timedelta import json from pathlib import Path

DATA_FILE = Path.home() / ".habit_tracker.json"

def load_data(): if not DATA_FILE.exists(): return {"habits": [], "last_opened": date.today().isoformat()} return json.loads(DATA_FILE.read_text())

def save_data(data): DATA_FILE.write_text(json.dumps(data, indent=2))

def add_habit(name, frequency="daily"): data = load_data() new_id = (max([h["id"] for h in data["habits"]] or [0]) + 1) habit = { "id": new_id, "name": name, "frequency": frequency, "created_at": date.today().isoformat(), "history": [] } data["habits"].append(habit) save_data(data) return habit

def mark_done(habit_id, day=None): d = day or date.today().isoformat() data = load_data() for h in data["habits"]: if h["id"] == habit_id: if d not in h["history"]: h["history"].append(d) h["history"].sort() save_data(data) return True return False

def streak(habit, today=None): today = today or date.today() history = set(habit["history"]) count = 0 current = today while current.isoformat() in history: count += 1 current = current - timedelta(days=1) return count

if name == "main":

Minimal demo

add_habit("Read for 20 minutes") mark_done(1) data = load_data() print(streak(data["habits"][0]))

JavaScript-Beispiel: Kernlogik (Web mit localStorage)

const KEY = "habit-tracker-data";

function loadData() { const raw = localStorage.getItem(KEY); return raw ? JSON.parse(raw) : { habits: [], last_opened: new Date().toISOString().slice(0, 10) }; }

function saveData(data) { localStorage.setItem(KEY, JSON.stringify(data)); }

export function addHabit(name, frequency = "daily") { const data = loadData(); const newId = (Math.max(0, ...data.habits.map(h => h.id)) + 1); const habit = { id: newId, name, frequency, created_at: new Date().toISOString().slice(0, 10), history: [] }; data.habits.push(habit); saveData(data); return habit; }

export function markDone(habitId, day) { const d = day || new Date().toISOString().slice(0, 10); const data = loadData(); const h = data.habits.find(h => h.id === habitId); if (!h) return false; if (!h.history.includes(d)) { h.history.push(d); h.history.sort(); saveData(data); } return true; }

export function streak(habit, todayStr) { const today = todayStr || new Date().toISOString().slice(0, 10); let count = 0; let current = new Date(today); const history = new Set(habit.history); while (history.has(current.toISOString().slice(0, 10))) { count++; current.setDate(current.getDate() - 1); } return count; }

Tests der Kernfunktionen

• Python (pytest) def test_streak_basic(tmp_path, monkeypatch): from datetime import date, timedelta

  Build habit in-memory

  today = date(2025, 1, 10) habit = {"history": [(today).isoformat(), (today - timedelta(days=1)).isoformat()]} assert streak(habit, today) == 2

• JavaScript (Vitest) import { describe, it, expect } from "vitest"; import { streak } from "./services";

describe("streak", () => { it("counts consecutive days", () => { const habit = { history: ["2025-01-09", "2025-01-10"] }; expect(streak(habit, "2025-01-10")).toBe(2); }); });

Schreibe Tests, bevor du codest, wenn möglich — selbst ein paar Randfälle ändern, wie du Funktionen entwirfst und verhindern Regressionen.

Kommandozeilen-Interface (CLI) oder Web-UI

Wähle die UI, die zu deinen Interessen passt.

• CLI (Python)
  • Nutze argparse für Befehle: add, list, done, streaks.
  • Beispiel: import argparse

parser = argparse.ArgumentParser(prog="habits") sub = parser.add_subparsers(dest="cmd") p_add = sub.add_parser("add"); p_add.add_argument("name") p_list = sub.add_parser("list") p_done = sub.add_parser("done"); p_done.add_argument("id", type=int)

args = parser.parse_args() if args.cmd == "add": add_habit(args.name) elif args.cmd == "list": for h in load_data()["habits"]: print(h["id"], h["name"]) elif args.cmd == "done": mark_done(args.id)

• Web-UI (JS)
  • Minimales HTML: ein Formular zum Hinzufügen einer Gewohnheit, eine Liste zur Anzeige der Habits und ein „done today“-Button.
  • Verwende Event-Listener, die addHabit/markDone aufrufen und die Liste neu rendern.
  • Halte DOM-Updates simpel: Baue die Liste bei jeder Änderung neu auf.

Persistenz und Datenintegrität

• JSON-Datei (CLI)
  • Validieren, bevor du speicherst. Beim Laden: Ist die Datei korrupt, sichere sie und initialisiere neu.
  • Denke später über Dateisperren nach, falls du mehrere Instanzen ausführst.
• localStorage (Web)
  • Namespacing für Keys, Backup als herunterladbare JSON-Datei und Schutz gegen JSON-Parse-Fehler.

Paketierung und Bereitstellung

• Python-CLI
  • Wandle es in ein Paket: pyproject.toml hinzufügen, Entry-Point (console_scripts) definieren.
  • Lokal mit pipx installieren für globale Nutzung.
  • Auf GitHub veröffentlichen mit einem Release; optional später auf PyPI.
• Web-App
  • Nutze Vite, um statische Assets zu bauen.
  • Deploye in Minuten auf GitHub Pages oder Netlify.
  • Schreibe eine einfache Datenschutzerklärung (Daten bleiben im Browser).

Dokumentation und README

Dein README ist Teil deines Portfolios. Enthält:

• Was es tut und warum es existiert.
• Features und Screenshots/GIFs.
• Quickstart (Installation/Start) und Beispiele.
• Design-Notes (Datenmodell, Entscheidungen, Trade-offs).
• Roadmap mit Stretch-Goals.
• Lizenz und Hinweise zur Mitarbeit.

Visuelles Feedback und Analysen

• Zeige Streak-Zähler klar neben jeder Gewohnheit.
• Füge eine Wochenübersicht hinzu: Anzahl erfüllter Tage diese Woche.
• Optional: Berechne die Einhaltungsquote über die letzten 30 Tage.

Best Practices, die du heute anwenden kannst

• Schreibe kleine Funktionen (unter ~20 Zeilen) mit klaren Namen und nur einer Verantwortung.
• Behandle Fehler explizit. Schütze vor fehlenden Dateien, ungültiger Eingabe oder falschen Datumsangaben.
• Logge an Schnittstellen. Drucke/logge Ein- und Ausgaben großer Abläufe beim Debuggen.
• Halte enge Loops: edit → run → inspect → test → commit. Lass Branches nicht auseinanderlaufen.
• Bevorzuge reine Logikfunktionen mit dünnen I/O-Wrappern. Teste die reine Logik intensiv.
• Refaktoriere kontinuierlich, nicht nur am Ende. Benenne früh für Klarheit um, extrahiere Funktionen.
• Dokumentiere Annahmen in Code-Kommentaren (kurz und aussagekräftig, keine offensichtlichen Wiederholungen).

Häufige Fallstricke und wie du sie vermeidest

• Tutorials anhäufen ohne zu bauen
  • Fix: Verpflicht dich zu einem Projekt und liefere ein MVP aus. Verknüpfe neues Lernen mit Projektbedarf.
• Copy-Paste ohne Verständnis
  • Fix: Schreibe Code aus dem Gedächtnis neu. Erkläre jede Zeile in deinen eigenen Worten, bevor du sie committest.
• Frühzeitiges Overengineering
  • Fix: Erst das MVP, Struktur nach Bedarf hinzufügen. Vermeide Klassenhierarchien am ersten Tag.
• Tests ignorieren, weil „es ist klein“
  • Fix: Schreibe mindestens einen Test pro Kernfunktion. Das zukünftige Ich wird darauf angewiesen sein.
• Riesen-Lern-Sessions
  • Fix: Pomodoro-Zyklen und hör auf, solange du noch klar denkst. Lass eine Notiz für die erste Aufgabe der nächsten Sitzung.
• Keine Versionskontrolle verwenden
  • Fix: Committe bei sinnvollen Meilensteinen; nutze Branches für Features; schreibe aussagekräftige Messages.

Fortschritt messen und ein Portfolio aufbauen

• Quantitative Signale
  • Anzahl kleiner Utilities, die du ausgeliefert hast, Testabdeckung für Kernmodule, offene/geschlossene Issues in deinem Repo, aufeinanderfolgende Tage mit Code.
• Qualitative Signale
  • Du kannst erklären, wie du einen Bug gelöst hast und was sich in deinem Mentalmodell geändert hat.
  • Du kannst fremden Code lesen und modifizieren, ohne Dinge kaputt zu machen.
• Portfolio-Struktur
  • 3–5 Repositories: jeweils README, Screenshots, Tests und eine kurze Projektbeschreibung.
  • Pinne deine besten Projekte auf deinem GitHub-Profil.
• Breite und Tiefe demonstrieren
  • Breite: Skripte, eine kleine Web-App, einfache Datenanalyse.
  • Tiefe: Ein Projekt mit Tests, Packaging und Dokumentation.

Nächste Schritte und Spezialisierungspfade

Nach deinem ersten Projekt wähle einen Pfad, der zu deinen Interessen passt. Baue ein zweites, etwas ambitionierteres Projekt in diesem Pfad.

• Web-Entwicklung (Frontend)
  • Lerne TypeScript, ein Framework (React/Vue/Svelte) und State-Management-Grundlagen.
  • Projektidee: „Progressive Habit Tracker“ mit Offline-Unterstützung (Service Worker) und Kalenderansicht.
• Backend und APIs
  • Python: FastAPI; JS: Express oder Hono.
  • Füge eine REST-API für deinen Habit-Tracker hinzu; persistiere in SQLite oder Postgres.
• Daten und Analyse
  • Python: pandas, seaborn/Matplotlib; Jupyter-Notebooks.
  • Analysiere Habit-Einhaltung und visualisiere Trends; exportiere als kleinen Report.
• Automatisierung und DevOps
  • Schreibe Skripte, die nach Zeitplan laufen (cron/GitHub Actions), sichere Daten und versende Erinnerungen.
• Systeme und Performance (fortgeschritten)
  • Schreibe ein Kernmodul in Go/Rust neu; messe Geschwindigkeit und Speicherverbrauch.

Jeder Pfad sollte in einem weiteren Projekt münden, das du in unter 3 Minuten demonstrieren kannst.

Häufig gestellte Fragen

• Wie viele Stunden pro Woche sind realistisch?
  • Ziel: 7–10 fokussierte Stunden. Täglich ist am besten; kurze, konsistente Sessions bringen kompoundierte Verbesserungen.
• Brauche ich viel Mathe?
  • Du brauchst Komfort mit Arithmetik, Logik und Problemdekomposition. Fortgeschrittene Mathematik ist nur für Spezialgebiete nötig.
• Welcher Laptop oder welches OS ist empfehlenswert?
  • Jede moderne Maschine funktioniert. macOS und Linux bieten etwas reibungslosere Dev-Tools; Windows mit WSL ist ebenfalls solide.
• Sollte ich mehrere Sprachen gleichzeitig lernen?
  • Nein. Beherrsche die Kernkonzepte einer Sprache und liefere 2–3 Projekte, bevor du neue Sprachen ausprobierst.
• Wie vermeide ich Burnout?
  • Halte ein Backlog mit kleinen, befriedigenden Aufgaben. Feier ausgelieferte Features. Mach Pausen.

Abschließende Checkliste und ein 30-Tage-Aktionsplan

Checkliste bevor du startest

• VS Code, Git, Sprachruntime installiert.
• „Hello, world“ läuft lokal.
• Linting und Formatierung beim Speichern aktiviert.
• Ein Test besteht mit deinem gewählten Test-Runner.
• GitHub-Account eingerichtet; Repo erstellt.

30-Tage-Plan (1–1,5 Stunden/Tag)

• Tage 1–3: Umgebung einrichten; 10 Syntax-Übungen fertigstellen; jedes committen.
• Tage 4–6: Funktionen und Collections; winzige Utilities schreiben (CSV-Parser, JSON-Pretty-Printer).
• Tage 7–9: Grundlegende Algorithmen; unique, Häufigkeiten zählen, einfacher Sort; Tests schreiben.
• Tage 10–12: Tooling-Deep-Dive; Debugger nutzen, Breakpoints setzen, sinnvoll loggen; CI hinzufügen, wenn möglich (GitHub Actions).
• Tage 13–16: Habit-Tracker entwerfen; Datenmodell und Architektur; Repo scaffolden; erste Tests bestehen.
• Tage 17–20: Implementiere add/list/mark-done; stell sicher, dass Load/Save robust ist; CLI oder UI verfeinern.
• Tage 21–23: Streak-Logik; Randfälle (