1. Static Code Analysis Tools
1.1. Find Bugs Report
1.2. Cyclomatic Complexity
2. Database Refactoring
2.1. testing databases
2.2. abstracting away from dbms
3. customer satisfaction
3.1. split testing
4. Bugs
5. Relational vs Hierarchical Thinking
6. Performance / Response Time
7. Non-functional requirements
7.1. Load / Capacity
7.2. Robustness / Long Duration
8. Critiquing the Product
8.1. Test Harness for Legacy Code
8.1.1. test seams
8.1.2. dependency breaking
8.1.3. sprouts and strangling
9. easy to use/learn
9.1. simple
9.2. functional completeness
9.3. overall coherence
9.3.1. Evolutionary Design
10. Domain-Driven Design
11. Persistent
12. JDUF-just enough design up front
13. Code Smells
13.1. Don't Repeat Yourself
13.2. Law of Demeter (Tell Don't Ask)
13.3. Metrics
13.3.1. Test Coverage
13.3.2. Lines of Code (sphags)
14. Collaboration
14.1. Sufficient communication
14.2. Frequent
15. Business Value
15.1. validating
15.1.1. Release Management
15.1.1.1. Flow
15.1.1.2. Stories
15.1.1.2.1. Story Estimation
15.1.1.2.2. Story Splitting
15.1.1.2.3. Story Writing
15.1.1.3. Delivering In Small Slices
15.1.1.3.1. Incremental
15.1.1.3.2. Iterative
15.1.1.4. Product Backlog
15.1.1.4.1. Sprint Backlog
15.1.1.5. frequent delivery
15.1.1.6. Basic Throughput Accounting
15.1.1.6.1. Cadence
15.1.1.6.2. Limiting Work in Progress
15.1.1.6.3. Optimize the whole
15.1.1.6.4. Value Stream Mapping
15.1.1.7. Kanban
15.1.2. Time management
15.1.2.1. Pomodoro
15.1.2.2. Getting Things Done
15.1.2.3. Timeboxes
15.2. avoiding waste (muda)
15.2.1. Extra features
15.2.2. Heavy specs
15.2.3. Handoffs
15.2.4. Waiting
15.2.5. Multi-step analyze-dev-test-verify...
15.2.6. Re-creating knowledge
16. Supportive Culture
16.1. Conflict management
16.1.1. diagnosis
16.1.1.1. dissapointment
16.1.1.2. friction
16.1.1.3. disconnect
16.1.1.4. disagreement
16.1.2. productive discussion
16.1.2.1. Consent-based decision making
16.1.2.2. Knowledge vs Information
16.1.2.3. Facilitation
16.2. respect
16.2.1. Craftsmanship Manifesto
16.2.2. Declaration of Interdependence
16.2.3. Agile Manifesto
16.2.4. growing trust
16.2.5. individuals and interactions over processes and tools
16.2.6. give teams what they need & trust them to get the job done
16.3. commitment
16.3.1. Nudging for Improvement
16.3.1.1. Jiggling (Change Agent)
16.3.2. Patrick Lencioni’s Five Dysfunctions of a team
16.3.2.1. Absence of Trust
16.3.2.2. Fear of Conflict
16.3.2.3. Lack of Commitment
16.3.2.4. Avoidance of Accountability
16.3.2.5. Inattention to Results
16.3.3. help
16.3.3.1. Knowing when you're blocked
16.3.3.2. Ask first, conclude later
16.3.3.3. Active Listening
16.3.3.4. Mentoring
16.3.3.5. Helping
16.3.4. whole team attitude
16.3.4.1. Cross-functional teams
16.3.4.2. generalizing specialists
16.3.4.3. product focus
16.3.4.4. responsibility
16.3.4.5. autonomy
16.3.5. permanent team attitude
16.3.5.1. improves productivity
16.3.5.2. enhances commitment
16.3.5.3. shared history
16.4. Space to learn
16.4.1. slack
16.4.2. accepting failure
16.4.3. sustainable pace
16.4.4. risk taking
17. Technical Excellence
17.1. Simple Design
17.1.1. KISS - Keep it simple, stupid!
17.1.1.1. Architecture--simplest thing that could possibly work
17.1.1.2. One level of abstraction
17.1.2. Design Patterns
17.1.2.1. Evolutionary Iterative Development
17.1.2.2. Emergent Design
17.1.2.2.1. Refactoring to Framework
17.1.2.2.2. Avoid Speculative Generality
17.1.2.3. MVP / MVC Patterns
17.1.2.4. Separation of Concerns
17.1.2.5. FCoI - Favour Composition over Inheritance
17.1.2.6. Modeling
17.1.2.6.1. CRC (class responsibility collaborator) cards
17.1.2.6.2. UML diagrams
17.1.2.6.3. whiteboard discussions
17.1.3. Craftsmanship
17.1.3.1. Clean Code
17.1.3.2. Boy Scout Rule
17.1.3.3. Source Code Conventions
17.2. Refactoring
17.2.1. SOLID
17.2.1.1. Single Responsibility Principle
17.2.1.1.1. Coding by Intention
17.2.1.2. Open Closed Principle
17.2.1.3. Liskov Substitution Principle
17.2.1.4. Interface Segregation Principle
17.2.1.5. Dependency Inversion Principle
17.2.2. Common Refactorings
17.2.2.1. Compose Method
17.2.2.2. Extract Method
17.2.2.3. Inline Method
17.2.2.4. Rename
17.2.3. Test Refactoring
17.2.4. Modular Design
17.3. Testing
17.3.1. developer tests
17.3.1.1. Unit Testing
17.3.1.1.1. xUnit
17.3.1.2. Design-for-Testability
17.3.2. test-first
17.3.2.1. Test-Driven Development
17.3.2.1.1. TDD Cycle - Red, Green, Refactor
17.3.2.1.2. Which test next?
17.3.2.1.3. TDD with GUIs
17.3.2.2. Tests Used for Design
17.3.2.3. Behavior-Driven Development
17.3.2.3.1. StoryTest-Driven Development
17.3.3. customer tests
17.3.3.1. Acceptance Testing
17.3.3.2. Exploratory Testing
17.3.3.3. Testing Quadrants
17.3.3.3.1. Supporting Programming
17.3.3.3.2. Robustness / Fault Tolerance
17.3.3.3.3. Technology Facing
17.3.3.3.4. Business Facing
17.3.4. Test Automation
17.3.4.1. Test Automation Patterns
17.3.4.1.1. Test Doubles
17.3.4.1.2. 3A Pattern: Arrange, Act, Assert
18. Self Improvement
18.1. intentional practice
18.1.1. book discussions
18.1.2. online communities
18.1.3. Reading
18.1.4. Code Kata
18.1.5. local user groups
18.1.6. open source projects
18.1.7. conferences
18.2. retroflection
18.2.1. Daily self reflection
18.2.2. Self Management
18.2.3. Common Pitfalls
18.2.4. Self Awareness
18.3. balance
18.3.1. Keeping Motivated
18.3.1.1. autonomy
18.3.1.2. mastery
18.3.1.3. purpose
18.3.2. work/ health/ friends
18.3.3. social captial (networking)
18.3.4. slack
19. Product
19.1. vision
19.1.1. clear problem domain
19.1.1.1. Visualization and Presentation Techniques
19.1.1.2. Wireframe/Paper Prototyping
19.1.1.3. working directly with whole team
19.1.2. explicit goals
19.1.2.1. managed scope
19.1.3. measured progress
19.1.3.1. success metrics
19.1.3.2. split testing
19.2. solves real/valuable problems
20. Confidence
20.1. Definition of Done
20.1.1. working software
20.1.2. validated learning
20.1.3. High Quality
20.1.3.1. Zero Bugs
20.2. Visibility
20.2.1. Storyboard
20.2.2. Informative Build
20.2.3. Burn-up/down charts
20.2.4. transparency
20.2.4.1. open decision making
20.2.4.2. continuous improvement
20.2.4.2.1. Plan Do Check Act
20.2.5. Reliable Cadence
20.2.6. Using Version Control
20.2.6.1. Distributed
20.2.6.2. Optimistic vs Pessimistic Locking
20.2.6.3. branching
20.2.7. Continuous Integration (CI)
20.2.7.1. CI Tools
20.2.7.2. automated deployment
20.2.7.3. automated build
20.2.7.3.1. ten-minute build
20.2.7.4. automated deployment
20.2.7.5. frequent check-in