Over McLean Hall, Gary
Gary McLean Hall is a senior software developer who focuses on producing agile software for a leading investment-management firm.
McLean Hall, Gary
Gary McLean Hall is a senior software developer who focuses on producing agile software for a leading investment-management firm.
Meer over McLean Hall, Gary
McLean Hall, Gary
Adaptive Code: Agile coding with design patterns and SOLID principles
Paperback Engels 2017 2e druk 9781509302581Levertijd ± 9 werkdagen
Gratis verzonden
Past door de brievenbus
Samenvatting
By applying the principles in 'Adaptive Code, Second Edition', you can create code that adapts to new requirements and unforeseen scenarios without significant rework. 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. This concise, undogmatic book bridges theory and practice, demonstrating its principles and patterns with working C# code examples.
Hall helps you:
- Organize and manage architectural dependencies
- Leverage best practice patterns -- and avoid anti-patterns
- Apply SOLID principles: single-responsibility, open/closed, Liskov substitution
- Manage interface versatility
- Perform unit testing and refactoring in tandem
- See how delegation and abstraction impact code adaptability
- Learn better ways to implement dependency interjection
- And much more
Expanded and updated, this Second Edition adds new coverage of Kanban for BAU, Domain-Driven Design, Hexagonal Architecture, Test-Driven Development, and Test-First methodology. Hall also deepens and updates his discussions of unit testing, refactoring, and Pure Dependency Injection.
Specificaties
ISBN13:9781509302581
Trefwoorden:Programmeren, C#, Programmeertalen, Adaptive Code
Taal:Engels
Bindwijze:paperback
Aantal pagina's:448
Uitgever:Microsoft Press
Druk:2
Verschijningsdatum:20-4-2017
Hoofdrubriek:IT-management / ICT
Lezersrecensies
Wees de eerste die een lezersrecensie schrijft!
Inhoudsopgave
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?
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
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
Afgekapt op 60 regels
Rubrieken
- advisering
- algemeen management
- coaching en trainen
- communicatie en media
- economie
- financieel management
- inkoop en logistiek
- internet en social media
- it-management / ict
- juridisch
- leiderschap
- marketing
- mens en maatschappij
- non-profit
- ondernemen
- organisatiekunde
- personal finance
- personeelsmanagement
- persoonlijke effectiviteit
- projectmanagement
- psychologie
- reclame en verkoop
- strategisch management
- verandermanagement
- werk en loopbaan