Table of contents for Agile principles, patterns, and practices in C# / Robert C. Martin, Micah Martin.

Bibliographic record and links to related information available from the Library of Congress catalog.

Note: Contents data are machine generated based on pre-publication provided by the publisher. Contents may have variations from the printed book or be incomplete or contain other coding.


Counter
Foreword
Preface
Section I: Agile Development
Chapter 1: Agile Practices
The Agile Alliance 
Principles
Conclusion
Bibliography
Chapter 2: Overview of Extreme Programming
The Practices of Extreme Programming
Conclusion
Bibliography 
Chapter 3: Planning 
Initial Exploration
Release Planning 
Iteration Planning 
What does "Done" Mean? 
Task Planning 
Iterating
Tracking 
Conclusion
Bibliography 
Chapter 4: Testing
Test Driven Development 
Acceptance Tests
Serendipitous Architecture 
Conclusion
Bibliography 
Chapter 5: Refactoring
Generating Primes: A Simple Example of Refactoring
Conclusion
Bibliography 
Chapter 6: A Programming Episode 
The Bowling Game
Conclusion
An Overview of the Rules of Bowling
Section II: Agile Design
Chapter 7: What is Agile Design?
What Goes Wrong with Software?
The "Copy" Program
Keeping the Design as Good as It Can Be
Conclusion
Bibliography 
Chapter 8: SRP: The Single Responsibility Principle 
What Is a Responsibility?
Conclusion
Bibliography
Chapter 9: OCP: The Open Closed Principle 
Description 
Abstraction Is the Key
The Shape Application
Conclusion 
Bibliography 
Chapter 10: LSP: The Liskov Substitution Principle
A Simple Example of a Violation of LSP 
Square and Rectangle, a More Subtle Violation
A Real Example
Factoring Instead of Deriving 
Heuristics and Conventions
Conclusion 
Bibliography
Chapter 11: DIP: The Dependency Inversion Principle
Layering 
A Simple Example
The Furnace Example
Conclusion
Bibliography 
Chapter 12: ISP: The Interface Segregation Principle
Interface Pollution
Separate Clients Mean Separate Interfaces
Class Interfaces versus Object Interfaces 
The ATM User Interface Example 
Conclusion
Bibliography 
Chapter 13: Overview of UML for C# Programmers
Diagram Types 
Conclusion
Notes 
Chapter 14: Working with Diagrams
Why Model?
Making Effective Use of UML
Iterative Refinement 
Minimalism
When and How to Draw Diagrams 
Conclusion
Chapter 15: State Diagrams
The Basics 
Using FSM Diagrams 
Conclusion
Chapter 16: Object Diagrams 
A Snapshot in Time
Active Objects
Conclusion
Chapter 17: Use Cases
Writing Use Cases
Use Case Diagrams
Conclusion
Bibliography
Chapter 18: Sequence Diagrams
The Basics 
Advanced Concepts
Conclusion
Chapter 19: Class Diagrams 
The Basics
An Example Class Diagram
The Details
Conclusion
Notes
Chapter 20: Heuristics and Coffee
The Mark IV Special Coffee Maker
A Coffee Maker Solution
Overkill
Notes
Section III: The Payroll Case Study
Chapter 21: Command and Active Object
Simple Commands
Transactions
UNDO
Active Object
Conclusion
Bibliography
Chapter 22: Template Method and Strategy: Inheritance versus Delegation
Template Method
Strategy
Which One Should I Use?
Bibliography
Chapter 23: Facade and Mediator
Facade
Mediator
Conclusion 
Bibliography
Chapter 24: Singleton and Monostate
Singleton
Monostate
Conclusion
Bibliography
Chapter 25: Null Object
Conclusion
Bibliography 
Chapter 26: The Payroll Case Study: Iteration One Begins
Introduction 
Specification
Analysis by Use-Cases
Reflection: What Have We Learned? 
Finding the Underlying Abstractions
Conclusion
Bibliography 
Chapter 27: The Payroll Case Study: Implementation
Transactions 
Adding Employees
Deleting Employees 
Time Cards, Sales Receipts, and Service Charges 
Changing Employees
Paying Employees 
Main Program 
The Database 
Summary of Payroll Design 
Bibliography 
Section IV: packaging the Payroll System
Chapter 28: Principles of Package and Component Design
A Package is a Component 
Designing with Packages and Components 
Granularity: The Principles of Component Cohesion
Stability: The Principles of Component Coupling 
Top Down versus Bottom up Design
The Stable Dependencies Principle (SDP) 
The Stable Abstractions Principle (SAP)
Conclusion
Chapter 29: Factory
A Dependency Problem 
Static versus Dynamic Typing 
Substitutable Factories 
Using Factories for Test Fixtures 
How Important Is It to Use Factories?
Conclusion
Bibliography 
Chapter 30: The Payroll Case Study (Part 2) 
Component Structure and Notation 
Applying the Common Closure Principle (CCP) 
Applying the Reuse-Release Equivalency Principle (REP)
Coupling and Encapsulation 
Metrics
Applying the Metrics to the Payroll Application 
The Final Packaging Structure 
Conclusion
Bibliography 
Chapter 31: Composite 
Example: Composite Commands 
Multiplicity or not Multiplicity 
Chapter 32: Observer--Evolving into a Pattern
The Digital Clock 
The Observer Pattern 
Bibliography 
Chapter 33: Abstract Server, Adapter, and Bridge
Abstract Server 
Adapter
Bridge 
Conclusion
Bibliography 
Chapter 34: Proxy and Gateway: Managing Third Party APIs 
Proxy 
Table Data Gateway
Other Patterns That can Be Used with Databases 
Conclusion
Bibliography 
Chapter 35: Visitor 
The VISITOR Family of Design Patterns
VISITOR
Acyclic Visitor
Decorator 
Extension Object 
Conclusion
Bibliography 
Chapter 36: State 
Implementation Techniques 
The State Pattern 
SMC--The State Machine Compiler 
Where Should State Machines Be Used? 
Conclusion
Listings 
Bibliography 
Chapter 37: The Payroll Case Study: The Database
Building the Database 
A Flaw in the Code Design 
Adding an Employee 
Transactions 
Loading an Employee 
What Remains? 
Chapter 38: The Payroll UI: Model View Presenter
The Interface 
Implementation 
Building a Window
The Payroll Window 
The Unveiling
Conclusion
Bibliography 
Appendix A: A Satire of Two Companies
Appendix B: The Source Code Is the Design 
Afterword
Index

Library of Congress Subject Headings for this publication:

Object-oriented programming (Computer science).
C# (Computer program language).
Computer software -- Development.