DEV Community: Inderpreet Singh Parmar

Simplifying Event Creation: Adding a Dedicated Button for Group Admins

Inderpreet Singh Parmar — Thu, 12 Dec 2024 17:28:30 +0000

In Release 4, I aimed to streamline the process of event creation for group admins in the Event Blend Frontend project. My focus was on implementing the following feature:

Add create new event button (#78)

This feature allows group admins to quickly access the event creation page from their group's details page, significantly enhancing the usability of the platform.

Overview of the Feature

Previously, navigating to the event creation page required several clicks, making it less intuitive for group admins to create new events. The new feature introduces a dedicated button visible only to admins, enabling a smoother and more accessible workflow.

Steps Taken to Implement the Feature

Role-Based Visibility
- Used the role property from the session data to check if the logged-in user is an admin.
- Ensured only users with the Admin role can see the "Create Event" button.
Dynamic Redirect
- Added a button that redirects admins to the event creation page with the group ID pre-filled as a query parameter.
UI Enhancements
- Designed the button to match the existing UI theme for consistency.
- Ensured responsiveness and accessibility for various screen sizes.
Code Refactoring
- Refactored the existing codebase to accommodate this feature without redundancy.
- Improved code maintainability by introducing reusable components.

Challenges and Collaboration

A key challenge was dynamically fetching and validating the admin role from the session data. Communication with the maintainer via Discord helped clarify the expected behavior and validate the changes. This collaboration ensured the feature met the project's standards and requirements.

Results and Impact

This feature greatly enhances the user experience for group admins by providing a direct and intuitive way to create events. It reduces navigation complexity and improves the overall efficiency of the platform.

For more details, see the related Pull Request here.

Conclusion

Both features—adding datetime inputs and a dedicated event creation button—have significantly improved the Event Blend Frontend's functionality and user experience. Through these contributions, I’ve honed my skills in frontend development, validation logic, and open-source collaboration. Working directly with the maintainer on Discord was an invaluable experience that emphasized the importance of clear communication in distributed teams.

Enhancing Event Management: Adding Date and Time Features in Open Source

Inderpreet Singh Parmar — Thu, 12 Dec 2024 17:25:59 +0000

As part of my Release 3 contribution to the Event Blend Frontend project, I focused on improving the event management functionality by addressing two important issues:

These changes were pivotal in enhancing the user experience for event creation, ensuring better functionality and usability.

Overview of the Issues

The original system allowed users to add only start and end dates for events. There was no functionality to include start and end times, which limited the precision and practicality of event scheduling. Additionally, the backend supported datetime values, but the frontend did not utilize this feature effectively.

My contributions were focused on:

Adding start time and end time inputs alongside the date inputs in the event creation form.
Validating the input to ensure the end datetime is always later than the start datetime.
Updating the data sent to the backend to include combined date and time values in ISO format.

Steps Taken to Solve the Issues

Frontend Form Enhancement
- Updated the event creation form by adding fields for start time and end time.
- Used the useSignal hook to capture and manage date and time values in real time.
Validation Logic
- Implemented a client-side validation to ensure the end datetime is after the start datetime. If invalid, an alert prevents the form submission.
Data Formatting for Backend
- Modified the data structure sent to the backend, combining date and time values into a single ISO format string.
User Interface Improvement
- Enhanced the user interface with labels and placeholders to guide users on filling out the new fields effectively.

Challenges and Collaboration

One challenge was ensuring proper validation and formatting while maintaining a seamless user experience. Communication with the maintainer via Discord was essential to clarify implementation details and expectations. This direct line of communication was instrumental in quickly resolving uncertainties, particularly regarding data formatting requirements and UI design choices.

Results and Impact

These updates improved the event creation process by allowing users to define precise event timings. The new functionality aligns with modern user expectations and streamlines the scheduling process for organizers and participants.

For a more detailed overview of my work, you can view the related Pull Request here.

Releasing Tailor4Job via npm

Inderpreet Singh Parmar — Thu, 21 Nov 2024 20:58:39 +0000

As part of my open-source development journey, I recently worked on packaging and releasing my command-line tool, Tailor4Job, via the npm registry. Tailor4Job helps candidates optimize their resumes and cover letters by analyzing them against job descriptions and providing actionable feedback. In this blog post, I’ll walk you through my experience with creating and publishing the package, the challenges I faced, and the lessons I learned.

Why I Chose npm

I chose npm as the package registry for Tailor4Job for several reasons:

Popularity: npm is one of the most widely used package registries and provides a robust ecosystem for publishing and sharing tools.
Ease of Use: npm simplifies the process of packaging and distributing command-line tools, making it accessible to a broad audience.
Compatibility: Although Tailor4Job is a Python-based tool, npm allows easy integration for CLI tools, making it an ideal choice for this project.

Steps for Creating and Publishing the Package

Setting Up package.json:
- I initialized the project with npm init and carefully filled in the metadata, such as name, version, description, repository, and author.
- I added a bin field to specify the CLI entry point (main.py).
Ensuring Script Compatibility:
- Added a shebang line (#!/usr/bin/env python3) to main.py to ensure it executed as a Python script.
Publishing to npm:
- Logged into my npm account and published the package:
```
 npm publish
```
Testing the Installation:
- Installed the package globally to verify:
```
 npm install -g tailor4job
 tailor4job --help
```
Version Management:
- Encountered a restriction on republishing the same version. Resolved it by incrementing the version number in package.json and using semantic versioning for subsequent releases.
Documentation:
- Updated the README.md with installation and usage instructions, ensuring users could easily understand how to install and use Tailor4Job.

Challenges and Solutions

Permission Issues During Installation:
- Faced EACCES errors when globally installing the package. Fixed it by using sudo and later configuring npm to use a local directory for global installations.
CLI Command Not Found:
- Initially, the tailor4job command was not recognized because the bin field was missing in package.json. After adding it, the issue was resolved.
Script Execution Errors:
- The script was mistakenly executed as a shell script. Adding a shebang line and ensuring proper permissions fixed the problem.
Republishing the Same Version:
- npm does not allow overwriting published versions. Learned to increment the version number using npm version commands before republishing.

Conclusion

Releasing Tailor4Job on npm was an enlightening experience. It taught me the nuances of software packaging, semantic versioning, and user-focused documentation. While challenges like permission errors and script execution issues slowed me down, they also helped me grow as a developer.

Now, Tailor4Job is accessible to users globally, and I’m excited to see how it can help job seekers enhance their applications. If you’re interested, feel free to check out the project on npm and contribute your feedback or improvements!

npm Package Link: tailor4job
GitHub Repository: Tailor4Job GitHub Repo

Thank you for reading, and happy tailoring! 🚀

Implementing GitHub Actions CI Workflow for Tailor4Job

Inderpreet Singh Parmar — Thu, 21 Nov 2024 19:23:27 +0000

Continuous Integration (CI) has revolutionized the way developers manage and maintain their codebases. In this blog post, I’ll share my experience setting up a GitHub Actions CI workflow for my project, Tailor4Job. I’ll also reflect on writing tests for a peer’s repository in collaboration with Fahad Ali Khan, share insights on CI, and discuss additional challenges tackled during the process.

Setting Up the GitHub Actions CI Workflow

To automate testing and ensure code quality for Tailor4Job, I used GitHub Actions to set up a CI workflow. Here's how I approached it:

Define the Workflow

The workflow is defined in .github/workflows/python-app.yml. It runs on every push or pull request to the main branch and executes the following steps:

Checks out the code.
Sets up Python 3.9.
Installs dependencies from requirements.txt.
Installs wkhtmltopdf, required for PDF generation tests.
Runs all tests using pytest.

name: Python CI

on:
  push:
    branches:
      - main
  pull_request:
    branches:
      - main

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout code
      uses: actions/checkout@v3

    - name: Set up Python
      uses: actions/setup-python@v4
      with:
        python-version: '3.9'

    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt

    - name: Install wkhtmltopdf
      run: |
        sudo apt-get update
        sudo apt-get install -y wkhtmltopdf

    - name: Run Tests
      run: |
        pytest -v --maxfail=1 --durations=10

Challenges Faced

Dependency Issues: I encountered errors related to the wkhtmltopdf dependency missing in the CI environment. Installing it resolved issues with PDF generation.
Environment Variables: Setting up API keys securely as GitHub secrets required careful attention to avoid exposing sensitive data.

Outcome

The workflow successfully ran all tests, providing immediate feedback on code changes. This streamlined the process of maintaining code quality and improved development efficiency.

Writing Tests for a Partner’s Repository

As part of the lab, I collaborated with Fahad Ali Khan to contribute tests to his repository. This was an enriching experience, as it involved adapting to a different codebase and setup.

Test Case Added

I added the following test case to verify error handling in the save_file method of the eng_format class:

TEST(EngFormatTests, SaveFileThrowsOnInvalidFile) {
    // Set dummy environment variables for testing
    setenv("API_KEY", "dummy_key", 1);
    setenv("API_URL", "https://dummy.url", 1);

    eng_format formatter;

    // Use an invalid file path (e.g., a directory) to force an error
    std::string invalidFilePath = "/invalid_path/test_output.txt";
    std::string testContent = "This content should fail to save.";

    // Ensure that the save_file method throws an exception for the invalid path
    EXPECT_THROW(formatter.save_file(invalidFilePath, testContent), std::runtime_error);
}

Purpose

This test ensures robust error handling when saving files, verifying that the save_file method throws a std::runtime_error for invalid file paths.

Challenges and Learnings

Understanding a New Codebase: Writing tests for a new repository required me to carefully analyze the code and understand its structure and logic.
Collaboration: Communicating with Fahad to clarify ambiguities and align my tests with his expectations was vital.
Test Integration: Ensuring the new test fit seamlessly into the existing suite required attention to compatibility and coverage.

Reflections on CI

Implementing CI for Tailor4Job and contributing tests to Fahad’s repository has given me a new appreciation for CI's role in modern development.

Benefits of CI

Error Prevention: CI catches bugs early in the development process, preventing them from reaching production.
Efficiency: Automated testing saves time and ensures consistency.
Collaboration: CI fosters a collaborative environment by ensuring code changes are rigorously tested before merging.

Future Plans

I plan to integrate CI into all future projects, particularly those involving collaboration or open-source contributions.

Conclusion

This lab was a rewarding experience that highlighted the importance of CI and testing in software development. Collaborating with Fahad Ali Khan and contributing to his repository improved my collaborative and technical skills. CI is now an integral part of my workflow, ensuring code quality and streamlining development processes.

Deep Dive into Testing and Tooling: Insights from Lab 7

Inderpreet Singh Parmar — Mon, 04 Nov 2024 05:45:04 +0000

In Lab 7 of my open-source development course, I focused on establishing robust testing practices within my project, Tailor4Job. This lab emphasized automated testing and static code analysis using tools like pytest, requests-mock, and ruff. In this post, I'll walk through the setup, challenges, and insights gained.

Choosing the Right Tools

Testing and code quality are essential for open-source projects. For Lab 7, I used:

pytest: As the main testing framework. pytest is lightweight yet powerful and supports test discovery, which makes it ideal for an expanding project.
requests-mock: To simulate API responses for functions reliant on external services. This tool allows us to verify functionality without making actual network requests, which is crucial for isolated and reliable tests.
ruff: A linter and formatter for ensuring code quality and consistency across the project. I used ruff to enforce style conventions and eliminate errors like unused imports or improper module-level import placement.

Mocking API Responses:
To avoid real network calls, I used requests-mock to simulate the API’s behavior in test scenarios. By defining expected responses for the API endpoints, I ensured that tests were consistent and independent of network conditions.

Writing Test Cases

Lab 7 required extensive test case coverage. Some highlights include:

Basic Input Validation: Testing for proper handling of inputs like non-existent files, empty strings, and unsupported formats.
API Response Testing: Using requests-mock, I verified that functions responded correctly to different API statuses (e.g., 401 Unauthorized for invalid API keys).
Edge Case Testing: From large file handling to custom filenames, edge cases were essential to test thoroughly. By simulating these scenarios, I gained confidence that the program could handle diverse inputs.

Challenges Faced

Static Analysis Failures:
One of the most persistent challenges was dealing with ruff failures in pre-commit hooks. Errors related to import order (E402) required restructuring imports across multiple files. Fixing these required running ruff --fix repeatedly until all issues were addressed.
Mocking Complex File Inputs:
Handling .docx files in tests required careful mocking to simulate content without reading actual files. patch from unittest.mock helped to bypass file access, allowing me to test file-dependent functions in isolation.
Git Workflow Adjustments:
Rebasing and stashing changes became tricky when pre-commit hooks kept flagging issues. Using --no-verify with commits was a workaround to continue my workflow while maintaining formatting locally.

Insights and Takeaways

This lab underscored the importance of automation in testing and formatting. I learned that setting up robust pre-commit hooks and using tools like requests-mock early can save significant debugging time later. Additionally, structured testing practices make the codebase more reliable, paving the way for future enhancements without risking regressions.

Conclusion

Lab 7 was a deep dive into testing and static analysis for open-source development. By implementing thorough tests, leveraging mocking tools, and adhering to code quality standards with ruff, I gained hands-on experience that will be invaluable in future projects.

For the complete source code and test cases, check out the project repository here.

Submission Details

Commit Hash: [https://github.com/InderParmar/Tailor4Job/commit/e024ecb26cd134951a83c7042dd7faf9c41da7c7]

Improving Tailor4Job with Ruff 🛠️✨

Inderpreet Singh Parmar — Mon, 04 Nov 2024 02:38:52 +0000

In this post, I'll walk you through how I integrated Ruff, a static analysis tool, into my project Tailor4Job. Ruff provides both code formatting and linting, making it a one-stop tool for keeping my codebase clean and consistent. Here’s why I chose Ruff, how I set it up, the issues it helped me catch, and what I learned along the way. Let's dive in! 🏊‍♂️

Why Ruff? 🤔

I chose Ruff because it’s lightweight, fast, and powerful — perfect for ensuring code quality without slowing down my workflow. Ruff handles both formatting and linting, meaning I don’t need separate tools for each. Plus, it’s highly customizable and easy to integrate with my editor and pre-commit hooks. The documentation is clear and easy to follow, making it a great choice for my project.

👉 Check out Ruff’s documentation here for details on how it works and how you can configure it!

Setting Up Ruff 🛠️

To get started, I followed these steps:

Installation: I installed Ruff with pip install ruff. Super easy! 👍

Configuration with .ruff.toml: Ruff’s configuration file lets me specify formatting, linting rules, and files to ignore.

Example settings:

  line-length = 88
  exclude = ["env", "__pycache__", "build", "dist", ".venv"]

  [lint]
  select = ["E", "F"]
  ignore = ["E501"]

Editor Integration: I added Ruff to my VS Code setup for real-time linting and formatting on save. This was as simple as configuring .vscode/settings.json:

   {
     "python.formatting.provider": "ruff",
     "editor.formatOnSave": true,
     "python.linting.ruffEnabled": true
   }

Now, Ruff highlights issues as I type, making it easy to catch and fix them right away! 🚀

Pre-Commit Hook: Using a pre-commit hook, Ruff runs automatically before each commit, ensuring all code follows my project’s standards. No more style checks in PRs! 🎉

Issues Found and Fixed 🐛

Ruff was great at identifying issues I didn’t notice before, like:

Unused Variables: Ruff flagged variables that were declared but never used. It’s easy to miss these, but they can clutter the code and cause confusion. Fixing this was straightforward.
Formatting Consistency: Ruff adjusted inconsistent indentation and spacing automatically, so I didn’t have to go through each file manually. This saved a ton of time! 🕒
Line Length Violations: Ruff pointed out lines that were too long, which I was able to break up for better readability.

Most of these fixes were quick and easy thanks to Ruff’s automatic corrections. For others, Ruff provided clear feedback on what needed to be adjusted.

Running Ruff 🚀

There are multiple ways to run Ruff in my project:

Command Line: I set up format.sh and lint.sh scripts for one-command formatting and linting:

   ./format.sh  # Formats code
   ./lint.sh    # Lints code

These scripts are great for quickly checking or formatting code without needing to remember complex commands.

Editor Integration: With Ruff in VS Code, I get instant feedback on errors and style issues. Code is automatically formatted on save, making it easier to maintain quality without interrupting my workflow. 🔥
Pre-Commit Hook: Ruff runs automatically before each commit, so I don’t have to worry about accidentally committing unformatted or non-compliant code. ✅

What I Learned 🎓

Using Ruff taught me a lot about the benefits of static analysis tools:

Time Efficiency: Ruff catches issues before they become a problem, saving debugging time down the line. Pre-commit hooks are especially valuable for catching errors early.
Code Consistency: Ruff enforces a consistent style, making the codebase cleaner and easier to navigate. This is crucial when working on collaborative projects.
Improved Workflow: With editor integration, Ruff keeps my code clean as I write, reducing the need for end-of-session cleanup. The scripts and pre-commit hooks add further efficiency, allowing me to focus more on writing code and less on formatting.

Overall, Ruff made my project more professional, readable, and scalable for future contributors. I’m excited to keep using it and highly recommend it to anyone looking to streamline their development process. 💪

🎉 Final Blog: My Hacktoberfest Journey - Four PRs, Countless Lessons! 🚀

Inderpreet Singh Parmar — Sun, 03 Nov 2024 18:22:46 +0000

Embarking on Hacktoberfest this year has been an incredible experience. Through my course Topics in Open Source Development, I tackled four unique issues across different projects, each with its own challenges and learning curves. Here’s a look back on my journey from my first PR to my fourth, which marked the completion of this wonderful open-source journey! 🌟

PR #1: Adding a Signup Feature on the Login Page 🔑

Issue: Adding a Signup Feature in Login Page
PR: #96

For my very first contribution, I worked on a small but impactful UI improvement, adding a "Sign up" link to the login page of the ForkTheCaptcha project. This feature was aimed at simplifying the user experience for new users, making it easier for them to find the signup page directly from the login screen.

Lessons Learned:

Tailwind CSS Mastery: I dove into Tailwind for styling, ensuring the "Sign up" link seamlessly blended with the existing design.
UI/UX Fundamentals: I learned about subtle placement and consistency for better user navigation.

This straightforward issue gave me a solid start, building confidence and making me excited to tackle more complex projects! 🥳

PR #2: Fixing the "Get Started" Link on Event-Blend-Frontend 🌐

Issue: Fix Get Started Link
PR: #115

My second PR involved updating a broken link in the Event-Blend-Frontend project. The “Get Started” button was redirecting to the wrong page due to recent routing changes, so I updated it to ensure users reached the correct destination.

Challenges & Solutions:

File Tracking with Git: Dealing with unwanted lock files was a lesson in Git management. I learned how to use git rm --cached to ensure these files weren’t included in the PR.
Maintainer Interaction: The maintainer’s feedback taught me the importance of file tracking and adhering to repository guidelines.

This experience gave me hands-on practice with Git hygiene and navigating file management in open-source projects. It also reinforced how a small fix can significantly improve user navigation. 📍

PR #3: Adding Consistent Bands Metadata for Vision Transformer and ResNet Weights 🛰️

Issue: Add Consistent Bands Metadata
PR: #2376

In my third contribution, I worked on adding consistent bands metadata for Vision Transformer and ResNet weights in the torchgeo library. This fix was crucial for improving usability in geospatial applications by ensuring standardized metadata across weight classes.

Highlights:

Understanding Geospatial Metadata: I delved into Landsat and Sentinel dataset specifications, learning about satellite bands and their practical applications.
Complex Git Workflows: Handling Git conflicts during rebase was challenging, but I learned to use git rebase and git rebase --continue effectively.
Detailed Maintainer Feedback: The maintainer’s input on variable names and code organization was invaluable and helped me refine my approach.

This PR significantly expanded my understanding of data consistency in machine learning workflows. It was a fantastic opportunity to work on a complex, real-world problem with practical implications for end-users! 🌍

PR #4: Migrating Nested Checkboxes - Task Migration Issue #3 ✅

Issue: Task Migration for Nested Checkboxes
PR: #4

My final contribution for Hacktoberfest and this course was solving an issue with nested checkbox migration. The problem? Only the first checkbox in a nested task list was being migrated to the current day’s tasks, leaving behind the rest. My solution involved implementing a recursive function to ensure all checkboxes, regardless of depth, were migrated.

Takeaways:

Recursive Functions for Nested Data: I used a recursive approach to handle nested checkboxes, which was both challenging and enlightening.
API Integration Skills: Working with the Notion API helped me better understand nested structures and how to handle them in API requests.
Completing a Complex Feature: Wrapping up Hacktoberfest with this issue was incredibly rewarding as it represented the culmination of everything I had learned along the way.

This final PR felt like the perfect capstone to my open-source journey, tying together my knowledge of JavaScript, APIs, and recursive functions. 📦

Final Reflections 🥂

Each PR was a stepping stone, building upon the last and pushing me out of my comfort zone. From UI tweaks and link fixes to handling complex metadata and recursive data migrations, I’ve learned so much through this journey. Open source has taught me to:

Adapt to New Technologies: Every project had different tools, from Tailwind CSS to advanced metadata handling in ML libraries.
Collaborate with Maintainers: Communication is key, and interacting with maintainers helped me refine my contributions.
Refine Git Skills: Handling conflicts and organizing commits are essential skills that I’ll carry forward.

What I’d Do Differently: I’d focus more on thorough testing before creating a PR to ensure I catch minor issues upfront. Additionally, I’d reach out sooner if I’m uncertain about feedback to streamline the process.

With four successful PRs, I’m celebrating this milestone and looking forward to more contributions in the future! 🎊

Open Source - Working on Task Migration for Nested Checkboxes

Inderpreet Singh Parmar — Sun, 03 Nov 2024 18:16:07 +0000

Issue: Task Migration Bug for Nested Checkboxes

This week, I worked on Issue #3 in the project. The issue identified a bug where only the first checkbox in a nested list was being migrated to the current day’s task page, leaving subsequent checkboxes behind. The goal was to ensure all nested checkboxes in a task list were correctly transferred to the new page, preserving the nested structure.

Preparation for the Fix

To address this bug, I set up the project environment and familiarized myself with the repository structure. This involved:

Reviewing the existing task migration function to understand the current behavior.
Ensuring my setup could handle the required API calls.
Reviewing documentation on nested lists and task migrations to understand how other tools approach similar issues.

Learning Goals and Key Knowledge Gained

To implement this fix, I needed to understand how nested tasks are structured and accessed in the Notion API. This led me to learn more about recursive functions in JavaScript, which allow a function to call itself until a specified condition is met—in this case, iterating through nested tasks until each was processed.

Code Explanation

To address the issue, I implemented a recursive function, moveNestedTasks, which handles nested checkboxes by:

Identifying Incomplete Tasks: Filtering tasks to locate those that were not checked.
Migrating the Main Tasks: Adding these tasks to the current day’s task page.
Recursively Handling Nested Tasks: For any task that had children, moveNestedTasks calls itself to handle the nested items, ensuring that the sub-tasks are also appended in the correct format.

Here’s a simplified code breakdown:

Main Migration Function: moveIncompleteTasks retrieves incomplete tasks and calls moveNestedTasks.
Recursive Function: moveNestedTasks iterates through tasks and, if it encounters a nested task, calls itself again, ensuring each level of the nested list is correctly processed.

Research and Challenges

During this work, I researched task structures within the Notion API and reviewed best practices for recursive functions in JavaScript. The biggest challenge was ensuring each subtask maintained its order and structure when migrated, which required careful handling of API calls.

Project Maintainer Interaction

The project maintainer was responsive and supportive, especially when I requested clarification on nested structures. They confirmed the exact requirements for migrating nested items, which helped me finalize the approach.

Difficulties and Solutions

I initially struggled with managing the nested structure while ensuring efficiency. Recursive functions, while effective, can lead to high memory usage if not handled correctly. By carefully structuring the function calls and ensuring each nested task was processed independently, I was able to overcome these challenges.

Reflection

This task was a great learning experience in working with recursive functions and handling nested data structures through APIs. If I were to approach this again, I’d test each nested level independently before the final implementation to verify structure handling at each depth. Going forward, I’ll continue using recursive functions for similar tasks, given how well it handled nested structures in this case.

My First Open Source Contribution @microsoft

Inderpreet Singh Parmar — Sun, 03 Nov 2024 17:59:26 +0000

Issue Worked On:
Add Consistent Bands Metadata to Vision Transformer and ResNet Weights #2376
This week, I worked on a GitHub issue to add consistent band metadata across Vision Transformer (ViT) and ResNet weight classes in the torchgeo library. The goal was to ensure uniform metadata across different weight classes, specifically supporting various satellite datasets like Landsat and Sentinel.

Overview of the Issue:
The issue focused on improving usability by ensuring that each weight class had clear and consistent band metadata. This enhancement aimed to address missing information that users need to ensure compatibility when applying these weights in their workflows. The metadata needed to align closely with the Sentinel and Landsat datasets’ specifications, which are commonly used in geospatial applications.

Preparation and Setup:
I began by cloning the repository and setting up the environment, ensuring I was familiar with the metadata definitions in torchgeo. I studied the structure and naming conventions used in resnet.py and vit.py to determine where to add the new metadata. I also reviewed related documentation on Landsat and Sentinel datasets to ensure accuracy.

Learning Requirements:
Understanding the structure and conventions for the different satellite bands was essential. I researched how Landsat and Sentinel datasets represent bands to ensure that I correctly implemented each set of metadata for these satellite data sources. Additionally, learning to interpret feedback from the maintainers regarding variable naming conventions and formatting was an important part of the process.

Explanation of the Fix:
To implement the fix:

Added Band Metadata: I added band metadata to the Vision Transformer and ResNet weight classes, following the structure set in the swin.py file for consistency.
Standardized Variable Naming: I adopted naming conventions that clearly indicated the dataset associated with each band, such as _landsat_tm_toa_bands, _sentinel2_rgb_bands, etc.
Removed Inconsistent Variables: The final review involved removing the fMoW bands metadata as these bands were inconsistent across satellites, per feedback from the maintainer.

Demo of Code Before/After Fix:
Before the fix, the band metadata was either missing or inconsistently named, making it difficult for users to identify which bands were needed for each weight class. After the update, the band metadata is now clear and consistent across weight classes, and each dataset is properly represented with standardized naming conventions.

Research and Challenges:
In addition to researching Landsat and Sentinel band specifications, I faced challenges with Git, particularly with rebase conflicts while addressing feedback. Some metadata, like the fMoW bands, was particularly challenging due to inconsistent satellite band usage, which led to the eventual removal of this metadata.

Interactions with Maintainers:
Throughout the process, I received helpful feedback from the project maintainer, adamjstewart, who provided specific requests to:

Alphabetize imports and variables for better readability.
Move comments to improve code organization.
Remove fMoW metadata due to inconsistencies across satellites. The maintainer's insights on metadata formatting and code organization helped refine the final solution.

Overcoming Difficulties:
Handling Git conflicts was challenging, but I used commands like git rebase and git rebase --continue to resolve these issues. Additionally, interpreting the feedback regarding metadata names required careful review and adjustment. I implemented each change step-by-step and tested to ensure the updated metadata did not introduce errors.

Link to the Pull Request:
Add Consistent Bands Metadata to Vision Transformer and ResNet Weights #2376

Reflection and Learning:

This experience highlighted the importance of clear metadata and code organization in collaborative projects. For future contributions, I would ensure that I understand naming conventions from the start to avoid rework. The alphabetical organization and standardized naming practices were particularly useful and something I would apply in future coding projects. Additionally, I gained valuable experience in handling complex Git workflows, which will be beneficial for similar projects.

Outcome:

The PR was successfully merged, with the "hacktoberfest-accepted" label added, allowing my contribution to be counted toward Hacktoberfest. The maintainer acknowledged the timing, ensuring the merge was completed in October. This contribution enhanced the usability of torchgeo for geospatial applications, and I’m grateful for the learning experience this project provided.

Fixing the “Get Started” Link in Event-Blend-Frontend

Inderpreet Singh Parmar — Mon, 28 Oct 2024 12:10:55 +0000

Issue Addressed

Issue #112: Fix Get Started Link

Summary of the Issue

The "Get Started" button in the footer of the website was redirecting to /group/new, which needed to be updated to /create-group to align with recent changes in the app's routing structure.

Preparation and Setup

To fix this issue, I first set up the project locally:

Forked and cloned the repository to ensure a separate copy for making changes.
Installed dependencies using npm install to prepare the project for development.
Ran the project locally to familiarize myself with the existing navigation structure and locate the “Get Started” link in the codebase.

Learning and Fix Implementation

Navigating the project, I identified the footer component and located the "Get Started" button. The link was previously hardcoded to /group/new, so I changed it to /create-group in the component. I then:

Tested the link locally by running the app on localhost.
Confirmed that the button redirected correctly to the new path /create-group.

Handling Lock Files

In the initial commit, I included the package-lock.json file, which the project maintainer requested to be removed. To address this:

I deleted both package-lock.json and pnpm-lock.yaml files locally.
After removing them, I committed and pushed the changes. However, GitHub still displayed pnpm-lock.yaml in the pull request, likely due to cache or sync issues.
I resolved this by force-pushing the branch to refresh the pull request, ensuring both lock files were excluded.

Challenges and Interactions

The most challenging part of this task was dealing with the lingering pnpm-lock.yaml file in the PR. I had to troubleshoot this by experimenting with Git commands to forcefully update GitHub’s display of the files.

The maintainer, @harshmangalam, was very helpful, providing feedback that guided me toward the best practices for managing unnecessary files in PRs.

What I Learned

File Tracking in Git: I learned about using git rm --cached to ensure unwanted files are completely removed from Git tracking.
Force Sync with GitHub: This issue taught me when and how to use a forced push to resolve GitHub sync issues.
Working with Maintainers: It reinforced the importance of clear communication and responsiveness to feedback in open-source projects.

Link to the Pull Request

Pull Request #115: Fix Get Started Link in Footer

Reflection and Next Steps

This experience underscored the need for attention to detail in open source, especially in adhering to repository guidelines. Next time, I’ll double-check any included files to avoid unnecessary additions in PRs. Overall, it was a great learning opportunity to practice collaboration and tackle minor technical issues.

Adding a Signup Feature in Login Page (Issue #96)

Inderpreet Singh Parmar — Mon, 28 Oct 2024 01:15:26 +0000

Issue and Link

This week, I worked on Issue #96 in the "ForkTheCaptcha" repository, which involved adding a signup feature to the login page. The issue required a "Sign up" link on the login page that would redirect users to the signup page.

What Was the Issue About?

The issue was about improving user experience by allowing users who don’t have an account to navigate easily to the signup page from the login screen. The request was straightforward: add a "Sign up" link below the "Submit" button in the login form and ensure it redirects to the signup page.

Preparation and Setup

The setup was simple as the project already had a functioning login page (login.html). I needed to analyze the existing structure and style of the login page to ensure the "Sign up" link would integrate seamlessly with the design. There wasn’t much technical setup involved since it was primarily a UI/UX addition.

Learning Points

To make the fix, I focused on a few key areas:

Understanding Tailwind CSS: The project uses Tailwind for styling, so I reviewed Tailwind’s documentation to ensure I could add styles that matched the existing theme.
Basic HTML/CSS: Since the change was in a static HTML file, it required a solid understanding of HTML and CSS basics rather than complex JavaScript or framework knowledge.

Demo of the Change

Before the fix, the login page only had the "Submit" button, making it challenging for new users to locate the signup option. Now, with the "Sign up" link, users who don't have an account can quickly navigate to the signup page. Below is a screenshot of the updated login page (include the screenshot if possible).

Research and Challenges

Research: Most of my research revolved around Tailwind CSS to ensure the link styling was consistent with the login page. I also reviewed best practices for login/signup pages to confirm my approach to placement.
Challenges: The main challenge was ensuring the new link didn’t disrupt the login page’s layout. I tested it across screen sizes to ensure responsiveness.

Interactions with Project Maintainers

The issue was assigned by the project maintainer, Aditya Sinha, who provided a brief description. There wasn’t extensive interaction required for this issue as it was a straightforward addition, but I communicated clearly about my progress and verified that the PR was correctly linked to the issue.

Difficulties and Solutions

This issue was relatively straightforward, but I did double-check styling consistency and responsive design for different screen sizes. Testing it on different browsers also helped catch minor visual inconsistencies, which I adjusted accordingly.

Link to Pull Request

The pull request for this issue can be found here: PR for Issue #96.

Reflection

Process and Learning: Working on this issue taught me the importance of aligning design elements with the existing UI for a seamless experience. This project gave me practical experience using Tailwind CSS, which was valuable.
What I’d Do Differently: Next time, I’d consider setting up a more formal review process for UI changes to ensure consistency across pages.
What Worked Well: Integrating the signup link was smooth, and Tailwind CSS made it easy to style the new element.

This was a great experience contributing to Hacktoberfest and building on my UI/UX skills!

Refactoring and Git Rebase for Tailor4Job

Inderpreet Singh Parmar — Tue, 22 Oct 2024 21:34:08 +0000

Introduction
As part of my open-source development course, I undertook Lab 5, which focused on refactoring my 0.1 Release project, Tailor4Job. This process involved improving the code's structure, readability, and maintainability. Additionally, I had to practice using Git to rebase, squash commits, and update the commit history.

Refactoring Improvements

Refactoring is an essential part of maintaining any codebase, particularly as new features are added and technical debt starts to accumulate. In this lab, I focused on the following improvements for the Tailor4Job project:

Encapsulation of Repetitive Code:
I encapsulated the model and provider processing logic into a new function called process_model_provider. This removed code duplication across multiple sections of the code and made future modifications easier.
Improved Naming Conventions:
One of the critical changes I made was renaming ambiguous variables to better reflect their purpose. For example, I changed generic names like data to more descriptive names, which made the code easier to follow.
Separation of Concerns:
I also worked on separating different functionalities into distinct functions and classes. For example, I moved API key handling to its function (get_api_key), improving modularity and making the code more maintainable.

Git Rebase and Squashing Commits

One of the most valuable parts of this lab was learning how to rewrite Git history by squashing multiple commits into a single cohesive one. Here’s how I approached it:

Created a Refactoring Branch: I started by creating a new branch called refactoring, which allowed me to make changes without affecting the main branch.

   git checkout -b refactoring

Made Multiple Commits: As I refactored the code, I made individual commits for each improvement, such as:

Refactored code logic
Encapsulated model and provider processing

Squashed Commits Using Git Rebase: After completing my refactor, I squashed all the refactoring commits into a single commit using Git's interactive rebase feature:

   git rebase main -i

In the interactive rebase, I combined all the changes into one cohesive commit message.

Challenges Faced During Refactoring

Module Import Error: One of the challenges I faced was a ModuleNotFoundError related to the groq package. This error delayed the testing of the refactored code. After installing the necessary dependencies and fixing the module imports, I was able to run the project smoothly.

Final Steps and Merging

Once I was satisfied with the refactoring and squash rebase, I merged the refactoring branch into main using a fast-forward merge:

git merge --ff-only refactoring

Finally, I pushed the changes to the remote GitHub repository:

git push origin main

Conclusion

Refactoring the code for Tailor4Job not only improved its maintainability and readability but also helped me gain valuable experience using Git rebase and commit squashing. These tools are powerful for managing a clean and understandable commit history in any project.

This lab has enhanced my understanding of writing clean code and managing Git history effectively, which are both crucial skills in open-source development.

DEV Community: Inderpreet Singh Parmar

Simplifying Event Creation: Adding a Dedicated Button for Group Admins

Overview of the Feature

Steps Taken to Implement the Feature

Challenges and Collaboration

Results and Impact

Conclusion

Enhancing Event Management: Adding Date and Time Features in Open Source

Overview of the Issues

Steps Taken to Solve the Issues

Challenges and Collaboration

Results and Impact

Releasing Tailor4Job via npm

Why I Chose npm

Steps for Creating and Publishing the Package

Challenges and Solutions

Conclusion

Implementing GitHub Actions CI Workflow for Tailor4Job

Setting Up the GitHub Actions CI Workflow

Define the Workflow

Challenges Faced

Outcome

Writing Tests for a Partner’s Repository

Test Case Added

Purpose

Challenges and Learnings

Reflections on CI

Benefits of CI

Future Plans

Conclusion

Deep Dive into Testing and Tooling: Insights from Lab 7

Choosing the Right Tools

Writing Test Cases

Challenges Faced

Insights and Takeaways

Conclusion

Submission Details

Improving Tailor4Job with Ruff 🛠️✨

Why Ruff? 🤔

Setting Up Ruff 🛠️

Issues Found and Fixed 🐛

Running Ruff 🚀

What I Learned 🎓

🎉 Final Blog: My Hacktoberfest Journey - Four PRs, Countless Lessons! 🚀

PR #1: Adding a Signup Feature on the Login Page 🔑

PR #2: Fixing the "Get Started" Link on Event-Blend-Frontend 🌐

PR #3: Adding Consistent Bands Metadata for Vision Transformer and ResNet Weights 🛰️

PR #4: Migrating Nested Checkboxes - Task Migration Issue #3 ✅

Final Reflections 🥂

Open Source - Working on Task Migration for Nested Checkboxes

Issue: Task Migration Bug for Nested Checkboxes

Preparation for the Fix

Learning Goals and Key Knowledge Gained

Code Explanation

Research and Challenges

Project Maintainer Interaction

Difficulties and Solutions

Links

Reflection

My First Open Source Contribution @microsoft

Fixing the “Get Started” Link in Event-Blend-Frontend

Issue Addressed

Summary of the Issue

Preparation and Setup

Learning and Fix Implementation

Handling Lock Files

Challenges and Interactions

What I Learned

Link to the Pull Request

Reflection and Next Steps

Adding a Signup Feature in Login Page (Issue #96)

Issue and Link

What Was the Issue About?

Preparation and Setup

Learning Points

Demo of the Change

Research and Challenges

Interactions with Project Maintainers

Difficulties and Solutions

Link to Pull Request