Refactoring Legacy Code like a Pro: a Use Case.

Set up a Java project with Gradle and Kotlin configuration, configure Java 11, and write the first unit test using JUnit 5 to support refactoring of a prayer time calculator.

Learn how to improve unit test coverage for a prayer time calculator to support refactoring by fixing fixtures, using local dates, and adopting parameterized tests to approach near 100% coverage.

Learn to implement parameterized tests in JUnit 5 for a prayer time calculator, using CSV, value, and method sources with test data and converters to boost coverage.

Explore improving code coverage by adding tests and preparing for refactoring. Remove dead code and unused methods, guided by the agony principle, to reach 100% coverage.

Clean and refactor tests by extracting classes to a converters package, creating constants, and adding helper assertions to improve readability and maintainability of the prayer times calculator tests.

Explore mutation testing to evaluate and improve test quality by mutating code, measuring killed versus survived mutations, and using Pytest with Gradle to generate reports.

Convert the Java file to Kotlin using the shortcut, fix conversion errors, run safety net tests, and refactor by removing unused code and addressing warnings.

Explore why teams refactor legacy code for educational purposes, focusing on improving design, fixing bugs, adding behaviors or features, and optimizing performance.

Remove clutter from legacy code by using descriptive names, refactoring to replace comments, and renaming across the codebase to boost readability and maintainability.

Refactor large Kotlin files by using top level functions and extracting helpers into separate files. Move trigonometric functions to a separate file and use expression body.

refactor primitive obsession by replacing raw ints with enums and dedicated types in kotlin, using time formats and converters to improve type safety and clarify domain concepts.

Refactor by depending on abstract types instead of concrete implementations, swapping ArrayList for List and HashMap for Map to enable safe, performance-aware changes in large codebases.

Split a complex function to improve readability by extracting duplication, breaking calculations into dedicated helpers, and renaming variables for clarity while preserving tests.

Refactor legacy calculation logic by replacing a complex double array with a custom class and a sealed calculation method to clarify parameters for fajr, maghrib, and isha.

Master real-world refactoring techniques to improve legacy code structure and enable new features, while teaching others and helping the next generation of developers.

refactor legacy code by converting state-changing actions into pure functions, passing latitude, longitude, timezone, and julian date as explicit parameters to improve testability and ensure same outputs for given inputs.

Refactor the public API to be developer friendly by extracting classes to separate files and introducing a formatted prayer times object, with tests updated accordingly.

Pair programming pairs two developers on the same keyboard and screen to write code and critique ideas, improving refactoring outcomes and code quality through junior and senior collaboration and reviews.

Extract formatting logic from prayer time calculator into time format utilities and a time format class. Implement 12 hour and 24 hour formats with or without suffix, backed by tests.

Refactor the app's time format to remove duplication, introduce a configurable suffix and a without-suffix option, and consolidate formatting logic into a reusable helper.

Refactor the core logic for calculating prayer times by extracting julian date calculation, introducing a prayer times data class, and replacing arrays with a simpler approach, ensuring tests pass.

Refactor the core logic of prayer time calculations, extract functions, convert to arrays, and test step by step while tackling floating-point precision issues and high latitude adjustments.

Refactor the core logic for prayer times by debugging failing tests, gradually extracting and moving functions, and implementing time adjustments with high latitude methods and calculation parameters.

Refactor the core logic by extracting prayer time calculations into a dedicated class, introduce time offsets, and streamline formatting, while updating tests and public API.

Explore legacy code with scratch refactoring to understand complexity through small, exploratory steps. Refactor by renaming variables, extracting functions, removing clutter and comments, and clarifying time formatting.

Apply techniques from more than 20 videos of a refactoring course to clean up legacy code. Celebrate the course completion and share your honest review to help others find it.