Clean Code

Name: Clean Code | A Handbook of Agile Software Craftsmanship
Brand: Addison Wesley
Price: 58.49 EUR
Availability: OnlineOnly

A Handbook of Agile Software Craftsmanship

Robert Martin(Autor*in)

Addison Wesley (Verlag)

2. Auflage

Erschienen am 30. September 2025

E-Book

ePUB ohne DRM

Systemvoraussetzungen

978-0-13-539854-8 (ISBN)

58,49 €inkl. 7% MwSt.

Systemvoraussetzungen

für ePUB ohne DRM

E-Book Einzellizenz

Als Download verfügbar

Beschreibung

Bestselling author Robert C. Martin brings new life and updated code to his beloved Clean Code book

With Clean Code, Second Edition, Robert C. Martin ("Uncle Bob") reinvigorates the classic guide to software craftsmanship with updated insights, broader scope, and enriched content. This new edition--a comprehensive rewrite of the original bestseller--is poised to transform the way developers approach coding, fostering a deeper commitment to the craft of writing clean, flexible, and maintainable code.

The book is divided into four parts: basic coding practices, design principles and heuristics, high-level architecture, and the ethics of craftsmanship. It challenges readers to critically evaluate code quality and reassess their professional values, ultimately guiding them to produce better software. This edition includes expanded coverage of testing disciplines, design and architecture principles, and multiple programming languages.

Design and architecture principles integrated with coding practices
Coverage of more languages, including Java, JavaScript, Go, Python, Clojure, C#, and C
Case studies for practical exercises in code transformation
Techniques for writing good names, functions, objects, and classes
Strategies for formatting code for maximum readability
Comprehensive error handling and testing practices
Productive use of AI tools for coding
Soft skills and the ethics of programming
SOLID principles of software design
Management of dependencies for flexible and reusable code
Professional practices and trade-offs in object-oriented design

Clean Code, Second Edition, underscores the importance of evolving software craftsmanship to meet contemporary challenges. Offering a deeper exploration of testing, design, and architecture, alongside universal coding principles applicable across various programming languages, this edition is set to be an indispensable resource for developers, engineers, and project managers. It not only aims to enhance technical skills but also to cultivate a professional ethos that values clean, flexible, and sustainable code.

Register your book for convenient access to downloads, updates, and/or corrections as they become available. See inside book for details.

Rezensionen / Stimmen

Praise for the First Edition of Clean Code

"Clean Code has changed the way I develop and maintain software in so many ways. It defines so well how code should be written, and I have not only learnt much from this book but have also put into practice many of its gems. I can honestly say that having gone on this journey, it is once again a pleasure to develop software and look at code that you are proud to have written."
--Steve Roberts, head of IT

"Reading Clean Code validated my inner sense of how software should be written, while also improving the quality of my work by teaching me things I didn't know. I'm grateful for this book and others by the same author as they remain fundamental prerequisites, even in the age of AI."
--Milos Baic, developer and solution architect

"[Clean Code] was the single most influential thing that I encountered in my career. Provided I was in a team that adhered to it, it took a lot of stress away as the code was suddenly more understandable and thus easier to maintain. To design something with testability in mind eliminated a lot of complexity in design and maintenance. Above all, it made programming feel cozy and fun again. The feeling gets stronger when you move from poor to a cleaner code base."
--Zarko Stojanovic, staff software engineer

Weitere Details

Weitere Ausgaben

Person

Inhalt

Foreword xix
Introduction xxv
Introduction (from Long Ago) xxix
About the Author xxxi

Chapter 1: Clean Code 1
There Will Be Code 2
Bad Code 3
The Art of Clean Code 5
Putting All This Together 9
We Read More Than We Write 13
The Boy Scout Rule 14

Part I: Code 17

Chapter 2: Clean That Code! 19
The Cleaning Process 30
Conclusion 37
Postscript: Future Bob Playing with Grok3 37
Postscript Conclusion 40

Chapter 3: First Principles 41
Everything Small, Well Named, Organized, and Ordered 42
A More Significant Example 44
A Final Thought 68

Chapter 4: Meaningful Names 71
Use Intention-Revealing Names 72
Final Words 87

Chapter 5: Comments 89
Compensating for Failure 90
Good Comments 92
Bad Comments 97
Conclusion 115

Chapter 6: Formatting 117
The Purpose of Formatting 118
Vertical Formatting 118
Horizontal Formatting 127
Team Rules 132
Uncle Bob's Formatting Rules 133

Chapter 7: Clean Functions 137
Small! 138
Reading Code from Top to Bottom: The Stepdown Rule 140
Switch Statements 142
Clean Functions: A Deeper Look 144
Conclusion 157

Chapter 8: Function Heuristics 159
Function Arguments 159
Command Query Separation 164
Prefer Exceptions to Returning Error Codes 165
DRY: Don't Repeat Yourself 169
Side Effects 177
Structured Programming 181
This Is Too Much to Constantly Keep in Mind 183
Conclusion 184

Chapter 9: The Clean Method 185
Make It Right 186
Example 188
Conclusion 210

Chapter 10: One Thing 211
Extract Method Refactoring 212
What Are Large Functions Anyway? 217
Conclusion 239

Chapter 11: Be Polite 241
The Newspaper Metaphor 243
The Stepdown Rule: Once Again 245
The Abstraction Roller Coaster 246
This Is How We Write, but Not How We Want to Read 246

Chapter 12: Objects and Data Structures 249
What Is an Object? 250
Data Abstraction 251
Data/Object Antisymmetry 252
The Law of Demeter 255
Data Transfer Objects 258
Switch Statements 260
The OO/Procedural Trade-off 264
But What About Performance? 265
Conclusion 265

Chapter 13: Clean Classes 267
Classes and Modules versus Files 267
What Should a Class Contain? 268

Chapter 14: Testing Disciplines 289
Discipline 1: Test-Driven Development (TDD) 291
Discipline 2: Test && Commit || Revert (TCR) 292
Discipline 3: Small Bundles 293
Design 293
Discipline 294
Keeping Tests Clean 299
Tests Enable the -ilities 300

Chapter 15: Clean Tests 303
Domain-Specific Testing Language 307
F.I.R.S.T. 310
Test Design 311
Conclusion 311

Chapter 16: Acceptance Testing 313
The Acceptance Testing Discipline 314
Conclusion 316

Chapter 17: AIs, LLMs, and God Knows What 317
Programming by Prompt 319
Conclusion 328

Part II: Design 329

Chapter 18: Simple Design 331
YAGNI 333
Covered by Tests 333
Maximize Expression 334
Minimize Duplication 337

Chapter 19: The SOLID Principles 341
SRP: The Single Responsibility Principle 343
OCP: The Open-Closed Principle 347
LSP: The Liskov Substitution Principle 351
ISP: The Interface Segregation Principle 354
DIP: The Dependency Inversion Principle 356

Chapter 20: Component Principles 363
Components 364
A Brief History of Components 364
Component Cohesion 368
Component Coupling 373
Conclusion 387

Chapter 21: Continuous Design 389
Continuous Change 390
Continuous Design 391
Sailing on the Four Cs of Continuous Design 392
When Else Do We Design? 420

Chapter 22: Concurrency 423
Why Concurrency? 424
Concurrency Defense Principles 427
2025 Update and Report from the Field 437
Conclusion 442

Part III: Architecture 443

Chapter 23: The Two Values of Software 445
Keeping Options Open 446

Chapter 24: Independence 449
Use Cases 450
Operation 450
Development 451
Deployment 451
Leaving Options Open 451

Chapter 25: Architectural Boundaries 453
What Lines Do You Draw, and When? 454
Plug-in Architecture 456
Case Study: FitNesse 457
Conclusion 459

Chapter 26: Clean Boundaries 461
Third-Party IoT Framework: Lots o' Boundaries 462
UI/Application Boundary 466
Clean Boundaries 474

Chapter 27: The Clean Architecture 475
The Dependency Rule 476
Conclusion 481

Part IV: Craftmanship 483
"A Great Number" 484
Eight Decades 484
The Oath 492

Chapter 28: Harm 495
No Harm to Society 496
Harm to Function 497
No Harm to Structure 499
Soft 500
Tests 501

Chapter 29: No Defect in Behavior or Structure 503
Making It Right 504
Programmers Are Stakeholders 507
Do Your Best 508

Chapter 30: Repeatable Proof 511
Dijkstra 511
Structured Programming 514
Functional Decomposition 516
Test-Driven Development et al. 517

Chapter 31: Small Cycles 519
The History of Source Code Control 519
Continuous Integration 524
Branches versus Toggles 525
Continuous Deployment 527
Continuous Build 528

Chapter 32: Relentless Improvement 529
Test Coverage 529
Mutation Testing 530
Semantic Stability 530
Cleaning 531
Creations 531

Chapter 33: Maintain High Productivity 533
Viscosity 533
Managing Distractions 535
Time Management 538

Chapter 34: Work as a Team 539
Collaborative Programming 539
Open/Virtual Office 540

Chapter 35: Estimate Honestly and Fairly 543
Lies 544
Honesty, Accuracy, Precision 544
Lessons from Me 545
Accuracy and Precision 547
Aggregation 548
Honesty 549
Pressure 550

Chapter 36: Respect for Fellow Programmers 553

Chapter 37: Never Stop Learning 555

Afterword 557

Appendix: The Clean Code Debate 561
Introductions 562
Method Length 563
Method Length Summary 575
Comments 576
Comments Summary 590
John's Rewrite of PrimeGenerator 591
A Tale of Two Programmers 596
Bob's Rewrite of PrimeGenerator2 599
Test-Driven Development 603
TDD Summary 612
Closing Remarks 613

Bibliography 615
Index 619

Systemvoraussetzungen

Als PDF speichern Als Link merken