Adaptive code: agile coding with design patterns and solid principles

Cover
Title Page
Copyright Page
Acknowledgments
Contents
Introduction
PART I: AGILE DEVELOPMENT FRAMEWORKS
	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
Index
	A
	B
	C
	D
	E
	F
	G
	H
	I
	K
	L
	M
	N
	O
	P
	Q
	R
	S
	T
	U
	V
	W
	X
About the author
Survey