Clean Code: A Handbook of Agile Software Craftsmanship

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

Taschenbuch

Taschenbuch

34,99 €

Clean Code: A Handbook of Agile Software Craftsmanship

Ebenfalls verfügbar als:

Taschenbuch

Taschenbuch

ab 34,99 €
eBook

eBook

ab 26,99 €

34,99 €

inkl. MwSt, Versandkostenfrei

Beschreibung

Details

Verkaufsrang

5833

Einband

Taschenbuch

Erscheinungsdatum

01.08.2008

Verlag

Pearson Studium

Seitenzahl

464

Beschreibung

Details

Verkaufsrang

5833

Einband

Taschenbuch

Erscheinungsdatum

01.08.2008

Verlag

Pearson Studium

Seitenzahl

464

Maße (L/B/H)

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

Gewicht

806 g

Auflage

17th print.

Sprache

Englisch

ISBN

978-0-13-235088-4

Herstelleradresse

Pearson Education Limited
The Strand 80
WC2R 0RL London
GB
Email: buchhandel@pearson.de
Url: www.stark-verlag.de
Telephone: +49 811 600040
Fax: +49 811 60004601

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, Robert C. 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