Books & Videos

Table of Contents

  1. Hallo Wels Hallo Welt

    1. Chapter 1 Bin ich hier richtig?

    2. Chapter 2 Zwischen Hybris und Demut

      1. Schwächen als Stärken
      2. Richtiges muss nicht schwierig sein
  2. Programmieren als Verständigung

    1. Chapter 3 Du bist wie die andern

    2. Chapter 4 Konventionen

      1. Englisch oder nicht?
      2. Die Steinchen des Anstoßes
      3. Konventionen im Team
    3. Chapter 5 Namensgebung

      1. Namenskonventionen
      2. Von Byzanz über Konstantinopel nach Istanbul
      3. Was Namen können sollten
      4. Der Stoff, aus dem die Namen sind
      5. Boolesche Variablen
      6. Objektorientierte Programmierung
      7. Datenbanken
      8. Falsche Freunde
      9. Wie es weitergeht
    4. Chapter 6 Kommentare

      1. Mehr ist manchmal mehr
      2. Zur äußeren Form von Kommentaren
      3. Dokumentationskommentare
      4. Wann und was soll man kommentieren?
      5. Anzeichen, dass ein Kommentar eine gute Idee wäre
      6. Problematische Kommentare
    5. Chapter 7 Code lesen

      1. Muss ich wirklich?
      2. Zuerst die Dokumentation lesen
      3. Sourcecode ausdrucken
      4. Zeichnen Sie schematisch auf, was einzelne Programmteile tun
      5. Von oben nach unten, von leicht nach schwer
      6. Lernen Sie Spurenlesen
      7. 80/20 ist gut genug (meistens)
      8. Vergessen Sie die Daten nicht
      9. Der Beweis ist das Programm
      10. Gemeinsames Code-Lesen
    6. Chapter 8 Hilfe suchen

      1. Der richtige Zeitpunkt
      2. An der richtigen Stelle fragen
      3. Die Anfrage richtig strukturieren
      4. An den Leser denken
      5. Nicht zu viel erwarten
      6. Keine unbewussten Fallen stellen
      7. Höflich bleiben – egal, was passiert
    7. Chapter 9 Lizenz zum Helfen

      1. Der falsche Anlass
      2. Die eigennützige Motivation
      3. Die fehlende Einfühlung
      4. Zu viel auf einmal
      5. Antworten auf konkrete Fragen
      6. Wenn Sie selbst keine Antwort wissen
      7. Wenn Sie mit schlechteren Programmierern zusammenarbeiten
      8. Schlechten Code gefasst ertragen
    8. Chapter 10 Überleben im Team

      1. Ich war’s nicht!
      2. Der Bus-Faktor
      3. Zusammenarbeit mit Anwendern
      4. Zusammenarbeit mit Freiwilligen
      5. Aussprache von Begriffen
  3. Umgang mit Fehlern

    1. Chapter 11 Unrecht haben für Anfänger

      1. Im Irrtum zu Hause
      2. Fehlerforschung im Alltag
      3. Der Hund hat die Datenbank gefressen!
      4. Der gepolsterte Helm
    2. Chapter 12 Debugging I: Fehlersuche als Wissenschaft

      1. Systematische Fehlersuche
      2. Beobachtung
      3. Was das Beobachten erschwert
      4. Analyse und Hypothesenbildung
      5. Was das Bilden von Hypothesen erschwert
      6. Test der Hypothesen
      7. Was das Testen von Hypothesen erschwert
    3. Chapter 13 Debugging II: Finde den Fehler

      1. Fehlermeldungen sind unsere Freunde
      2. Wer will da was von mir?
      3. Diagnosewerkzeuge und -strategien
      4. Wenn sonst nichts hilft
      5. Wenn auch das nicht hilft
      6. Die häufigsten Fehlerursachen schlechter Programmierer
    4. Chapter 14 Schlechte Zeichen oder Braune M&Ms

      1. Zu große Dateien
      2. Sehr lange Funktionen
      3. Zu breite Funktionen
      4. Tief verschachtelte if/then-Bedingungen
      5. Mitten im Code auftauchende Zahlen
      6. Komplexe arithmetische Ausdrücke im Code
      7. Globale Variablen
      8. Reparaturcode
      9. Eigene Implementierung vorhandener Funktionen
      10. Sonderfälle
      11. Inkonsistente Schreibweisen
      12. Funktionen mit mehr als fünf Parametern
      13. Code-Duplikation
      14. Zweifelhafte Dateinamen
      15. Leselabyrinth
      16. Ratlose Kommentare
      17. Sehr viele Basisklassen oder Interfaces
      18. Sehr viele Methoden oder Member-Variablen
      19. Auskommentierte Codeblöcke und Funktionen
      20. Browservorschriften
      21. Verdächtige Tastaturgeräusche
    5. Chapter 15 Refactoring

      1. Neu schreiben oder nicht?
      2. Wann sollte man refakturieren?
      3. Eins nach dem anderen
      4. Code auf mehrere Dateien verteilen
      5. Ein Codemodul in kleinere aufspalten
      6. Nebenwirkungen entfernen
      7. Code zusammenfassen
      8. Bedingungen verständlicher gestalten
      9. Die richtige Schleife für den richtigen Zweck
      10. Schleifen verständlicher gestalten
      11. Variablen kritisch betrachten
      12. Refactoring von Datenbanken
      13. Was man nebenbei erledigen kann
      14. Ist das jetzt wirklich besser?
      15. Wann man auf Refactoring besser verzichtet
      16. Ein Problem und seine Lösung
    6. Chapter 16 Testing

      1. Warum testen?
      2. Testverfahren
      3. Datenvalidierungen
      4. Performancetests
      5. Richtig testen
    7. Chapter 17 Warnhinweise

      1. GET und POST
      2. Zeichenkodierung
      3. Zeitangaben
      4. Kommazahlen als String, Integer oder Decimal speichern
      5. Variablen als Werte oder Referenzen übergeben
      6. Der schwierige Umgang mit dem Nichts
      7. Rekursion
      8. Usability
    8. Chapter 18 Kompromisse

      1. Trügerische Tugenden
      2. Absolution: Wann Bad Practice okay ist
  4. Wahl der Mittel

    1. Chapter 19 Mach es nicht selbst

      1. Der Weg zur Lösung
      2. Bibliotheken
      3. Umgang mit Fremdcode
      4. Was man nicht selbst zu machen braucht
    2. Chapter 20 Werkzeugkasten

      1. Editoren
      2. Welche Programmiersprache ist die richtige?
      3. REPL
      4. Diff und Patch
      5. Paketmanager
      6. Frameworks
      7. Entwicklungsumgebungen
    3. Chapter 21 Versionskontrolle

      1. Alternativen
      2. Arbeiten mit einem VCS
      3. Konflikte auflösen
      4. Welches Versionskontrollsystem?
      5. Gute Ideen beim Arbeiten mit Versionskontrolle
      6. Schlechte Ideen beim Arbeiten mit Versionskontrolle
      7. Versionskontrollsysteme als Softwarebausteine
    4. Chapter 22 Command and Conquer – vom Überleben auf der Kommandozeile

      1. Mehr Effizienz durch Automatisierung
      2. Unsere langbärtigen Vorfahren
      3. Windows
      4. Was jeder Programmierer wissen sollte
      5. Navigation
      6. Dateien
      7. Betrachten
      8. Suchen und Finden
      9. Ressourcen schonen
      10. Zusammenarbeit
      11. Zeitsteuerung
      12. Editieren auf dem Server
      13. Internet
      14. Muss ich mir das alles merken?
      15. Not the whole Shebang!
    5. Chapter 23 Objektorientierte Programmierung

      1. Vorteile der objektorientierten Programmierung
      2. Die Prinzipien objektorientierter Programmierung
      3. Sinnvoller Einsatz von OOP
      4. Nachteile und Probleme
      5. Unterschiedliche Objektmodelle, je nach Sprache
      6. Objektorientierte Programmierung und Weltherrschaftspläne
    6. Chapter 24 Aufbewahrung von Daten

      1. Dateien
      2. Versionskontrollsysteme
      3. Datenbanken
    7. Chapter 25 Sicherheit

      1. Wichtige Konzepte
      2. Vor- und Nachteile der Offenheit
      3. Vom Umgang mit Passwörtern
      4. Authentifizierungsverfahren
      5. SQL Injection und XSS – die Gefahren in User-Content
      6. Weiße Listen sind besser als schwarze
      7. Alle Regler nach links
      8. Auch die Hintertür abschließen
      9. Penetration Testing
      10. Die Fehler der anderen
      11. Sicherheit ist ein Prozess
    8. Chapter 26 Nützliche Konzepte

      1. Exceptions
      2. Error Handling
      3. State und Statelessness
      4. IDs, GUIDs, UUIDs
      5. Sprachfamilien
      6. Variablentypen
      7. Trennung von Inhalt und Präsentation
      8. Trennung von Entwicklungs- und Produktivserver
      9. Selektoren
      10. Namespaces
      11. Scope von Variablen
      12. Assertions
      13. Transaktionen und Rollbacks
      14. Hashes, Digests, Fingerprints
      15. CRUD und REST
    9. Chapter 27 Wie geht es weiter?

      1. Was ist ein guter Programmierer?
      2. Zum Weiterlesen
      3. Danksagungen