Contributing to open-source projects is a great way to collaborate with developers around the world and improve software that others rely on. Recently, I had the opportunity to contribute to a project hosted by HTSagara, where I submitted a pull request to implement a new feature. In this blog post, I’ll walk you through my experience, including the challenges, what I learned, and what I would do differently next time.

The Project: readme_genie
The project I contributed to, readme_genie, is an interesting tool that automates the process of generating detailed README.md files for repositories. It’s designed to help developers quickly create project documentation. I saw an opportunity to improve the tool by adding a new feature that would streamline its functionality, which led me to open an issue and create a pull request.

Repository: HTSagara/readme_genie
Pull request link: Pull Request #5

Step 1: Identifying the Feature
As I explored the readme_genie repository, I noticed an area for improvement in how the tool handled certain aspects of file generation. Specifically, I proposed adding a new flag that would allow users to generate more customizable README.md files, catering to different programming languages or frameworks.

I opened an issue to track this feature request:

Issue link: Issue #4

Step 2: Forking the Repository and Making Changes
Once the feature was discussed and approved, I forked the repository and cloned it to my local machine. After setting up the project locally, I made the necessary changes. This involved modifying the codebase to add the new flag and updating the usage documentation in the README.md file.

I tested the changes thoroughly to ensure everything worked as expected and didn’t break any existing functionality. I also used automated tests provided by the repository to confirm that my modifications met the project's standards.

Step 3: Submitting the Pull Request
After verifying my changes, I created a pull request to merge my feature into the main project. This was a smooth process, as GitHub's interface makes it easy to compare branches and initiate a pull request. I provided a detailed description of the changes and linked the issue to the PR.

Pull Request Link: HTSagara/readme_genie#5

Step 4: Feedback and Iteration
After submitting the pull request, I waited for feedback from the project maintainer. Fortunately, the project maintainer responded quickly. They reviewed my code, and while they were happy with the changes, they requested a minor revision related to code formatting and added a suggestion to improve the error handling mechanism.

I promptly made the changes and updated the pull request. This part of the process was a valuable learning experience, as it showed me how essential it is to collaborate effectively with maintainers and other contributors.

Step 5: Pull Request Merged
Once the maintainer was satisfied with the revisions, my pull request was merged into the project! It was incredibly rewarding to see my contribution accepted, knowing that others could benefit from the feature I helped build.

Challenges I Faced

One of the challenges I encountered was understanding the existing codebase well enough to make modifications. Since every project has its own structure and conventions, it took some time to familiarize myself with the code before making changes. Additionally, balancing new feature development with maintaining the existing structure was something I had to pay close attention to.

Another challenge was ensuring that my changes wouldn’t break any existing functionality. I had to rely on testing and careful analysis of the code to avoid introducing bugs.

Lessons Learned

• Understand the Codebase: Take time to thoroughly understand the existing code. This helps you make well-informed changes and avoid errors.
• Communication is Key: Engaging with the project maintainers and other contributors is critical for getting feedback and ensuring your changes meet the project's needs.
• Testing is Essential: Before submitting any changes, always test them to ensure they don’t introduce new bugs or issues. Rely on both automated and manual testing.

Step 6:Receiving a Pull Request for My Own Project
While I was working on my contribution, I also received a pull request for my own project, Release-0.1. This was an exciting experience, as I got to see what it’s like on the other side of the contribution process.

Pull Request Link: Release-0.1 PR #6

When I received the pull request, I had to review the contributor's code and ensure that it aligned with the project's goals. I asked for some small changes, and the contributor was very responsive, making it easy to finalize and merge their work. This experience taught me the importance of providing clear, constructive feedback when reviewing contributions.

Step 7: What I Would Do Differently Next Time
Next time, I would aim to:

• Engage Earlier: I would try to engage with the project maintainer earlier in the process to ensure that my proposed changes align with their vision for the project.
• Write Better Documentation: Although I updated the README.md, I realized I could have written more comprehensive documentation for users unfamiliar with the new feature.
• **Automate More Tests: **While testing was done manually and via existing test suites, I learned the importance of writing additional tests to cover edge cases, especially when contributing new features.

Conclusion
Contributing to open source is an incredibly rewarding experience, and I encourage every developer to try it out. Whether you're improving existing functionality or adding new features, collaborating with others helps you grow as a developer. My journey contributing to readme_genie and receiving a pull request for my own project taught me valuable lessons about communication, testing, and collaboration.

If you're thinking about contributing to open-source projects, don’t hesitate! It's a fantastic way to give back to the community and improve your skills in the process.