Agile Technical Practices Distilled: A learning journey in technical practices and principles of software design

Cover
FM
Copyright
Table of Contents
Preface
First Steps
Chapter 1: Pair Programming
	What is Pair Programming?
	Roles
	Driver/Navigator Switch Techniques
		Chess Clock
		Ping Pong/Popcorn
	Breaks
		Pomodoro
	Katas
	When Should I Move to the Next Lesson?
	Resources
		Web
Chapter 2: Classic TDD I – Test-Driven Development
	Classic TDD
	The Three Laws of TDD
		1. You Are Not Allowed to Write Any More of a Unit Test That Is Sufficient to Fail, and Compilation Failures Are Failures
		2. You Are Not Allowed to Write Any Production Code Unless It Is to Make a Failing Unit Test Pass
		3. You Are Not Allowed to Write Any More Production Code That Is Sufficient to Pass the One Failing Unit Test
	Refactoring and the Rule of Three – Baby Steps
	Three Methods of Moving Forward in TDD
		From Red to Green
	Degrees of Freedom
	Naming Tests
	A Test Name Pattern
	Katas
		Fizz Buzz by cyber-dojo
		Fizz Buzz Kata Summary
	More Katas
		Leap Year by cyber-dojo
		Nth Fibonacci by cyber-dojo
	Great Habits
		Considerations when Writing a New Test
		Considerations When Making a Failing Test Pass
		Considerations After the Test Passes
	Classic TDD Flow
	Where are We in the Big Picture of Object-Oriented (OO) Software Design?
	When Should I Move to the Next Lesson?
	Resources
		Web
		Books
Chapter 3: Classic TDD II
	Writing the Assertion First and Working Backward
	Organizing Your Test in Arrange, Act, and Assert Blocks
		Benefits of Organizing Tests in Arrange, Act, and Assert Blocks
	Unit Test Principles
	Katas
		Stats Calculator by cyber-dojo
		Anagrams by cyber-dojo
	Great Habits
		Considerations when Writing a New Test
		Considerations when Making a Failing Test Pass
		Considerations after the Test Passes
	Classic TDD Flow
	Where are we in the Big Picture of Object-Oriented (OO) Software Design?
	When Should I Move to the Next Lesson?
	Resources
		Web
		Books
Chapter 4: Classic TDD III – Transformation Priority Premise
	Kata
		Roman Numerals by cyber-dojo
	TPP – Defining Obvious Implementation
		TPP Table
		The Transformations
		Transformation 1 – {} -> Nil
		Transformation 2 – Nil -> Constant
		Transformation 3 – Constant -> Constant+
		Transformation 4 – Constant -> Scalar
		Transformation 5 – Statement -> Statements
		Transformation 6 – Unconditional -> Conditional
		Transformation 7 – Scalar -> Array
		Transformation 8 – Array -> Container
		Transformation 9 – Statement -> Tail Recursion
		Transformation 10 – If -> Loop
		Transformation 11 – Statement -> Recursion
		Transformation 12 – Expression -> Function
		Transformation 13 – Variable -> Mutation
		Example Using the TPP on the Fibonacci Sequence
	Katas
		Roman Numerals by cyber-dojo
		Prime Factors by cyber-dojo
		Boolean Calculator by Alessandro Di Gioia
	Great Habits
		Considerations when Writing a New Test
		Considerations when Making a Failing Test Pass
		Considerations after the Test Passes
	Classic TDD flow
	Where are We in the Big Picture of Object-Oriented (OO) Software Design?
	When Should I Move to the Next Lesson?
	Resources
		Web
Chapter 5: Design 1 – Object Calisthenics
	It's the Design...
	Kata
		Tic-Tac-Toe
	Object Calisthenics – 10 Steps to Better Software Design
		Only One Level of Indentation per Method
		Don't Use the ELSE Keyword
		Wrap All Primitives and Strings
		First-Class Collections
		No Getters/Setters/Properties
		Wrap All Primitives and Strings
		One Dot per Line
		Don't Abbreviate
		Keep All Entities Small
		No Classes with More Than Two Instance Variables
		All Classes Must Have State
	Heuristics
	Katas
		Tic-Tac-Toe
		Game of Life
	Great Habits
		Considerations When Writing a New Test
		Considerations When Making a Failing Test Pass
		Considerations after the Test Passes
	Classic TDD flow
	Where Are We in the Big Picture of OO Software Design?
	When Should I Move on to the Next Lesson?
	Resources
		Web
Walking
Chapter 6: Design 2 – Refactoring
	When to Refactor (For Now)
	Main Refactors
	IDE Agility (Know Your Shortcuts)
	Kata
		Refactoring Golf
	Refactor 80-20 Rule
	Refactoring Guidelines
		Stay in the Green While Refactoring
		Commit as Often as Possible
		Refactor Readability before Design
		Change Design (Simple Changes)
	Kata
		Tennis Refactoring by Emily Bache
	Parallel Change (Or Expand, Migrate, and Contract)
		Expand
		Migrate
		Contract
	Kata
		Parallel Change Kata by Pawel Duda and Carlos Blé
	Great Habits
		Considerations When Writing a New Test
		Considerations When Making a Failing Test Pass
		Considerations after the Test Passes
	When Should I Move on to the Next Lesson?
	Resources
		Web
		Books
Chapter 7: Design 3 – Code Smells
	Design Smells
	Code Smells
		Bloaters
		Couplers
		Object-Orientation Abusers
		Change Preventers
		Dispensables
	Highlighted Code Smells
		Code Smells Hierarchy
		Primitive Obsession
		Feature Envy
		Message Chains
	Object Calisthenics Preventing Code Smells
	When to Refactor (Extended for Code Smells)
	Refactor Code Smells
	Kata
		Smelly Tic-Tac-Toe
	Great Habits
		Considerations When Writing a New Test
		Considerations When Making a Failing Test Pass
		Considerations After the Test Passes
	Classic TDD Flow
	The Big Picture
	When Should I Move on to the Next Lesson?
	Resources
		Web
		Books
Chapter 8: Test Doubles
	Principles
		Command-Query Separation
		Queries
		Commands
	Different Types of Test Doubles
		Dummy Objects
		Stubs
		Fake Objects
		Mocks
		Spies
	Test Doubles Guidelines
		Only Use Test Doubles for Classes That You Own
		Verify as Little as Possible in a Test
		Don't Use Test Doubles for Isolated Objects
		Don't Add Behavior in Test Doubles
		Only Use Test Doubles for Your Immediate Neighbors
		Too Many Test Doubles
		CQS Principle Trade-OffS
	Katas
		Character Copier by Urs Enzler
		Instrument Processor by Urs Enzler
	Great Habits
		Considerations When Writing a New Test
		Considerations When Making a Failing Test Pass
		Considerations after the Test Passes
	When Should I Move on to the Next Lesson?
	Resources
		Web
		Books
Chapter 9: Testing Legacy Code
	Breaking Dependencies Using a Seam
		Using Inheritance to Decouple Production Code
	Characterization Tests
	Kata
		Characterization Tests on Gilded Rose Kata by Emily Bache
	Golden Master
		Feasibility
		Generate Input/Output (Golden Master)
		Assert
	Kata
		Golden Master on Gilded Rose Kata by Emily Bache
	Approval Tests by Llewellyn Falco
		Combination Tests
	Revisiting the Refactoring Guidelines
		Stay in the Green while Refactoring
	Kata
		Gilded Rose Refactoring Kata by Emily Bache
	Conclusions
		Guideline Questions
	Great Habits
		Considerations when Writing a New Test
		Considerations when Making a Failing Test Pass
		Considerations after the Test Passes
	When Should I Move to the Next Lesson?
	Resources
		Web
		Books
Chapter 10: Design IV –Design Patterns
	Design Pattern Advantages
	Design Pattern Pitfalls
	A Quick Reference Catalogue
		Creational Design Patterns
		Behavioral Design Patterns
		Structural Design Patterns
	Revisiting the Refactoring Guidelines
		Refactoring Design
	Kata
		Refactoring Game of Life Kata to Patterns
	Great Habits
		Considerations When Writing a New Test
		Considerations When Making a Failing Test Pass
		Considerations After the Test Passes
	When Should I Move to the Next Lesson?
	Resources
		Web
		Books
Running
Chapter 11: Design V – Cohesion and Coupling
	Coupling
		Types of Coupling
		Interaction Coupling
		Law of Demeter
		Method Coupling Premises
		Inheritance Coupling
	Cohesion
		Other Indicators of Possible Low Cohesion in Design
		Types of Cohesion
		Class Cohesion
		Method Cohesion
	Katas
		Connecting Code Smells with Cohesion/Coupling
		Connecting Object Calisthenics with Code Smells and Cohesion/Coupling
	When to Refactor (Extended for Cohesion/Coupling)
	Classic TDD Flow
	The Big Picture
	When Should I Move to the Next Lesson?
	Resources
		Web
		Books
Chapter 12: Design VI – Solid Principles ++
	Single Responsibility Principle
	Open/Closed Principle
	Liskov Substitution Principle
	Interface Segregation Principle
	Dependency Inversion Principle
	Balanced Abstraction Principle
	Principle of Least Astonishment
	Kata
		Connecting Cohesion/Coupling and SOLID principles
	When to Refactor (Extended for SOLID Principles)
	Classic TDD Flow
	The Big Picture
	When Should I Move to the Next Lesson?
	Resources
		Web
		Books
Chapter 13: Design VII – Connascence
	Definition
	Dimensions
		Degree
		Locality
		Strength
	Connascence of Name and Type (CoN and CoT)
	Connascence of Position
	Connascence of Value (CoV)
	Connascence of Meaning
	Connascence of Algorithm
	Connascence of Execution Order
	Connascence of Timing
	Connascence of Identity
	Connascence of Manual Task
	Classic TDD Flow
	The Big Picture
	When Should I Move to the Next Lesson?
	Resources
		Web
		Books
Chapter 14: Design VIII –The Four Elementsof Simple Design
	What Are the Four Elements of Simple Design?
	What Does Each Element Mean?
		Passes Its Tests
		Minimizes Duplication
		Maximizes Clarity
		Has Fewer Elements
	Alternative Definitions of Simple Design
		Definition #1
		Definition #2
		Definition #3
		Definition #4
		Definition #5
		Definition #6
	Our Personal Definitions of Simple Design
		Pedro
		Marco
		Alessandro
	Kata
		Elevator Kata by Marco Consolaro
	Classic TDD Flow
	The Big Picture
	When Should I Move to the Next Lesson?
	Resources
		Web
		Books
Chapter 15: Conclusion
	Cohesion and Coupling as Forces
	The 3 Cs of Design: From Cohesion and Coupling to Connascence
	Systems Entropy
		The Relevance of Systems Entropy
		Software Development as System Building
		Good Design as a Low-Entropy System
	The Big Picture
	Resources
		Web-based resources:
		Books:
Flying
Chapter 16: Outside-In Development
	The Classic TDD Approach
	Acceptance Tests
		Acceptance Test Styles
	Test Boundaries
	Double Loop TDD
	The Outside-In Approach
		An Outside-In Mindset
	Outside-In TDD: The London School
		Example
	The Direction of Dependencies
	Should I Use Classic TDD or Outside-In TDD?
	Kata
		Stock Portfolio
		Katacombs of Shoreditch by Marco Consolaro
		Part I
		PART II
	The Big Picture
	Great Habits
		Considerations When Writing a New Test
		Considerations When Making a Failing Test Pass
		Considerations After the Test Has Passed
	Resources
		Web-based resources:
		Books:
Chapter 17: Behavior-Driven Development
	Poka-Yoke
	Mistakes versus Defects: Feedback Is the Cure (Again)
	Bugs and Communication
		User Stories
	Behavior-Driven Development
		The Structure of a Story
		Acceptance Criteria: It's All about the Examples
		From Criteria to Acceptance Tests
	Acceptance Tests Done Right
		Readable by Business Folks
		Feature Complete
		Fast
	Boundaries
	The Walking Skeleton
	Kata
		The Messy Delivery Office Requirements
	Resources
		Web-based resources
		Books
Chapter 18: Understand the Business
	Knowledge versus Understanding
	Theory of Constraints
	Domain-Driven Design: What Domain?
	Beyond Requirements: Knowledge Crunching
		5 Whys
		Impact Mapping
		PopcornFlow
		User Story Mapping
		EventStorming
		Business Model Canvas
	Value Streams and Domain Events
	Bounded Contexts and Communication
		Synchronous versus Asynchronous
		Command-Query Separation
	Business and DevOps
		The First Way
		The Second Way
		The Third Way
	Systems Thinking and Sociotechnical Organizations
	Resources
		Web-based resources
		Books
Chapter 19: Story of Team C
	Terraforming
	Team Building
	The Backlog: Crunching Knowledge for Breakfast
	Cracking On
	From Forming to Performing
	Outside-In ATDD with Optional Unit Tests
	The Green Flag
	The Moral of the Story
Chapter 20: Conclusion
	The Human Factor
	Team Play
	Bounded Rationality and Knowledge Sharing
	Resources
		Web
		Books
Chapter 21: The 12 Agile Principles
Chapter 22: PopcornFlow by Claudio Perrone
	The 7-Steps Decision Cycle
	The Principles
	Who Can Benefit from PopcornFlow
	Resources
		Web-based resources:
		Books:
Chapter 23: EventStorming by Alberto Brandolini
	Silos and Value Streams
	The Importance of Learning
	The EventStorming Approach
	The Workshop: A Quick Overview
	Different Flavors of EventStorming
	Complex Systems and Proven Solutions
	Resources
		Web
		Books
License: CyberDojo
	About CyberDojo Foundation Exercises
		Web Resources
Sample Solutions
	Sample Solutions: FizzBuzz in Clojure
		Sample Solutions: Fibonacci Sequence in C++
		Sample Solutions: Roman Numerals in C#
		Sample Solutions: Tic-Tac-Toe in Swift (Partial Solution)
		Sample Solutions: Connecting Code Smells with Cohesion/Coupling
		Sample Solutions: Connecting Object Calisthenics with Code Smells and Cohesion/Coupling
		Sample Solutions: Connecting Cohesion/Coupling and SOLID Principles
Feedback
	Personalized Coaching
		Individuals
		Organizations
	Feedback Please
Index