Passig / Jander Weniger schlecht programmieren

1. Auflage 2013
ISBN: 978-3-89721-568-9
Verlag: O'Reilly
Format: PDF
Kopierschutz: 0 - No protection

E-Book, Deutsch, 456 Seiten

Kathrin Passig gilt als Meisterin des unorthodoxen Blickwinkels, und wenn sie sich zusammen tut 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 insbesondere Programmier-Neulingen und Hobby-Entwicklern das Leben schwer machen. Ein Buch für alle, die ahnen, dass ein besserer Programmierer in ihnen steckt. Hätte ich das früher gewusst! Auch wenn es nicht unbedingt auf der Hand liegt: Programmieren hat viel mit Kommunikation zu tun. Programmierstil, Namensgebung, Umgang mit Kommentaren oder mit Fremdcode - oftmals haben sich gerade dort Konventionen etabliert, wo eine Sprache keine strengen Vorgaben macht. Lernen Sie die unterschiedlichen Traditionen der verschiedenen Sprachen kennen und erfahren Sie, wie Sie sich auf diesem unsicheren Terrain halbwegs unfallfrei bewegen. Vom Umgang mit Fehlern - Wer hat nicht schon Stunden damit verbracht, nach einem Fehler im Programm zu suchen, um herauszufinden, warum etwas nicht so funktioniert, wie eigentlich geplant? Es gibt eine Menge Anzeichen, die darauf schließen lassen, wo genau etwas im Code nicht stimmt. Lernen Sie, wie Sie solche Roststellen erkennen, wie Sie mit systematischem Debugging Fehler finden und durch Tests dauerhaft bändigen. Die Qual der Wahl - Nicht jede Programmiersprache eignet sich gleich gut für jede Aufgabe, Daten lassen sich auf unterschiedliche Weise vorhalten, Entwicklungsumgebungen und Versionskontrollsysteme gibt es viele - auf technischer Ebene gilt es jede Menge Entscheidungen zu treffen, deren Konsequenzen schwer zu überreißen sind. Universell gültige Empfehlungen kann niemand abgeben, aber mit den Erfahrungswerten und Entscheidungshilfen der Autoren fahren Sie für den Anfang nicht schlecht.

Kathrin Passig ist bekannt geworden als Sachbuchautorin (unter anderem 'Internet - Fluch oder Segen', zusammen mit Sascha Lobo oder 'Lexikon des Unwissens', zusammen mit Aleks Scholz). Sie blickt aber auch auf fünfzehn Jahre Erfahrung mit wirklich schlechter Programmierung zurück. Johannes Jander hat schon als Jugendlicher begeistert programmiert, musste aber erst auf einem Umweg über die Biologie zur Softwareentwicklung zurückfinden. Inzwischen arbeitet er hauptberuflich als Entwickler in einem großen Unternehmen.

Autoren/Hrsg.

Passig, Kathrin

Jander, Johannes

Inhaltsverzeichnis

1;Cover;1
2;Inhalt;5
3;Vorwort;13
3.1;Warum dauert es so lange, bis der Mensch klüger wird?;15
3.2;Spezialprobleme schlechter Programmierer;16
3.3;Die sieben gebräuchlichsten Argumente schlechter Programmierer;17
3.4;Wenige Jahre später;18
3.5;Die nächsten 422 Seiten;19
4;Teil 1: Hallo Wels Hallo Welt;21
4.1;Kapitel 1: Bin ich hier richtig?;23
4.2;Kapitel 2: Zwischen Hybris und Demut;27
4.2.1;Schwächen als Stärken;29
4.2.2;Richtiges muss nicht schwierig sein;32
4.3;Kapitel 27: Wie geht es weiter?;439
4.3.1;Was ist ein guter Programmierer?;440
4.3.2;Zum Weiterlesen;441
4.3.3;Danksagungen;442
5;Teil 2: Programmieren als Verständigung;35
5.1;Kapitel 3: Du bist wie die andern;37
5.2;Kapitel 4: Konventionen;39
5.2.1;Englisch oder nicht?;40
5.2.2;Die Steinchen des Anstoßes;43
5.2.3;Konventionen im Team;46
5.3;Kapitel 5: Namensgebung;49
5.3.1;Namenskonventionen;49
5.3.2;Von Byzanz über Konstantinopel nach Istanbul;51
5.3.3;Was Namen können sollten;53
5.3.4;Der Stoff, aus dem die Namen sind;60
5.3.5;Boolesche Variablen;70
5.3.6;Objektorientierte Programmierung;72
5.3.7;Datenbanken;73
5.3.8;Falsche Freunde;75
5.3.9;Wie es weitergeht;78
5.4;Kapitel 6: Kommentare;81
5.4.1;Mehr ist manchmal mehr;83
5.4.2;Zur äußeren Form von Kommentaren;84
5.4.3;Dokumentationskommentare;86
5.4.4;Wann und was soll man kommentieren?;87
5.4.5;Anzeichen, dass ein Kommentar eine gute Idee wäre;89
5.4.6;Problematische Kommentare;94
5.5;Kapitel 7: Code lesen;97
5.5.1;Muss ich wirklich?;97
5.5.2;Zuerst die Dokumentation lesen;99
5.5.3;Sourcecode ausdrucken;100
5.5.4;Zeichnen Sie schematisch auf, was einzelne Programmteile tun;101
5.5.5;Von oben nach unten, von leicht nach schwer;102
5.5.6;Lernen Sie Spurenlesen;102
5.5.7;80/20 ist gut genug (meistens);103
5.5.8;Vergessen Sie die Daten nicht;104
5.5.9;Der Beweis ist das Programm;104
5.5.10;Gemeinsames Code-Lesen;105
5.6;Kapitel 8: Hilfe suchen;107
5.6.1;Der richtige Zeitpunkt;108
5.6.2;An der richtigen Stelle fragen;111
5.6.3;Die Anfrage richtig strukturieren;111
5.6.4;An den Leser denken;114
5.6.5;Nicht zu viel erwarten;115
5.6.6;Keine unbewussten Fallen stellen;116
5.6.7;Höflich bleiben – egal, was passiert;116
5.7;Kapitel 9: Lizenz zum Helfen;119
5.7.1;Der falsche Anlass;119
5.7.2;Die eigennützige Motivation;121
5.7.3;Die fehlende Einfühlung;122
5.7.4;Zu viel auf einmal;123
5.7.5;Antworten auf konkrete Fragen;125
5.7.6;Wenn Sie selbst keine Antwort wissen;126
5.7.7;Wenn Sie mit schlechteren Programmierern zusammenarbeiten;127
5.7.8;Schlechten Code gefasst ertragen;128
5.8;Kapitel 10: Überleben im Team;131
5.8.1;Ich war's nicht!;133
5.8.2;Der Bus-Faktor;134
5.8.3;Zusammenarbeit mit Anwendern;136
5.8.4;Zusammenarbeit mit Freiwilligen;137
5.8.5;Aussprache von Begriffen;137
6;Teil 3: Programmieren als Verständigung;141
6.1;Kapitel 11: Unrecht haben für Anfänger;143
6.1.1;Im Irrtum zu Hause;144
6.1.2;Fehlerforschung im Alltag;145
6.1.3;Der Hund hat die Datenbank gefressen!;146
6.1.4;Der gepolsterte Helm;147
6.2;Kapitel 12: Debugging I: Fehlersuche als Wissenschaft;151
6.2.1;Systematische Fehlersuche;153
6.2.2;Beobachtung;155
6.2.3;Was das Beobachten erschwert;156
6.2.4;Analyse und Hypothesenbildung;158
6.2.5;Was das Bilden von Hypothesen erschwert;158
6.2.6;Test der Hypothesen;159
6.2.7;Was das Testen von Hypothesen erschwert;160
6.3;Kapitel 13: Debugging II: Finde den Fehler;163
6.3.1;Fehlermeldungen sind unsere Freunde;163
6.3.2;Wer will da was von mir?;164
6.3.3;Diagnosewerkzeuge und -strategien;167
6.3.4;Wenn sonst nichts hilft;180
6.3.5;Wenn auch das nicht hilft;182
6.3.6;Die häufigsten Fehlerursachen schlechter Programmierer;183
6.4;Kapitel 14: Schlechte Zeichen oder Braune M & Ms;185
6.4.1;Zu große Dateien;186
6.4.2;Sehr lange Funktionen;187
6.4.3;Zu breite Funktionen;187
6.4.4;Tief verschachtelte if/then-Bedingungen;188
6.4.5;Mitten im Code auftauchende Zahlen;190
6.4.6;Komplexe arithmetische Ausdrücke im Code;190
6.4.7;Globale Variablen;191
6.4.8;Reparaturcode;192
6.4.9;Eigene Implementierung vorhandener Funktionen;193
6.4.10;Sonderfälle;194
6.4.11;Inkonsistente Schreibweisen;194
6.4.12;Funktionen mit mehr als fünf Parametern;194
6.4.13;Code-Duplikation;195
6.4.14;Zweifelhafte Dateinamen;196
6.4.15;Leselabyrinth;196
6.4.16;Ratlose Kommentare;196
6.4.17;Sehr viele Basisklassen oder Interfaces;197
6.4.18;Sehr viele Methoden oder Member-Variablen;197
6.4.19;Auskommentierte Codeblöcke und Funktionen;198
6.4.20;Browservorschriften;198
6.4.21;Verdächtige Tastaturgeräusche;199
6.5;Kapitel 15: Refactoring;201
6.5.1;Neu schreiben oder nicht?;202
6.5.2;Wann sollte man refakturieren?;203
6.5.3;Eins nach dem anderen;206
6.5.4;Code auf mehrere Dateien verteilen;211
6.5.5;Ein Codemodul in kleinere aufspalten;211
6.5.6;Nebenwirkungen entfernen;214
6.5.7;Code zusammenfassen;215
6.5.8;Bedingungen verständlicher gestalten;218
6.5.9;Die richtige Schleife für den richtigen Zweck;221
6.5.10;Schleifen verständlicher gestalten;221
6.5.11;Variablen kritisch betrachten;223
6.5.12;Refactoring von Datenbanken;224
6.5.13;Was man nebenbei erledigen kann;226
6.5.14;Ist das jetzt wirklich besser?;228
6.5.15;Wann man auf Refactoring besser verzichtet;228
6.5.16;Ein Problem und seine Lösung;231
6.6;Kapitel 16: Testing;233
6.6.1;Warum testen?;233
6.6.2;Testverfahren;234
6.6.3;Datenvalidierungen;240
6.6.4;Performancetests;242
6.6.5;Richtig testen;245
6.7;Kapitel 17: Warnhinweise;247
6.7.1;GET und POST;248
6.7.2;Zeichenkodierung;249
6.7.3;Zeitangaben;250
6.7.4;Kommazahlen als String, Integer oder Decimal speichern;252
6.7.5;Variablen als Werte oder Referenzen übergeben;253
6.7.6;Der schwierige Umgang mit dem Nichts;256
6.7.7;Rekursion;257
6.7.8;Usability;258
6.8;Kapitel 18: Kompromisse;261
6.8.1;Trügerische Tugenden;263
6.8.2;Absolution: Wann Bad Practice okay ist;267
7;Teil4: Wahl der Mittel;273
7.1;Kapitel 19: Mach es nicht selbst;275
7.1.1;Der Weg zur Lösung;277
7.1.2;Bibliotheken;278
7.1.3;Umgang mit Fremdcode;281
7.1.4;Was man nicht selbst zu machen braucht;282
7.2;Kapitel 20: Werkzeugkasten;293
7.2.1;Editoren;294
7.2.2;Welche Programmiersprache ist die richtige?;295
7.2.3;REPL;299
7.2.4;Diff und Patch;302
7.2.5;Paketmanager;304
7.2.6;Frameworks;306
7.2.7;Entwicklungsumgebungen;309
7.3;Kapitel 21: Versionskontrolle;317
7.3.1;Alternativen;319
7.3.2;Arbeiten mit einem VCS;320
7.3.3;Konflikte auflösen;322
7.3.4;Welches Versionskontrollsystem?;323
7.3.5;Gute Ideen beim Arbeiten mit Versionskontrolle;325
7.3.6;Schlechte Ideen beim Arbeiten mit Versionskontrolle;326
7.3.7;Versionskontrollsysteme als Softwarebausteine;327
7.4;Kapitel 22: Command and Conquer – vom Überleben auf der Kommandozeile;329
7.4.1;Mehr Effizienz durch Automatisierung;330
7.4.2;Unsere langbärtigen Vorfahren;332
7.4.3;Windows;333
7.4.4;Was jeder Programmierer wissen sollte;333
7.4.5;Navigation;338
7.4.6;Dateien;338
7.4.7;Betrachten;341
7.4.8;Suchen und Finden;342
7.4.9;Ressourcen schonen;345
7.4.10;Zusammenarbeit;346
7.4.11;Zeitsteuerung;346
7.4.12;Editieren auf dem Server;348
7.4.13;Internet;348
7.4.14;Muss ich mir das alles merken?;350
7.4.15;Not the whole Shebang!;350
7.5;Kapitel 23: Objektorientierte Programmierung;353
7.5.1;Vorteile der objektorientierten Programmierung;355
7.5.2;Die Prinzipien objektorientierter Programmierung;357
7.5.3;Sinnvoller Einsatz von OOP;364
7.5.4;Nachteile und Probleme;367
7.5.5;Unterschiedliche Objektmodelle, je nach Sprache;368
7.5.6;Objektorientierte Programmierung und Weltherrschaftspläne;368
7.6;Kapitel 24: Aufbewahrung von Daten;371
7.6.1;Dateien;372
7.6.2;Versionskontrollsysteme;377
7.6.3;Datenbanken;377
7.7;Kapitel 25: Sicherheit;385
7.7.1;Wichtige Konzepte;386
7.7.2;Vor- und Nachteile der Offenheit;388
7.7.3;Vom Umgang mit Passwörtern;390
7.7.4;Authentifizierungsverfahren;391
7.7.5;SQL Injection und XSS – die Gefahren in User-Content;395
7.7.6;Weiße Listen sind besser als schwarze;400
7.7.7;Alle Regler nach links;401
7.7.8;Auch die Hintertür abschließen;403
7.7.9;Penetration Testing;404
7.7.10;Die Fehler der anderen;405
7.7.11;Sicherheit ist ein Prozess;406
7.8;Kapitel 26: Nützliche Konzepte;409
7.8.1;Exceptions;409
7.8.2;Error Handling;412
7.8.3;State und Statelessness;416
7.8.4;IDs, GUIDs, UUIDs;417
7.8.5;Sprachfamilien;419
7.8.6;Variablentypen;421
7.8.7;Trennung von Inhalt und Präsentation;424
7.8.8;Trennung von Entwicklungs- und Produktivserver;425
7.8.9;Selektoren;426
7.8.10;Namespaces;428
7.8.11;Scope von Variablen;430
7.8.12;Assertions;431
7.8.13;Transaktionen und Rollbacks;434
7.8.14;Hashes, Digests, Fingerprints;435
7.8.15;CRUD und REST;437
8;Index;443

Über Autor(innen)

Kathrin Passig ist bekannt geworden als Sachbuchautorin (unter anderem "Internet - Fluch oder Segen", zusammen mit Sascha Lobo oder "Lexikon des Unwissens", zusammen mit Aleks Scholz). Sie blickt aber auch auf fünfzehn Jahre Erfahrung mit wirklich schlechter Programmierung zurück.
Johannes Jander hat schon als Jugendlicher begeistert programmiert, musste aber erst auf einem Umweg über die Biologie zur Softwareentwicklung zurückfinden. Inzwischen arbeitet er hauptberuflich als Entwickler in einem großen Unternehmen.