دوره Learn TDD in [Number] Days همراه با فلش‌کارت آموزشی — ارائه روی فلش مموری

🎓 دوره آموزشی جامع

📚 اطلاعات دوره

عنوان دوره: دوره Learn TDD in [Number] Days

موضوع کلی: برنامه نویسی

موضوع میانی: توسعه آزمون‌محور (TDD)

📋 سرفصل‌های دوره

• 1. Welcome to Test-Driven Development (TDD)
• 2. Understanding the Core Concept of TDD
• 3. Why Embrace TDD? Key Benefits for Developers
• 4. TDD's Impact on Software Quality and Design
• 5. Setting the Stage: Your First TDD Environment
• 6. Exploring Common TDD Misconceptions
• 7. A Brief Historical Context of TDD
• 8. TDD vs. Traditional Testing Approaches
• 9. The TDD Mindset: Shifting Your Perspective
• 10. The Red Phase: Writing Your First Failing Test
• 11. Test Runners: Executing Your Tests
• 12. Making the Test Fail Intentionally
• 13. The Test as a Specification
• 14. Introduction to Unit Testing Frameworks
• 15. Structuring Your Test Project
• 16. The Red-Green-Refactor Cycle Explained
• 17. The Green Phase: Writing Minimal Code to Pass
• 18. Ensuring Your Test Passes Correctly
• 19. The Refactor Phase: Improving Code Structure
• 20. Iterating Through the TDD Loop Effectively
• 21. The Importance of Small, Incremental Steps
• 22. Gaining Confidence with Each Passing Test
• 23. Driving Development Through Tests
• 24. When to Stop Writing Tests: Satisfying Requirements
• 25. Understanding Test Coverage Metrics
• 26. The Rhythmic Flow of TDD Practice
• 27. Visualizing the TDD Cycle: A Practical Walkthrough
• 28. Troubleshooting Failing Tests
• 29. Best Practices for Initial Test Setup
• 30. Evolving Your Codebase with TDD
• 31. Principles of Good Unit Tests: The FIRST Acronym
• 32. F - Fast Tests: Ensuring Quick Feedback
• 33. I - Independent Tests: Avoiding Side Effects
• 34. R - Repeatable Tests: Consistent Results
• 35. S - Self-Validating Tests: Clear Pass/Fail
• 36. T - Timely Tests: Writing Before Implementation
• 37. The Arrange-Act-Assert (AAA) Pattern
• 38. Effective Test Naming Conventions
• 39. Crafting Robust Assertions
• 40. Exploring Advanced Assertion Techniques
• 41. Parameterized Tests: Testing Multiple Inputs Efficiently
• 42. Handling Exceptions and Error Paths with TDD
• 43. Testing Edge Cases and Boundary Conditions
• 44. Introduction to Test Doubles: Mocks, Stubs, Fakes, Spies
• 45. Using Mocks for Behavior Verification
• 46. Employing Stubs for Controlled Responses
• 47. Fakes: Simplified Working Implementations
• 48. Spies: Observing Interactions Without Altering Behavior
• 49. Deciding When to Use Which Test Double
• 50. The Dangers of Over-Mocking and Tight Coupling
• 51. Dependency Injection for Testability
• 52. Inversion of Control Containers and TDD
• 53. Achieving Test Isolation: Techniques and Strategies
• 54. Setting Up and Tearing Down Test Fixtures
• 55. Data Builders and Object Mothers for Complex Objects
• 56. TDD for Pure Functions and Utilities
• 57. Applying TDD to Classes and Objects
• 58. Developing Services and Business Logic with TDD
• 59. Testing Data Access Layer (DAL) Components
• 60. TDD for Input Validation Logic
• 61. Building Complex Algorithms with TDD
• 62. TDD for Handling Collections and Iterators
• 63. TDD for Asynchronous Operations (Introduction)
• 64. TDD for Concurrent Code (Introduction)
• 65. Introduction to Testing User Interface (UI) Components
• 66. TDD and External System Integrations (Via Doubles)
• 67. Tackling Legacy Code with TDD: Characterization Tests
• 68. The "Sander's Sprout" Method for Safe Changes
• 69. Refactoring Towards Testability in Legacy Systems
• 70. Strategies for Database Testing in a TDD Context
• 71. The Art of Refactoring: What and Why
• 72. Refactoring as an Integral Part of TDD
• 73. Common Refactoring Techniques: Extract Method
• 74. Common Refactoring Techniques: Rename Variable/Method/Class
• 75. Common Refactoring Techniques: Extract Class/Interface
• 76. Common Refactoring Techniques: Introduce Parameter Object
• 77. Identifying Code Smells That Warrant Refactoring
• 78. Safe Refactoring Practices: Small Steps and Constant Testing
• 79. Leveraging Automated Refactoring Tools
• 80. Clean Code Principles and Their Synergy with TDD
• 81. SOLID Principle: Single Responsibility Principle (SRP)
• 82. SOLID Principle: Open/Closed Principle (OCP)
• 83. SOLID Principle: Liskov Substitution Principle (LSP)
• 84. SOLID Principle: Interface Segregation Principle (ISP)
• 85. SOLID Principle: Dependency Inversion Principle (DIP)
• 86. TDD and Design Patterns: Driving Pattern Implementation
• 87. The Test Pyramid: Structuring Your Testing Strategy
• 88. TDD's Role Within the Test Pyramid (Unit Tests)
• 89. Introduction to Behavior-Driven Development (BDD)
• 90. TDD vs. BDD: Understanding the Differences
• 91. Feature Files and Scenarios in BDD
• 92. TDD and Continuous Integration (CI) Pipelines
• 93. TDD and Continuous Delivery (CD) Benefits
• 94. Pair Programming and Mob Programming with TDD
• 95. TDD in Agile Development Methodologies
• 96. Overcoming Common Challenges and Roadblocks in TDD
• 97. Measuring the Success and ROI of TDD
• 98. Fostering a TDD Culture in Your Team
• 99. Advanced Topics and Future Directions in TDD
• 100. Course Conclusion and Next Steps for Your TDD Journey