emilybache/GildedRose-Refactoring-Kata

Features

• Refactoring Skill Practice - Provides intentionally messy codebases for developers to practice incremental design and software restructuring.
• Refactoring Exercises - Provides a set of intentionally messy codebases for practicing incremental design and test-driven refactoring.
• Code Katas - Collections of intentionally messy codebases used as exercises for practicing design, testing, and refactoring.
• Item Aging Simulations - Simulates the aging of stock items to verify the accuracy of quality and sell-in degradation logic.
• Inventory Management - Simulates inventory management by updating expiration dates and quality values based on specific business rules.
• Degradation Simulations - Tracks inventory degradation by updating quality and sell-in values daily based on product expiration rules.
• Code Refactoring Tools - Provides intentionally messy codebases for practicing the restructuring and modernization of source code.
• Educational Exercises - Offers a set of intentionally messy codebases for practicing legacy code modernization and software restructuring.
• Refactoring Utilities - Offers targeted exercises for performing safe, incremental code transformations on legacy logic.
• Software Design Principles - Combines code samples and diagrams to teach fundamental architectural philosophies and refactoring patterns.
• Language Agnostic Learning - Provides a language-agnostic learning baseline by implementing the same business rules across multiple programming languages.
• Multi-Language Implementations - Provides a language-agnostic learning baseline by implementing the same business rules across multiple programming languages.
• TDD Training Materials - Provides a baseline implementation specifically designed for hands-on practice with TDD, regression, and approval tests.
• Item Quality Logic - Implements business rules for adjusting product quality and sell-in dates based on expiration speeds and caps.
• Practice Implementations - Provides baseline implementations of complex business logic for practicing incremental design and test creation.
• Multi-Language Code Collections - Provides identical business rule implementations across multiple programming languages as a universal learning baseline.
• Application Logic Implementations - Implements core business logic for inventory management as a baseline for refactoring practice.
• Code Modernization Guides - Provides a framework for practicing the safe transformation of legacy business rules into modern structures.
• Incremental Refactoring Practices - Implements a structured approach to evolving a flawed codebase through safe, small, test-driven changes.
• Software Development Education - Serves as a resource for teaching software engineering practices through the transformation of legacy code.
• Approval Testing - Implements approval testing by comparing system outputs against golden master files to ensure functional parity during refactoring.
• Behavioral Parity Verifiers - Uses comprehensive test suites to ensure functional parity is maintained while evolving the source code.
• Golden Master Testing - Implements golden master testing to detect behavioral regressions by comparing program output against reference files.
• Regression Testing Suites - Provides a framework for creating regression tests to ensure new changes do not break existing business logic.
• Test-Driven Development Resources - Provides a pedagogical environment for learning TDD by writing failing tests before implementing complex logic.
• Refactoring Diagrams - Uses activity diagrams to teach continuous refactoring concepts to non-programmers and analysts.
• State-Based Logic Simulations - Implements a simulation to process business days and track the degradation of item quality and sell-in values.
• Automated Test Execution - Ships automated test execution to verify software functionality during the refactoring process.
• Refactoring Loops - Provides a framework for iteratively applying small design changes verified by continuous test execution.
• Logic State Simulations - Implements simulations that track data structure transitions of item quality over discrete business days for educational purposes.
• Workshop Formats - Provides structured workshop formats using cases and diagrams to lead groups through incremental design exercises.
• Golden Master Workflows - Implements a workflow for capturing, approving, and comparing large text outputs to verify refactoring safety.
• Modernization Exercises - Offers structured challenges to transform complex legacy business logic into a clean, maintainable architecture.
• Manual Refactoring Techniques - Provides a baseline for performing manual, incremental improvements and safety testing on flawed code.
• Educational Test Suites - Provides educational test suites designed to document existing behavior before applying incremental design changes.
• BDD Specification Mappings - Maps human-readable behavioral requirements to executable automation steps to verify system logic.
• Database Test Case Executors - Provides a database-level framework to execute test cases and verify the correctness of logic changes.
• Snapshot Testing - Records serialized data states to disk to ensure behavior remains consistent across refactoring iterations.
• Test Fixture Systems - Includes systems to manage the environment and data setup required for running automated test sequences.
• Characterization Tests - Uses comprehensive test suites to document legacy behavior as a safety net for incremental design changes.
• Test Coverage Metrics - Provides reports measuring the percentage of source code exercised by the test suite to identify verification gaps.
• Unit Testing and Code Coverage - Provides utilities for executing component tests and analyzing code coverage to verify refactoring results.
• Unit Testing Frameworks - Ships with unit testing frameworks to validate individual logic components using assertions.
• Coding Exercises - A well-known exercise for refactoring complex legacy inventory code.

Star-Verlauf