Write code that can adapt to changes.
By applying this book's principles, you can create code that accommodates new requirements and unforeseen scenarios without significant rewrites. Gary McLean Hall describes Agile best practices, principles, and patterns for designing and writing code that can evolve more quickly and easily, with fewer errors, because it doesn't impede change.
Now revised, updated, and expanded, Adaptive Code, Second Edition adds indispensable practical insights on Kanban, dependency inversion, and creating reusable abstractions. Drawing on over a decade of Agile consulting and development experience, McLean Hall has updated his best-seller with deeper coverage of unit testing, refactoring, pure dependency injection, and more.
Master powerful new ways to:
* Write code that enables and complements Scrum, Kanban, or any other Agile framework
* Develop code that can survive major changes in requirements
* Plan for adaptability by using dependencies, layering, interfaces, and design patterns
* Perform unit testing and refactoring in tandem, gaining more value from both
* Use the "golden master" technique to make legacy code adaptive
* Build SOLID code with single-responsibility, open/closed, and Liskov substitution principles
* Create smaller interfaces to support more-diverse client and architectural needs
* Leverage dependency injection best practices to improve code adaptability
* Apply dependency inversion with the Stairway pattern, and avoid related anti-patterns
About You
This book is for programmers of all skill levels seeking more-practical insight into design patterns, SOLID principles, unit testing, refactoring, and related topics. Most readers will have programmed in C#, Java, C++, or similar object-oriented languages, and will be familiar with core procedural programming techniques.
Reihe
Auflage
Sprache
Verlagsort
Verlagsgruppe
Zielgruppe
ISBN-13
978-1-5093-0262-8 (9781509302628)
Copyright in bibliographic data and cover images is held by Nielsen Book Services Limited or by the publishers or by their respective licensors: all rights reserved.
Schweitzer Klassifikation
Gary McLean Hall is a software developer, architect, and consultant with more than a decade of experience optimizing processes and practices in diverse Agile environments. He recently founded Igirisu to provide developer training for TDD, continuous integration, refactoring, design patterns, SOLID principles, and Git source control; cultural coaching towards Agile; and related services. His book, Adaptive Code via C# (Microsoft Press, 2014), has been translated into German, Japanese, and Korean, and won the Society for Technical Communications
Distinguished Award in 2015.
TOC
Chapter 1 Introduction to Scrum
Scrum versus waterfall
Roles and responsibilities
Product owner
Scrum master
Development team
Artifacts
The Scrum board
Charts and metrics
Backlogs
The sprint
Release planning
Sprint planning
Daily Scrum
Sprint demo
Sprint retrospective
Scrum calendar
Agile in the real world
Rigidity
Untestability
Metrics
Conclusion
Chapter 2 Introduction to Kanban
Kanban quickstart
The information radiator
Limiting work in progress
Protecting against change
Defining "done"
Event-driven ceremonies
Classes of service
Service level agreements
Class WIP limits
People as a class of service
Analysis
Lead time and cycle time
Cumulative flow diagrams
Conclusion
Part II Foundations of adaptive code
Chapter 3 Dependencies and layering
Dependencies
A simple example
Framework dependencies
Third-party dependencies
Modeling dependencies in a directed graph
Managing dependencies
Implementations versus interfaces
The new code smell
Alternatives to object construction
Resolving dependencies
Dependency management with NuGet
Layering
Common layering patterns
Cross-cutting concerns
Asymmetric layering
Conclusion
Chapter 4 Interfaces and design patterns
What is an interface?
Syntax
Explicit implementation
Polymorphism
Adaptive design patterns
The Null Object pattern
The Adapter pattern
The Strategy pattern
Further versatility
Duck-typing
Mixins
Fluent interfaces
Conclusion
Chapter 5 Testing
Unit testing
Arrange, Act, Assert
Test-driven development
More complex tests
Unit-testing patterns
Writing maintainable tests
The Builder pattern for tests
The Builder pattern
Clarifying unit test intent
Writing tests first
What is TDD?
Test-driven design
Test-first development
Further testing
The testing pyramid
Testing pyramid anti-patterns
The testing quadrant
Testing for prevention and cure
How do you decrease MTTR?
Conclusion
Chapter 6 Refactoring
Introduction to refactoring
Changing existing code
A new account type
Aggressive refactoring
Red, green, refactor...redesign
Making legacy code adaptive
The golden master technique
Conclusion
Part III SOLID code
Chapter 7 The single responsibility principle
Problem statement
Refactoring for clarity
Refactoring for abstraction
SRP and the Decorator pattern
The Composite pattern
Predicate decorators
Branching decorators
Lazy decorators
Logging decorators
Profiling decorators
Decorating properties and events
Conclusion
Chapter 8 The open/closed principle
Introduction to the open/closed principle
The Meyer definition
The Martin definition
Bug fixes
Client awareness
Extension points
Code without extension points
Virtual methods
Abstract methods
Interface inheritance
"Design for inheritance or prohibit it"
Protected variation
Predicted variation
A stable interface
Just enough adaptability
Predicted variation versus speculative generality
Do you need so many interfaces?
Conclusion
Chapter 9 The Liskov substitution principle
Introduction to the Liskov substitution principle
Formal definition
LSP rules
Contracts
Preconditions
Postconditions
Data invariants
Liskov contract rules
Code contracts
Covariance and contravariance
Definitions
Liskov type system rules
Conclusion
Chapter 10 Interface segregation
A segregation example
A simple CRUD interface
Caching
Multiple interface decoration
Client construction
Multiple implementations, multiple instances
Single implementation, single instance
The Interface Soup anti-pattern
Splitting interfaces
Client need
Architectural need
Single-method interfaces
Conclusion
Chapter 11 Dependency inversion
Structuring dependencies
The Entourage anti-pattern
The Stairway pattern
An example of abstraction design
Abstractions
Concretions
Abstracting capabilities
The improved client
Abstracting queries
Further abstraction
Conclusion
Part IV Applying adaptive code
Chapter 12 Dependency injection
Humble beginnings
The Task List application
Constructing the object graph
Beyond simple injection
The Service Locator anti-pattern
Illegitimate Injection
The composition root
Convention over configuration
Conclusion
Chapter 13 Coupling, cohesion, and connascence
Coupling and cohesion
Coupling
Cohesion
Connascence
Name
Type
Meaning
Algorithm
Position
Execution order
Timing
Value
Identity
Measuring connascence
Locality
Unofficial connascence
Static vs. dynamic connascence
Conclusion
Appendix Adaptive tools
Source control with Git
Cloning a repository
Switching to a different branch
Continuous integration
