The Journey of Refactoring: Enhancing Code, One Step at a Time

Refactoring is often seen as a daunting task, but it's also an essential aspect of software development. Today, I'll share my experience on the journey of refactoring a particular project and the lessons I learned along the way.

The Motivation

Every developer knows the feeling: you look back at old code and wonder, "What was I thinking?" While the initial implementation might have worked, over time, as requirements change and new features are added, the structure might no longer be ideal. That was the situation I found myself in.

Focus Areas in Improvements

Separation of Concerns: My primary goal was to segregate functionalities into understandable chunks. For instance, I split the main functionality into two separate files: argparser.py for argument parsing and converter.py for conversion processes.
Class Structure: To handle different file formats, I introduced two classes: TxtConverter and MdConverter. This allowed for a clear differentiation in logic and operations for .txt and .md files.

Steps to Better Code

Code Duplication: Repeated chunks of code were the first targets. By extracting them into separate classes, the code became DRY (Don't Repeat Yourself).
Variable Naming: Clear and descriptive variable names can make code self-explanatory. Several variables got renamed to reflect their purpose better.
File Separation: Splitting the main code into separate files made it easier to locate functionalities and maintain the code.

The Interactive Rebase Adventure

Using Git's interactive rebase was like wielding a double-edged sword. It's powerful, but if misused, it can rewrite history in unwanted ways. My experience was smooth, though. I could squash some minor fixes into relevant commits, ensuring each commit was atomic and self-contained.

Bugs and Breaks

While refactoring, I did stumble upon a few overlooked bugs. This was a silver lining, as the process of refactoring indirectly led to more robust code.

There were instances where changes led to unexpected behaviors. This underscores the importance of thorough testing after each significant refactor.

Rewriting Project History with Git

Git, as a version control system, is an ally of the developer. While using Git to change the project's history, I realized the importance of clear commit messages. They acted as breadcrumbs, guiding me through the changes made and the reasons behind them.

Conclusion

Refactoring isn't just about cleaning up code. It's a process of revisiting decisions, understanding the current state of the project, and making informed choices to improve it. Through this journey, I not only enhanced the codebase but also grew as a developer, understanding the nuances and importance of maintaining clean and efficient code.