Refactoring: A way to write better Code

As I have landed in the Week 6, I got introduced to the new practice and that is Refactoring, which literally means to make changes in the internal structure keep the functionality not only intact but also enhancing it to scale when it comes to some projects. I applied onto my project i.e. Repository-Contextor and enhanced its actual working so as to scale well and come up with better tweeks

I start with focusing on the function extraction- by pulling out th reusable logic for the verbose logging, rendering and processing. Then I collected and joined the shared utilities- like language mapping and data building. I then created a single source to get the constants such as file extensions and skip directories. I then encapsulated the data and its analysis into the Repository_Analyzer class to make the code following the object-Oriented pattern.

I addressed naming hygiene, replacing ambiguous variables like f and p with descriptive names like discovered_fileand resolved_path, making the code self-documenting. Improvement made were incremental.

Using Git: Rebasing, Squashing

Working on the refactoring branch was not a new challenge for me but when I interactively rebase my branch with the main using git rebase -i main, I squashed all the small incremental changes into one commit without cluttering the log.Merging back to main via fast-forward ensured a clean integration, and pushing to GitHub made the work visible. I faced issues while I was making changes. Inconsistent language mappings, issues arose during file reading consolidation, and subtle path-handling errors arose during extraction part. Talking about the issues- Yesss, alot of them. Import errors during code splitting and parameter mismatches in class refactoring caused brief disruptions. Ultimately, refactoring invests in code quality. Follow iterative patterns—extract, consolidate, encapsulate, refine—to transform technical debt into scalable excellence.