Clean Code: A Handbook of Agile Software Craftsmanship

Inhaltsverzeichnis



Foreword                      xix

Introduction              xxv

On the Cover                     xxix



Chapter 1: Clean Code                    1

There Will Be Code                        2

Bad Code                           3

The Total Cost of Owning a Mess                 4

Schools of Thought                        12

We Are Authors                      13

The Boy Scout Rule                     14

Prequel and Principles                   15

Conclusion                        15

Bibliography                  15

Chapter 2: Meaningful Names                     17

Introduction               17

Use Intention-Revealing Names                     18

Avoid Disinformation                         19

Make Meaningful Distinctions                20

Use Pronounceable Names                            21

Use Searchable Names                                22

Avoid Encodings                          23

Avoid Mental Mapping                    25

Class Names                    25

Method Names                              25

Don’t Be Cute                    26

Pick One Word per Concept                 26

Don’t Pun                    26

Use Solution Domain Names                    27

Use Problem Domain Names                   27

Add Meaningful Context                       27

Don’t Add Gratuitous Context                    29

Final Words                        30

Chapter 3: Functions                                           31

Small!                               34

Do One Thing                         35

One Level of Abstraction per Function                           36

Switch Statements                     37

Use Descriptive Names                      39

Function Arguments                          40

Have No Side Effects                          44

Command Query Separation                           45

Prefer Exceptions to Returning Error Codes              46

Don’t Repeat Yourself                          48

Structured Programming                   48

How Do You Write Functions Like This?                49

Conclusion                          49

SetupTeardownIncluder                        50

Bibliography                                       52

Chapter 4: Comments                                                  53

Comments Do Not Make Up for Bad Code                   55

Explain Yourself in Code                        55

Good Comments                              55

Bad Comments                          59

Bibliography                          74

Chapter 5: Formatting                                           75

The Purpose of Formatting                     76

Vertical Formatting                         76

Horizontal Formatting                         85

Team Rules                      90

Uncle Bob’s Formatting Rules                  90

Chapter 6: Objects and Data Structures                      93

Data Abstraction                     93

Data/Object Anti-Symmetry                        95

The Law of Demeter                         97

Data Transfer Objects                     100

Conclusion                       101

Bibliography                           101

Chapter 7: Error Handling                           103

Use Exceptions Rather Than Return Codes                  104

Write Your Try-Catch-Finally Statement First                    105

Use Unchecked Exceptions                         106

Provide Context with Exceptions                      107

Define Exception Classes in Terms of a Caller’s Needs                107

Define the Normal Flow                  109

Don’t Return Null                        110

Don’t Pass Null                       111

Conclusion                           112

Bibliography                                 112

Chapter 8: Boundaries                                                            113

Using Third-Party Code                               114

Exploring and Learning Boundaries                      116

Learning log4j                         116

Learning Tests Are Better Than Free                      118

Using Code That Does Not Yet Exist                     118

Clean Boundaries                           120

Bibliography                           120

Chapter 9: Unit Tests                                    121

The Three Laws of TDD                   122

Keeping Tests Clean                          123

Clean Tests                        124

One Assert per Test                        130

F.I.R.S.T.                      132

Conclusion                       133

Bibliography                        133

Chapter 10: Classes                         135

Class Organization                  136

Classes Should Be Small!                 136

Organizing for Change                   147

Bibliography                     151

Chapter 11: Systems                                                  153

How Would You Build a City?                     154

Separate Constructing a System from Using It                      154

Scaling Up                            157

Java Proxies                        161

Pure Java AOP Frameworks                     163

AspectJ Aspects                     166

Test Drive the System Architecture                      166

Optimize Decision Making                       167

Use Standards Wisely, When They Add Demonstrable Value                168

Systems Need Domain-Specific Languages                   168

Conclusion                    169

Bibliography                      169

Chapter 12: Emergence                        171

Getting Clean via Emergent Design                171

Simple Design Rule 1: Runs All the Tests                  172

Simple Design Rules 2–4: Refactoring                        172

No Duplication                      173

Expressive                        175

Minimal Classes and Methods               176

Conclusion                   176

Bibliography                     176

Chapter 13: Concurrency                         177

Why Concurrency?                    178

Challenges                        180

Concurrency Defense Principles                   180

Know Your Library                    182

Know Your Execution Models                       183

Beware Dependencies Between Synchronized Methods            185

Keep Synchronized Sections Small                  185

Writing Correct Shut-Down Code Is Hard                 186

Testing Threaded Code                     186

Conclusion                      190

Bibliography                         191

Chapter 14: Successive Refinement                     193

Args Implementation                          194

Args: The Rough Draft                       201

String Arguments                   214

Conclusion                       250

Chapter 15: JUnit Internals                                    251

The JUnit Framework                    252

Conclusion                 265

Chapter 16: Refactoring SerialDate                         267

First, Make It Work                     268

Then Make It Right                    270

Conclusion                      284

Bibliography                     284

Chapter 17: Smells and Heuristics                         285

Comments                           286

Environment                       287

Functions                            288

General                               288

Java                                     307

Names                                 309

Tests                                    313

Conclusion                         314

Bibliography                      315

Appendix A: Concurrency II                              317

Client/Server Example                           317

Possible Paths of Execution                    321

Knowing Your Library                      326

Dependencies Between Methods Can Break Concurrent Code         329

Increasing Throughput                  333

Deadlock                    335

Testing Multithreaded Code                   339

Tool Support for Testing Thread-Based Code                    342

Conclusion                    342

Tutorial: Full Code Examples                    343

Appendix B: org.jfree.date.SerialDate                             349

Appendix C: Cross References of Heuristics                  409


Epilogue                           411

Index                                  413


Clean Code: A Handbook of Agile Software Craftsmanship

A Handbook of Agile Software Craftsmanship. Foreword by James O. Coplien

Buch (Taschenbuch, Englisch)

39,99 €

inkl. gesetzl. MwSt.
Taschenbuch

Taschenbuch

39,99 €

Clean Code: A Handbook of Agile Software Craftsmanship

Ebenfalls verfügbar als:

Taschenbuch

Taschenbuch

ab 39,99 €
eBook

eBook

ab 16,99 €

Beschreibung

Details

Verkaufsrang

20957

Einband

Taschenbuch

Erscheinungsdatum

14.08.2008

Verlag

Pearson Education Limited

Seitenzahl

464

Beschreibung

Details

Verkaufsrang

20957

Einband

Taschenbuch

Erscheinungsdatum

14.08.2008

Verlag

Pearson Education Limited

Seitenzahl

464

Maße (L/B/H)

17,9/23,3/2,1 cm

Gewicht

802 g

Auflage

17th print.

Sprache

Englisch

ISBN

978-0-13-235088-4

Unsere Kundinnen und Kunden meinen

3.5

2 Bewertungen

Informationen zu Bewertungen

Zur Abgabe einer Bewertung ist eine Anmeldung im Konto notwendig. Die Authentizität der Bewertungen wird von uns nicht überprüft. Wir behalten uns vor, Bewertungstexte, die unseren Richtlinien widersprechen, entsprechend zu kürzen oder zu löschen.

5 Sterne

(0)

4 Sterne

(1)

3 Sterne

(1)

2 Sterne

(0)

1 Sterne

(0)

Achtung PDF Druck

Thomas am 17.05.2022

Bewertungsnummer: 1713707

Bewertet: Buch (Taschenbuch)

Sehr lesenswertes Buch, auch für fortgeschritte Entwickler. Leider ist es nicht das Original, sondern nur ein schlechter PDF Druck. Sehr enttäuschend bei dem Preis..
Melden

Achtung PDF Druck

Thomas am 17.05.2022
Bewertungsnummer: 1713707
Bewertet: Buch (Taschenbuch)

Sehr lesenswertes Buch, auch für fortgeschritte Entwickler. Leider ist es nicht das Original, sondern nur ein schlechter PDF Druck. Sehr enttäuschend bei dem Preis..

Melden

Abolut lesenswert

Bewertung aus Chur am 11.02.2021

Bewertungsnummer: 960425

Bewertet: eBook (ePUB)

Neue Impulse die Qualität des Sourcecodes zu bewerten. Für Profis ein Muss.
Melden

Abolut lesenswert

Bewertung aus Chur am 11.02.2021
Bewertungsnummer: 960425
Bewertet: eBook (ePUB)

Neue Impulse die Qualität des Sourcecodes zu bewerten. Für Profis ein Muss.

Melden

Unsere Kundinnen und Kunden meinen

Clean Code: A Handbook of Agile Software Craftsmanship

von Robert Martin

3.5

0 Bewertungen filtern

Die Leseprobe wird geladen.
  • Clean Code: A Handbook of Agile Software Craftsmanship


  • Foreword                      xix

    Introduction              xxv

    On the Cover                     xxix



    Chapter 1: Clean Code                    1

    There Will Be Code                        2

    Bad Code                           3

    The Total Cost of Owning a Mess                 4

    Schools of Thought                        12

    We Are Authors                      13

    The Boy Scout Rule                     14

    Prequel and Principles                   15

    Conclusion                        15

    Bibliography                  15

    Chapter 2: Meaningful Names                     17

    Introduction               17

    Use Intention-Revealing Names                     18

    Avoid Disinformation                         19

    Make Meaningful Distinctions                20

    Use Pronounceable Names                            21

    Use Searchable Names                                22

    Avoid Encodings                          23

    Avoid Mental Mapping                    25

    Class Names                    25

    Method Names                              25

    Don’t Be Cute                    26

    Pick One Word per Concept                 26

    Don’t Pun                    26

    Use Solution Domain Names                    27

    Use Problem Domain Names                   27

    Add Meaningful Context                       27

    Don’t Add Gratuitous Context                    29

    Final Words                        30

    Chapter 3: Functions                                           31

    Small!                               34

    Do One Thing                         35

    One Level of Abstraction per Function                           36

    Switch Statements                     37

    Use Descriptive Names                      39

    Function Arguments                          40

    Have No Side Effects                          44

    Command Query Separation                           45

    Prefer Exceptions to Returning Error Codes              46

    Don’t Repeat Yourself                          48

    Structured Programming                   48

    How Do You Write Functions Like This?                49

    Conclusion                          49

    SetupTeardownIncluder                        50

    Bibliography                                       52

    Chapter 4: Comments                                                  53

    Comments Do Not Make Up for Bad Code                   55

    Explain Yourself in Code                        55

    Good Comments                              55

    Bad Comments                          59

    Bibliography                          74

    Chapter 5: Formatting                                           75

    The Purpose of Formatting                     76

    Vertical Formatting                         76

    Horizontal Formatting                         85

    Team Rules                      90

    Uncle Bob’s Formatting Rules                  90

    Chapter 6: Objects and Data Structures                      93

    Data Abstraction                     93

    Data/Object Anti-Symmetry                        95

    The Law of Demeter                         97

    Data Transfer Objects                     100

    Conclusion                       101

    Bibliography                           101

    Chapter 7: Error Handling                           103

    Use Exceptions Rather Than Return Codes                  104

    Write Your Try-Catch-Finally Statement First                    105

    Use Unchecked Exceptions                         106

    Provide Context with Exceptions                      107

    Define Exception Classes in Terms of a Caller’s Needs                107

    Define the Normal Flow                  109

    Don’t Return Null                        110

    Don’t Pass Null                       111

    Conclusion                           112

    Bibliography                                 112

    Chapter 8: Boundaries                                                            113

    Using Third-Party Code                               114

    Exploring and Learning Boundaries                      116

    Learning log4j                         116

    Learning Tests Are Better Than Free                      118

    Using Code That Does Not Yet Exist                     118

    Clean Boundaries                           120

    Bibliography                           120

    Chapter 9: Unit Tests                                    121

    The Three Laws of TDD                   122

    Keeping Tests Clean                          123

    Clean Tests                        124

    One Assert per Test                        130

    F.I.R.S.T.                      132

    Conclusion                       133

    Bibliography                        133

    Chapter 10: Classes                         135

    Class Organization                  136

    Classes Should Be Small!                 136

    Organizing for Change                   147

    Bibliography                     151

    Chapter 11: Systems                                                  153

    How Would You Build a City?                     154

    Separate Constructing a System from Using It                      154

    Scaling Up                            157

    Java Proxies                        161

    Pure Java AOP Frameworks                     163

    AspectJ Aspects                     166

    Test Drive the System Architecture                      166

    Optimize Decision Making                       167

    Use Standards Wisely, When They Add Demonstrable Value                168

    Systems Need Domain-Specific Languages                   168

    Conclusion                    169

    Bibliography                      169

    Chapter 12: Emergence                        171

    Getting Clean via Emergent Design                171

    Simple Design Rule 1: Runs All the Tests                  172

    Simple Design Rules 2–4: Refactoring                        172

    No Duplication                      173

    Expressive                        175

    Minimal Classes and Methods               176

    Conclusion                   176

    Bibliography                     176

    Chapter 13: Concurrency                         177

    Why Concurrency?                    178

    Challenges                        180

    Concurrency Defense Principles                   180

    Know Your Library                    182

    Know Your Execution Models                       183

    Beware Dependencies Between Synchronized Methods            185

    Keep Synchronized Sections Small                  185

    Writing Correct Shut-Down Code Is Hard                 186

    Testing Threaded Code                     186

    Conclusion                      190

    Bibliography                         191

    Chapter 14: Successive Refinement                     193

    Args Implementation                          194

    Args: The Rough Draft                       201

    String Arguments                   214

    Conclusion                       250

    Chapter 15: JUnit Internals                                    251

    The JUnit Framework                    252

    Conclusion                 265

    Chapter 16: Refactoring SerialDate                         267

    First, Make It Work                     268

    Then Make It Right                    270

    Conclusion                      284

    Bibliography                     284

    Chapter 17: Smells and Heuristics                         285

    Comments                           286

    Environment                       287

    Functions                            288

    General                               288

    Java                                     307

    Names                                 309

    Tests                                    313

    Conclusion                         314

    Bibliography                      315

    Appendix A: Concurrency II                              317

    Client/Server Example                           317

    Possible Paths of Execution                    321

    Knowing Your Library                      326

    Dependencies Between Methods Can Break Concurrent Code         329

    Increasing Throughput                  333

    Deadlock                    335

    Testing Multithreaded Code                   339

    Tool Support for Testing Thread-Based Code                    342

    Conclusion                    342

    Tutorial: Full Code Examples                    343

    Appendix B: org.jfree.date.SerialDate                             349

    Appendix C: Cross References of Heuristics                  409


    Epilogue                           411

    Index                                  413