Prinzipien des Softwaredesigns: Entwurfsstrategien für komplexe Systeme
Gespeichert in:
| 1. Verfasser: | |
|---|---|
| Weitere Verfasser: | |
| Format: | Buch |
| Sprache: | German English |
| Veröffentlicht: |
Heidelberg
O'Reilly
2022
|
| Ausgabe: | 1. Auflage |
| Schlagworte: | |
| Online-Zugang: | Inhaltstext Inhaltsverzeichnis |
| Beschreibung: | Auf dem Cover: US-Bestseller, Übersetzung der 2. Auflage |
| Beschreibung: | 190 Seiten Illustrationen, Diagramme 24 cm x 16.5 cm |
| ISBN: | 9783960091592 3960091591 |
Internformat
MARC
| LEADER | 00000nam a22000008c 4500 | ||
|---|---|---|---|
| 001 | BV047380763 | ||
| 003 | DE-604 | ||
| 005 | 20220613 | ||
| 007 | t | ||
| 008 | 210721s2022 gw a||| |||| 00||| ger d | ||
| 015 | |a 21,N09 |2 dnb | ||
| 016 | 7 | |a 1228166161 |2 DE-101 | |
| 020 | |a 9783960091592 |c kart. : EUR 24.90 (DE), EUR 25.60 (AT), ca. CHF 25.76 (freier Preis) |9 978-3-96009-159-2 | ||
| 020 | |a 3960091591 |9 3-96009-159-1 | ||
| 024 | 3 | |a 9783960091592 | |
| 035 | |a (OCoLC)1284800976 | ||
| 035 | |a (DE-599)DNB1228166161 | ||
| 040 | |a DE-604 |b ger |e rda | ||
| 041 | 1 | |a ger |h eng | |
| 044 | |a gw |c XA-DE-BW | ||
| 049 | |a DE-11 |a DE-860 |a DE-1050 |a DE-739 |a DE-Aug4 |a DE-1043 |a DE-858 |a DE-19 |a DE-29T |a DE-20 |a DE-859 |a DE-634 |a DE-703 |a DE-861 |a DE-573 |a DE-898 |a DE-824 |a DE-1102 | ||
| 084 | |a ST 230 |0 (DE-625)143617: |2 rvk | ||
| 084 | |8 1\p |a 004 |2 23sdnb | ||
| 100 | 1 | |a Ousterhout, John K. |d 1954- |e Verfasser |0 (DE-588)172296900 |4 aut | |
| 240 | 1 | 0 | |a A philosophy of software design |
| 245 | 1 | 0 | |a Prinzipien des Softwaredesigns |b Entwurfsstrategien für komplexe Systeme |c John Ousterhout ; deutsche Übersetzung von Thomas Demmig |
| 250 | |a 1. Auflage | ||
| 264 | 1 | |a Heidelberg |b O'Reilly |c 2022 | |
| 300 | |a 190 Seiten |b Illustrationen, Diagramme |c 24 cm x 16.5 cm | ||
| 336 | |b txt |2 rdacontent | ||
| 337 | |b n |2 rdamedia | ||
| 338 | |b nc |2 rdacarrier | ||
| 500 | |a Auf dem Cover: US-Bestseller, Übersetzung der 2. Auflage | ||
| 650 | 0 | 7 | |a Softwarearchitektur |0 (DE-588)4121677-5 |2 gnd |9 rswk-swf |
| 653 | |a Softwarearchitektur | ||
| 653 | |a Softwareentwicklung | ||
| 653 | |a clean code | ||
| 653 | |a Redesign | ||
| 653 | |a C++ | ||
| 653 | |a Java | ||
| 653 | |a objektorientierte Programmierung | ||
| 653 | |a programmieren | ||
| 653 | |a Programmierung | ||
| 653 | |a better code | ||
| 653 | |a Code Review | ||
| 653 | |a Code | ||
| 653 | |a Code-Smell | ||
| 689 | 0 | 0 | |a Softwarearchitektur |0 (DE-588)4121677-5 |D s |
| 689 | 0 | |5 DE-604 | |
| 700 | 1 | |a Demmig, Thomas |0 (DE-588)128548568 |4 trl | |
| 775 | 0 | 8 | |i Parallele Sprachausgabe |z 9781732102200 |
| 776 | 0 | 8 | |i Erscheint auch als |n Online-Ausgabe, EPUB |z 978-3-96010-500-8 |
| 776 | 0 | 8 | |i Erscheint auch als |n Online-Ausgabe, PDF |z 978-3-96010-499-5 |
| 776 | 0 | 8 | |i Erscheint auch als |n Online-Ausgabe, MOBI |z 978-3-96010-501-5 |
| 856 | 4 | 2 | |m X:MVB |q text/html |u http://deposit.dnb.de/cgi-bin/dokserv?id=195ee2d8d7834b3f99d26961f453d5c6&prov=M&dok_var=1&dok_ext=htm |3 Inhaltstext |
| 856 | 4 | 2 | |m Digitalisierung UB Passau - ADAM Catalogue Enrichment |q application/pdf |u http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=032782347&sequence=000001&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA |3 Inhaltsverzeichnis |
| 999 | |a oai:aleph.bib-bvb.de:BVB01-032782347 | ||
| 883 | 2 | |8 1\p |a dnb |d 20210223 |q DE-101 |u https://d-nb.info/provenance/plan#dnb | |
Datensatz im Suchindex
| _version_ | 1804182625999388672 |
|---|---|
| adam_text | Inhalt Vorwort............................................................................................................... 1 2 3 4 11 Einführung (es geht immer um Komplexität)................................................ 15 Wie Sie dieses Buch einsetzen................................................................ 17 Die Natur der Komplexität............................................................................ 19 Definition der Komplexität..................................................................... Symptome der Komplexität..................................................................... Ursachen für Komplexität....................................................................... Komplexität ist inkrementell................................................................... Zusammenfassung................................................................................... 19 21 23 25 25 Funktionierender Code reicht nicht aus (strategische versus taktische Programmierung).......................................... 27 Taktische Programmierung..................................................................... Strategische Programmierung................................................................. Wie viel soll ich investieren?................................................................... Start-ups und Investitionen..................................................................... Zusammenfassung................................................................................... 27 28 30 31 32 Module sollten
tiefsein................................................................................ 33 Modulares Design................................................................................... Was ist eine Schnittstelle?....................................................................... Abstraktionen......................................................................................... Tiefe Module........................................................................................... Flache Module......................................................................................... Klassizitis........................ Beispiele: Java und Unix-I/O................................................................... Zusammenfassung................................................................................... 33 34 35 36 39 39 40 41
5 6 7 8 9 6 I Information Hiding (und Lecks)....................................................... 43 Information Hiding.................................................................................... Informationslecks...................................................................................... Zeitliche Dekomposition.......................................................................... Beispiel: HTTP-Server................................................................................ Beispiel: Zu viele Klassen.......................................................................... Beispiel: HTTP-Parameter-Handling....................................................... Beispiel: Standardwerte in HTTP-Responses.......................................... Information Hiding in einer Klasse........................................................... Wann Sie zu weit gehen............................................................................ Zusammenfassung.................................................................................... 43 44 45 46 47 48 49 50 50 51 Vielseitige Module sind tiefer........................................................... 53 Gestalten Sie Klassen halbwegs vielseitig................................................ Beispiel: Text für einen Editor speichern................................................ Eine vielseitigere API.................................................................................. Vielseitigkeit führt zu besserem Information Hiding.............................. Fragen, die Sie sich stellen
sollten............................................................. Spezialisierung nach oben (und unten!) schieben.................................... Beispiel: Undo-Mechanismus für den Editor.......................................... Spezialfälle wegdesignen............................................................................ Zusammenfassung.................................................................................... 53 54 56 57 57 58 59 62 63 Verschiedene Schichten, verschiedene Abstraktionen............................ 65 Pass-Through-Methoden.......................................................................... Wann ist es in Ordnung, Schnittstellen doppelt zu haben?................... Das Decorator-Design-Pattern................................................................. Schnittstelle versus Implementierung....................................................... Pass-Through-Variablen............................................................................ Zusammenfassung.................................................................................... 66 68 68 70 70 73 Komplexität nach unten ziehen....................................................... 75 Beispiel: Texteditor-Klasse........................................................................ Beispiel: Konfigurationsparameter........................................................... Wann Sie zu weit gehen............................................................................
Zusammenfassung.................................................................................... 75 76 77 78 Zusammen oder getrennt?.............................................................. 79 Zusammenbringen bei gemeinsamen Informationen.............................. Zusammenbringen, um die Schnittstelle zu vereinfachen..................... Zusammenbringen, um doppelten Code zu vermeiden......................... Trennen von allgemeinem und speziellem Code.................................... 80 81 81 83 Inhalt
Beispiel: Einfügecursor und Auswahl.................................................... Beispiel: Getrennte Klasse zum Loggen................................................... Methoden aufteilen und zusammenführen............................................ Eine andere Meinung: Clean Code......................................................... Zusammenfassung................................................................................... 10 11 84 85 86 89 89 Definieren Sie die Existenz von Fehlern weg................................................... 91 Warum Exceptions zur Komplexität beitragen...................................... Zu viele Exceptions................................................................................. Die Existenz von Fehlern wegdefinieren................................................ Beispiel: Datei löschen in Windows...................................................... Beispiel: substring-Methode in Java....................................................... Exceptions maskieren............................................................................. Aggregieren von Exceptions................................................................... Einfach abstürzenP................................................................................... Wann Sie zu weit gehen........................................................................... Zusammenfassung................................................................................... 91 94 95 95 96 97 98 102 103 103 Designen Sie
zweimal......................................................................................... 105 12 Warum Kommentare schreiben? - Die vier Ausreden...................................... 109 Guter Code dokumentiert sich selbst.................................................... Ich habe keine Zeit, Kommentare zu schreiben...................................... Kommentare veralten und sind dann irreführend.................................. Die Kommentare, die ich gesehen habe, sind alle nutzlos...................... Die Vorteile gut geschriebener Kommentare.......................................... Eine andere Meinung: Kommentare sind Fehler.................................... 110 111 112 112 112 113 13 Kommentare sollten Dinge beschreiben, die im Code nicht offensichtlich sind.............................................................................................. 115 Konventionen......................................................................................... Wiederholen Sie nicht den Code............................................................ Kommentare auf niedrigerer Ebene sorgen für Präzision...................... Kommentare auf höherer Ebene verbessern die Intuition...................... Schnittstellendokumentation................................................................... Implementierungskommentare: was und warum, nicht wie.................. Modulübergreifende Designentscheidungen.......................................... Zusammenfassung................................................................................... Antworten auf die
Fragen aus dem Abschnitt »Schnittstellendokumentation« auf Seite 123........................................ 116 117 119 121 123 129 131 133 Inhalt 134 I 7
14 Namen auswählen....................................................................... 135 Beispiel: Schlechte Namen führen zu Fehlern.......................................... Ein Bild schaffen........................................................................................ Namen sollten präzise sein........................................................................ Namen konsistent einsetzen..................................................................... Vermeiden Sie überflüssige Wörter......................................................... Eine andere Meinung: Go Style Guide..................................................... Zusammenfassung.................................................................................... 135 136 137 139 140 141 142 15 Erst die Kommentare schreiben (nutzen Sie Kommentare als Teil des Designprozesses).......................... 143 Aufgeschobene Kommentare sind schlechte Kommentare..................... Erst die Kommentare schreiben............................................................... Kommentare sind ein Designwerkzeug..................................................... Frühes Kommentieren macht Spaß........................................................... Sind frühe Kommentare teuer?................................................................. Zusammenfassung.................................................................................... 143 144 145 146 146 146 16 Bestehenden Code anpassen........................................................... 147 Bleiben Sie
strategisch................................................................................ Kommentare pflegen: Halten Sie die Kommentare nahe am Code........ Kommentare gehören in den Code, nicht in das Commit-Log............... Kommentare pflegen: Vermeiden Sie Duplikate...................................... Kommentare pflegen: Schauen Sie auf die Diffs..................... Kommentare auf höherer Ebene lassen sich leichter pflegen................. 147 149 150 150 152 152 17 Konsistenz................. Beispiele für Konsistenz............................................................................ Konsistenz sicherstellen............................................................................ Wann Sie zu weit gehen............................................................................ Zusammenfassung.................................................................................... 153 153 154 156 156 18 Code sollte offensichtlich sein......................................................... 157 Dinge, die Code offensichtlicher machen................................................ Dinge, die Code weniger offensichtlich machen...................................... Zusammenfassung.................................................................................... 157 160 162 8 I Inhalt
19 Softwaretrends............................................................................ 163 Objektorientierte Programmierung und Vererbung............................... Agile Entwicklung...................................................................................... Unit Tests................................................................................................... Test-Driven Development.......................................................................... Design Patterns.......................................................................................... Getter und Setter........................................................................................ Zusammenfassung...................................................................................... 163 165 166 167 168 168 169 20 Performance............................................................................... Wie man über Performance nachdenkt.................................................... Vor (und nach) dem Ändern messen......................................................... Rund um den kritischen Pfad designen..................................................... Ein Beispiel: RAMCloud-Buffer................................................................. Zusammenfassung...................................................................................... 171 171 173 174 175 180 21 Entscheiden, was wichtig ist............................................................ 181 Wie entscheidet man, was wichtig ist?....................................................
Lassen Sie möglichst wenig wichtig sein.................................................. Wie Sie wichtige Dinge hervorheben......................................................... Fehler........................................................................................................... Denken Sie umfassender............................................................................ 181 182 183 183 184 22 Zusammenfassung........................................................................ 185 Index............................................................................................... 187 Inhalt I 9
|
| adam_txt |
Inhalt Vorwort. 1 2 3 4 11 Einführung (es geht immer um Komplexität). 15 Wie Sie dieses Buch einsetzen. 17 Die Natur der Komplexität. 19 Definition der Komplexität. Symptome der Komplexität. Ursachen für Komplexität. Komplexität ist inkrementell. Zusammenfassung. 19 21 23 25 25 Funktionierender Code reicht nicht aus (strategische versus taktische Programmierung). 27 Taktische Programmierung. Strategische Programmierung. Wie viel soll ich investieren?. Start-ups und Investitionen. Zusammenfassung. 27 28 30 31 32 Module sollten
tiefsein. 33 Modulares Design. Was ist eine Schnittstelle?. Abstraktionen. Tiefe Module. Flache Module. Klassizitis. Beispiele: Java und Unix-I/O. Zusammenfassung. 33 34 35 36 39 39 40 41
5 6 7 8 9 6 I Information Hiding (und Lecks). 43 Information Hiding. Informationslecks. Zeitliche Dekomposition. Beispiel: HTTP-Server. Beispiel: Zu viele Klassen. Beispiel: HTTP-Parameter-Handling. Beispiel: Standardwerte in HTTP-Responses. Information Hiding in einer Klasse. Wann Sie zu weit gehen. Zusammenfassung. 43 44 45 46 47 48 49 50 50 51 Vielseitige Module sind tiefer. 53 Gestalten Sie Klassen halbwegs vielseitig. Beispiel: Text für einen Editor speichern. Eine vielseitigere API. Vielseitigkeit führt zu besserem Information Hiding. Fragen, die Sie sich stellen
sollten. Spezialisierung nach oben (und unten!) schieben. Beispiel: Undo-Mechanismus für den Editor. Spezialfälle wegdesignen. Zusammenfassung. 53 54 56 57 57 58 59 62 63 Verschiedene Schichten, verschiedene Abstraktionen. 65 Pass-Through-Methoden. Wann ist es in Ordnung, Schnittstellen doppelt zu haben?. Das Decorator-Design-Pattern. Schnittstelle versus Implementierung. Pass-Through-Variablen. Zusammenfassung. 66 68 68 70 70 73 Komplexität nach unten ziehen. 75 Beispiel: Texteditor-Klasse. Beispiel: Konfigurationsparameter. Wann Sie zu weit gehen.
Zusammenfassung. 75 76 77 78 Zusammen oder getrennt?. 79 Zusammenbringen bei gemeinsamen Informationen. Zusammenbringen, um die Schnittstelle zu vereinfachen. Zusammenbringen, um doppelten Code zu vermeiden. Trennen von allgemeinem und speziellem Code. 80 81 81 83 Inhalt
Beispiel: Einfügecursor und Auswahl. Beispiel: Getrennte Klasse zum Loggen. Methoden aufteilen und zusammenführen. Eine andere Meinung: Clean Code. Zusammenfassung. 10 11 84 85 86 89 89 Definieren Sie die Existenz von Fehlern weg. 91 Warum Exceptions zur Komplexität beitragen. Zu viele Exceptions. Die Existenz von Fehlern wegdefinieren. Beispiel: Datei löschen in Windows. Beispiel: substring-Methode in Java. Exceptions maskieren. Aggregieren von Exceptions. Einfach abstürzenP. Wann Sie zu weit gehen. Zusammenfassung. 91 94 95 95 96 97 98 102 103 103 Designen Sie
zweimal. 105 12 Warum Kommentare schreiben? - Die vier Ausreden. 109 Guter Code dokumentiert sich selbst. Ich habe keine Zeit, Kommentare zu schreiben. Kommentare veralten und sind dann irreführend. Die Kommentare, die ich gesehen habe, sind alle nutzlos. Die Vorteile gut geschriebener Kommentare. Eine andere Meinung: Kommentare sind Fehler. 110 111 112 112 112 113 13 Kommentare sollten Dinge beschreiben, die im Code nicht offensichtlich sind. 115 Konventionen. Wiederholen Sie nicht den Code. Kommentare auf niedrigerer Ebene sorgen für Präzision. Kommentare auf höherer Ebene verbessern die Intuition. Schnittstellendokumentation. Implementierungskommentare: was und warum, nicht wie. Modulübergreifende Designentscheidungen. Zusammenfassung. Antworten auf die
Fragen aus dem Abschnitt »Schnittstellendokumentation« auf Seite 123. 116 117 119 121 123 129 131 133 Inhalt 134 I 7
14 Namen auswählen. 135 Beispiel: Schlechte Namen führen zu Fehlern. Ein Bild schaffen. Namen sollten präzise sein. Namen konsistent einsetzen. Vermeiden Sie überflüssige Wörter. Eine andere Meinung: Go Style Guide. Zusammenfassung. 135 136 137 139 140 141 142 15 Erst die Kommentare schreiben (nutzen Sie Kommentare als Teil des Designprozesses). 143 Aufgeschobene Kommentare sind schlechte Kommentare. Erst die Kommentare schreiben. Kommentare sind ein Designwerkzeug. Frühes Kommentieren macht Spaß. Sind frühe Kommentare teuer?. Zusammenfassung. 143 144 145 146 146 146 16 Bestehenden Code anpassen. 147 Bleiben Sie
strategisch. Kommentare pflegen: Halten Sie die Kommentare nahe am Code. Kommentare gehören in den Code, nicht in das Commit-Log. Kommentare pflegen: Vermeiden Sie Duplikate. Kommentare pflegen: Schauen Sie auf die Diffs. Kommentare auf höherer Ebene lassen sich leichter pflegen. 147 149 150 150 152 152 17 Konsistenz. Beispiele für Konsistenz. Konsistenz sicherstellen. Wann Sie zu weit gehen. Zusammenfassung. 153 153 154 156 156 18 Code sollte offensichtlich sein. 157 Dinge, die Code offensichtlicher machen. Dinge, die Code weniger offensichtlich machen. Zusammenfassung. 157 160 162 8 I Inhalt
19 Softwaretrends. 163 Objektorientierte Programmierung und Vererbung. Agile Entwicklung. Unit Tests. Test-Driven Development. Design Patterns. Getter und Setter. Zusammenfassung. 163 165 166 167 168 168 169 20 Performance. Wie man über Performance nachdenkt. Vor (und nach) dem Ändern messen. Rund um den kritischen Pfad designen. Ein Beispiel: RAMCloud-Buffer. Zusammenfassung. 171 171 173 174 175 180 21 Entscheiden, was wichtig ist. 181 Wie entscheidet man, was wichtig ist?.
Lassen Sie möglichst wenig wichtig sein. Wie Sie wichtige Dinge hervorheben. Fehler. Denken Sie umfassender. 181 182 183 183 184 22 Zusammenfassung. 185 Index. 187 Inhalt I 9 |
| any_adam_object | 1 |
| any_adam_object_boolean | 1 |
| author | Ousterhout, John K. 1954- |
| author2 | Demmig, Thomas |
| author2_role | trl |
| author2_variant | t d td |
| author_GND | (DE-588)172296900 (DE-588)128548568 |
| author_facet | Ousterhout, John K. 1954- Demmig, Thomas |
| author_role | aut |
| author_sort | Ousterhout, John K. 1954- |
| author_variant | j k o jk jko |
| building | Verbundindex |
| bvnumber | BV047380763 |
| classification_rvk | ST 230 |
| ctrlnum | (OCoLC)1284800976 (DE-599)DNB1228166161 |
| discipline | Informatik |
| discipline_str_mv | Informatik |
| edition | 1. Auflage |
| format | Book |
| fullrecord | <?xml version="1.0" encoding="UTF-8"?><collection xmlns="http://www.loc.gov/MARC21/slim"><record><leader>02832nam a22006618c 4500</leader><controlfield tag="001">BV047380763</controlfield><controlfield tag="003">DE-604</controlfield><controlfield tag="005">20220613 </controlfield><controlfield tag="007">t</controlfield><controlfield tag="008">210721s2022 gw a||| |||| 00||| ger d</controlfield><datafield tag="015" ind1=" " ind2=" "><subfield code="a">21,N09</subfield><subfield code="2">dnb</subfield></datafield><datafield tag="016" ind1="7" ind2=" "><subfield code="a">1228166161</subfield><subfield code="2">DE-101</subfield></datafield><datafield tag="020" ind1=" " ind2=" "><subfield code="a">9783960091592</subfield><subfield code="c">kart. : EUR 24.90 (DE), EUR 25.60 (AT), ca. CHF 25.76 (freier Preis)</subfield><subfield code="9">978-3-96009-159-2</subfield></datafield><datafield tag="020" ind1=" " ind2=" "><subfield code="a">3960091591</subfield><subfield code="9">3-96009-159-1</subfield></datafield><datafield tag="024" ind1="3" ind2=" "><subfield code="a">9783960091592</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(OCoLC)1284800976</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(DE-599)DNB1228166161</subfield></datafield><datafield tag="040" ind1=" " ind2=" "><subfield code="a">DE-604</subfield><subfield code="b">ger</subfield><subfield code="e">rda</subfield></datafield><datafield tag="041" ind1="1" ind2=" "><subfield code="a">ger</subfield><subfield code="h">eng</subfield></datafield><datafield tag="044" ind1=" " ind2=" "><subfield code="a">gw</subfield><subfield code="c">XA-DE-BW</subfield></datafield><datafield tag="049" ind1=" " ind2=" "><subfield code="a">DE-11</subfield><subfield code="a">DE-860</subfield><subfield code="a">DE-1050</subfield><subfield code="a">DE-739</subfield><subfield code="a">DE-Aug4</subfield><subfield code="a">DE-1043</subfield><subfield code="a">DE-858</subfield><subfield code="a">DE-19</subfield><subfield code="a">DE-29T</subfield><subfield code="a">DE-20</subfield><subfield code="a">DE-859</subfield><subfield code="a">DE-634</subfield><subfield code="a">DE-703</subfield><subfield code="a">DE-861</subfield><subfield code="a">DE-573</subfield><subfield code="a">DE-898</subfield><subfield code="a">DE-824</subfield><subfield code="a">DE-1102</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="a">ST 230</subfield><subfield code="0">(DE-625)143617:</subfield><subfield code="2">rvk</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="8">1\p</subfield><subfield code="a">004</subfield><subfield code="2">23sdnb</subfield></datafield><datafield tag="100" ind1="1" ind2=" "><subfield code="a">Ousterhout, John K.</subfield><subfield code="d">1954-</subfield><subfield code="e">Verfasser</subfield><subfield code="0">(DE-588)172296900</subfield><subfield code="4">aut</subfield></datafield><datafield tag="240" ind1="1" ind2="0"><subfield code="a">A philosophy of software design</subfield></datafield><datafield tag="245" ind1="1" ind2="0"><subfield code="a">Prinzipien des Softwaredesigns</subfield><subfield code="b">Entwurfsstrategien für komplexe Systeme</subfield><subfield code="c">John Ousterhout ; deutsche Übersetzung von Thomas Demmig</subfield></datafield><datafield tag="250" ind1=" " ind2=" "><subfield code="a">1. Auflage</subfield></datafield><datafield tag="264" ind1=" " ind2="1"><subfield code="a">Heidelberg</subfield><subfield code="b">O'Reilly</subfield><subfield code="c">2022</subfield></datafield><datafield tag="300" ind1=" " ind2=" "><subfield code="a">190 Seiten</subfield><subfield code="b">Illustrationen, Diagramme</subfield><subfield code="c">24 cm x 16.5 cm</subfield></datafield><datafield tag="336" ind1=" " ind2=" "><subfield code="b">txt</subfield><subfield code="2">rdacontent</subfield></datafield><datafield tag="337" ind1=" " ind2=" "><subfield code="b">n</subfield><subfield code="2">rdamedia</subfield></datafield><datafield tag="338" ind1=" " ind2=" "><subfield code="b">nc</subfield><subfield code="2">rdacarrier</subfield></datafield><datafield tag="500" ind1=" " ind2=" "><subfield code="a">Auf dem Cover: US-Bestseller, Übersetzung der 2. Auflage</subfield></datafield><datafield tag="650" ind1="0" ind2="7"><subfield code="a">Softwarearchitektur</subfield><subfield code="0">(DE-588)4121677-5</subfield><subfield code="2">gnd</subfield><subfield code="9">rswk-swf</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Softwarearchitektur</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Softwareentwicklung</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">clean code</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Redesign</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">C++</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Java</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">objektorientierte Programmierung</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">programmieren</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Programmierung</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">better code</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Code Review</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Code</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Code-Smell</subfield></datafield><datafield tag="689" ind1="0" ind2="0"><subfield code="a">Softwarearchitektur</subfield><subfield code="0">(DE-588)4121677-5</subfield><subfield code="D">s</subfield></datafield><datafield tag="689" ind1="0" ind2=" "><subfield code="5">DE-604</subfield></datafield><datafield tag="700" ind1="1" ind2=" "><subfield code="a">Demmig, Thomas</subfield><subfield code="0">(DE-588)128548568</subfield><subfield code="4">trl</subfield></datafield><datafield tag="775" ind1="0" ind2="8"><subfield code="i">Parallele Sprachausgabe</subfield><subfield code="z">9781732102200</subfield></datafield><datafield tag="776" ind1="0" ind2="8"><subfield code="i">Erscheint auch als</subfield><subfield code="n">Online-Ausgabe, EPUB</subfield><subfield code="z">978-3-96010-500-8</subfield></datafield><datafield tag="776" ind1="0" ind2="8"><subfield code="i">Erscheint auch als</subfield><subfield code="n">Online-Ausgabe, PDF</subfield><subfield code="z">978-3-96010-499-5</subfield></datafield><datafield tag="776" ind1="0" ind2="8"><subfield code="i">Erscheint auch als</subfield><subfield code="n">Online-Ausgabe, MOBI</subfield><subfield code="z">978-3-96010-501-5</subfield></datafield><datafield tag="856" ind1="4" ind2="2"><subfield code="m">X:MVB</subfield><subfield code="q">text/html</subfield><subfield code="u">http://deposit.dnb.de/cgi-bin/dokserv?id=195ee2d8d7834b3f99d26961f453d5c6&prov=M&dok_var=1&dok_ext=htm</subfield><subfield code="3">Inhaltstext</subfield></datafield><datafield tag="856" ind1="4" ind2="2"><subfield code="m">Digitalisierung UB Passau - ADAM Catalogue Enrichment</subfield><subfield code="q">application/pdf</subfield><subfield code="u">http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=032782347&sequence=000001&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA</subfield><subfield code="3">Inhaltsverzeichnis</subfield></datafield><datafield tag="999" ind1=" " ind2=" "><subfield code="a">oai:aleph.bib-bvb.de:BVB01-032782347</subfield></datafield><datafield tag="883" ind1="2" ind2=" "><subfield code="8">1\p</subfield><subfield code="a">dnb</subfield><subfield code="d">20210223</subfield><subfield code="q">DE-101</subfield><subfield code="u">https://d-nb.info/provenance/plan#dnb</subfield></datafield></record></collection> |
| id | DE-604.BV047380763 |
| illustrated | Illustrated |
| index_date | 2024-07-03T17:47:29Z |
| indexdate | 2024-07-10T09:10:32Z |
| institution | BVB |
| isbn | 9783960091592 3960091591 |
| language | German English |
| oai_aleph_id | oai:aleph.bib-bvb.de:BVB01-032782347 |
| oclc_num | 1284800976 |
| open_access_boolean | |
| owner | DE-11 DE-860 DE-1050 DE-739 DE-Aug4 DE-1043 DE-858 DE-19 DE-BY-UBM DE-29T DE-20 DE-859 DE-634 DE-703 DE-861 DE-573 DE-898 DE-BY-UBR DE-824 DE-1102 |
| owner_facet | DE-11 DE-860 DE-1050 DE-739 DE-Aug4 DE-1043 DE-858 DE-19 DE-BY-UBM DE-29T DE-20 DE-859 DE-634 DE-703 DE-861 DE-573 DE-898 DE-BY-UBR DE-824 DE-1102 |
| physical | 190 Seiten Illustrationen, Diagramme 24 cm x 16.5 cm |
| publishDate | 2022 |
| publishDateSearch | 2022 |
| publishDateSort | 2022 |
| publisher | O'Reilly |
| record_format | marc |
| spelling | Ousterhout, John K. 1954- Verfasser (DE-588)172296900 aut A philosophy of software design Prinzipien des Softwaredesigns Entwurfsstrategien für komplexe Systeme John Ousterhout ; deutsche Übersetzung von Thomas Demmig 1. Auflage Heidelberg O'Reilly 2022 190 Seiten Illustrationen, Diagramme 24 cm x 16.5 cm txt rdacontent n rdamedia nc rdacarrier Auf dem Cover: US-Bestseller, Übersetzung der 2. Auflage Softwarearchitektur (DE-588)4121677-5 gnd rswk-swf Softwarearchitektur Softwareentwicklung clean code Redesign C++ Java objektorientierte Programmierung programmieren Programmierung better code Code Review Code Code-Smell Softwarearchitektur (DE-588)4121677-5 s DE-604 Demmig, Thomas (DE-588)128548568 trl Parallele Sprachausgabe 9781732102200 Erscheint auch als Online-Ausgabe, EPUB 978-3-96010-500-8 Erscheint auch als Online-Ausgabe, PDF 978-3-96010-499-5 Erscheint auch als Online-Ausgabe, MOBI 978-3-96010-501-5 X:MVB text/html http://deposit.dnb.de/cgi-bin/dokserv?id=195ee2d8d7834b3f99d26961f453d5c6&prov=M&dok_var=1&dok_ext=htm Inhaltstext Digitalisierung UB Passau - ADAM Catalogue Enrichment application/pdf http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=032782347&sequence=000001&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA Inhaltsverzeichnis 1\p dnb 20210223 DE-101 https://d-nb.info/provenance/plan#dnb |
| spellingShingle | Ousterhout, John K. 1954- Prinzipien des Softwaredesigns Entwurfsstrategien für komplexe Systeme Softwarearchitektur (DE-588)4121677-5 gnd |
| subject_GND | (DE-588)4121677-5 |
| title | Prinzipien des Softwaredesigns Entwurfsstrategien für komplexe Systeme |
| title_alt | A philosophy of software design |
| title_auth | Prinzipien des Softwaredesigns Entwurfsstrategien für komplexe Systeme |
| title_exact_search | Prinzipien des Softwaredesigns Entwurfsstrategien für komplexe Systeme |
| title_exact_search_txtP | Prinzipien des Softwaredesigns Entwurfsstrategien für komplexe Systeme |
| title_full | Prinzipien des Softwaredesigns Entwurfsstrategien für komplexe Systeme John Ousterhout ; deutsche Übersetzung von Thomas Demmig |
| title_fullStr | Prinzipien des Softwaredesigns Entwurfsstrategien für komplexe Systeme John Ousterhout ; deutsche Übersetzung von Thomas Demmig |
| title_full_unstemmed | Prinzipien des Softwaredesigns Entwurfsstrategien für komplexe Systeme John Ousterhout ; deutsche Übersetzung von Thomas Demmig |
| title_short | Prinzipien des Softwaredesigns |
| title_sort | prinzipien des softwaredesigns entwurfsstrategien fur komplexe systeme |
| title_sub | Entwurfsstrategien für komplexe Systeme |
| topic | Softwarearchitektur (DE-588)4121677-5 gnd |
| topic_facet | Softwarearchitektur |
| url | http://deposit.dnb.de/cgi-bin/dokserv?id=195ee2d8d7834b3f99d26961f453d5c6&prov=M&dok_var=1&dok_ext=htm http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=032782347&sequence=000001&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA |
| work_keys_str_mv | AT ousterhoutjohnk aphilosophyofsoftwaredesign AT demmigthomas aphilosophyofsoftwaredesign AT ousterhoutjohnk prinzipiendessoftwaredesignsentwurfsstrategienfurkomplexesysteme AT demmigthomas prinzipiendessoftwaredesignsentwurfsstrategienfurkomplexesysteme |