O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

Weniger schlecht programmieren

Book Description

"Ein Experte ist jemand, der auf einem Spezialgebiet alle denkbaren Fehler bereits gemacht hat." Niels Bohr, Nobelpreisträger für Physik. Kathrin Passig gilt als Meisterin des unorthodoxen Blickwinkels, und wenn sie sich zusammentut mit einem gestandenen Entwickler, um ein Programmierbuch zu schreiben, darf man gespannt sein! Mit Sachverstand und Witz widmen sich die beiden den Holzwegen, Fehleinschätzungen und Irrtümern, die gerade Programmier-Neulingen und Hobby-Entwicklern häufig das Leben schwer machen. Ein Lesevergnügen für alle, die ahnen, dass in ihnen ein besserer Programmierer steckt.

Table of Contents

  1. Vorwort
    1. Warum dauert es so lange, bis der Mensch klüger wird?
    2. Spezialprobleme schlechter Programmierer
    3. Die sieben gebräuchlichsten Argumente schlechter Programmierer
    4. Wenige Jahre später
    5. Die nächsten 422 Seiten
  2. I. Hallo Wels Hallo Welt
    1. 1. Bin ich hier richtig?
    2. 2. Zwischen Hybris und Demut
      1. Schwächen als Stärken
      2. Richtiges muss nicht schwierig sein
  3. II. Programmieren als Verständigung
    1. 3. Du bist wie die andern
    2. 4. Konventionen
      1. Englisch oder nicht?
      2. Die Steinchen des Anstoßes
      3. Konventionen im Team
    3. 5. Namensgebung
      1. Namenskonventionen
      2. Von Byzanz über Konstantinopel nach Istanbul
      3. Was Namen können sollten
        1. Lesbarkeit, Verständlichkeit und Unverwechselbarkeit
        2. Verständlichkeit und Logik
        3. Keine Witze! Keine Coolness!
      4. Der Stoff, aus dem die Namen sind
        1. Vorgänge, Funktionen, Methoden
          1. Suchen und Beschaffen
          2. Anzeigen
          3. Verbinden
          4. Zerlegen
          5. Umwandeln
          6. Anfangen und Aufhören
          7. Auf- und Umräumen
          8. Flüchtiges dauerhaft machen
          9. Nein! Doch nicht!
          10. Vorsicht im Umgang mit
      5. Boolesche Variablen
      6. Objektorientierte Programmierung
      7. Datenbanken
      8. Falsche Freunde
      9. Wie es weitergeht
    4. 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. 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. 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. 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. 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
  4. III. Umgang mit Fehlern
    1. 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. 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. 13. Debugging II: Finde den Fehler
      1. Fehlermeldungen sind unsere Freunde
      2. Wer will da was von mir?
      3. Diagnosewerkzeuge und -strategien
        1. Die üblichen Verdächtigen
        2. Validatoren, Linting, Code-Analyse
        3. Printline-Debugging
        4. Logging
        5. Debugger
          1. Debuggen in einem IDE-Debugger
          2. Debuggen in einem Kommandozeilen-Debugger
          3. Steppen in einem IDE-Debugger
          4. Steppen in einem Kommandozeilen-Debugger
        6. Debugging in deklarativen Sprachen
          1. SQL
          2. Regular Expressions
          3. CSS
      4. Wenn sonst nichts hilft
      5. Wenn auch das nicht hilft
        1. Nach der Fehlersuche ist vor der Fehlersuche
      6. Die häufigsten Fehlerursachen schlechter Programmierer
    4. 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. 15. Refactoring
      1. Neu schreiben oder nicht?
      2. Wann sollte man refakturieren?
        1. Anzeichen dafür, dass Überarbeitungen jetzt kein Fehler wären
      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. 16. Testing
      1. Warum testen?
      2. Testverfahren
        1. Systemtests (Klicktests)
        2. Unit-Tests
          1. Assertions
          2. Test-Suites
          3. Fixtures
      3. Datenvalidierungen
      4. Performancetests
      5. Richtig testen
    7. 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. 18. Kompromisse
      1. Trügerische Tugenden
        1. Zukunftssicherheit
        2. Geschwindigkeit
        3. Perfektion, Schönheit, Eleganz
      2. Absolution: Wann Bad Practice okay ist
  5. IV. Wahl der Mittel
    1. 19. Mach es nicht selbst
      1. Der Weg zur Lösung
      2. Bibliotheken
      3. Umgang mit Fremdcode
        1. Beliebte Fehler im Umgang mit Fremdcode
      4. Was man nicht selbst zu machen braucht
        1. Was man auf keinen Fall selbst machen sollte
        2. Drei Lösungen für ein Problem
    2. 20. Werkzeugkasten
      1. Editoren
      2. Welche Programmiersprache ist die richtige?
      3. REPL
      4. Diff und Patch
      5. Paketmanager
      6. Frameworks
        1. Wahl des Frameworks
        2. Warnzeichen beim Umgang mit Frameworks
      7. Entwicklungsumgebungen
        1. Projektverwaltung
        2. Codechecker
        3. Codevervollständigung
        4. Unterstützung der Arbeitsorganisation
        5. Suchen und Refactoring
        6. Nachteile
    3. 21. Versionskontrolle
      1. Alternativen
      2. Arbeiten mit einem VCS
      3. Konflikte auflösen
      4. Welches Versionskontrollsystem?
        1. Subversion
        2. git
      5. Gute Ideen beim Arbeiten mit Versionskontrolle
      6. Schlechte Ideen beim Arbeiten mit Versionskontrolle
      7. Versionskontrollsysteme als Softwarebausteine
    4. 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
        1. Optionen
        2. Argumente
        3. Wohin mit dem Ergebnis?
        4. Ergebnisse verketten
        5. Wildcards
      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. 23. Objektorientierte Programmierung
      1. Vorteile der objektorientierten Programmierung
      2. Die Prinzipien objektorientierter Programmierung
        1. Modularität und Abschottung
        2. Abstraktion
        3. Polymorphismus
        4. Vererbung
      3. Sinnvoller Einsatz von OOP
      4. Nachteile und Probleme
      5. Unterschiedliche Objektmodelle, je nach Sprache
      6. Objektorientierte Programmierung und Weltherrschaftspläne
    6. 24. Aufbewahrung von Daten
      1. Dateien
        1. CSV/TSV
        2. XML
        3. JSON
        4. YAML
      2. Versionskontrollsysteme
      3. Datenbanken
        1. Suchen und Finden
        2. Relationale Datenbanken
        3. NoSQL-Datenbanken
        4. Document Store-Datenbanken wie CouchDB oder MongoDB
        5. Graphdatenbanken wie neo4j
    7. 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. 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. 27. Wie geht es weiter?
      1. Was ist ein guter Programmierer?
      2. Zum Weiterlesen
      3. Danksagungen
  6. Stichwortverzeichnis
  7. Copyright