DEV Community: alikhan1998

Refactoring Drowsiness Detection System

alikhan1998 — Wed, 01 Nov 2023 11:48:58 +0000

Issue Link: hassaanahmed04/Drowsiness-Detection-System #1
Issue Details: The current code implements a Drowsiness Monitoring System, combining image processing techniques with GUI elements using Tkinter. While the functionality is in place, there are opportunities for improvement in terms of code organization and readability.

Proposed Changes:

Modularize the code: Broke down the code into smaller, well-defined functions or classes to improve code structure and readability.
Add comments: Document complex logic or provide context for certain operations to enhance code understanding.
Use meaningful variable and function names: Ensured that variable and function names are descriptive and follow a consistent naming convention.
Implement error handling: Added appropriate error handling to handle scenarios where files or resources may not be found.
Use os.path.join(): Utilized this function to construct file paths, ensuring compatibility across different operating systems.
Expected Outcome: The refactored code should maintain the functionality of the Drowsiness Monitoring System while significantly improving its readability, maintainability, and adherence to coding best practices.

Research and Challenges: Understanding the existing codebase and identifying areas for improvement required careful examination. Ensuring compatibility across different operating systems was a key challenge. Interactions with Maintainers: No direct interactions with maintainers for this issue. Difficulties Faced and Solutions: Refactoring a complex system like the Drowsiness Monitoring System required a systematic approach. Breaking down the code into smaller functions and adding comments greatly enhanced code comprehension

Adding Calculation History Feature

alikhan1998 — Wed, 01 Nov 2023 11:46:57 +0000

Issue Link: alikhan1998/BABLU-The-Smart-Calculator-Assistant #1
Issue Details: Implement a feature that keeps track of the user's calculation history. This feature will allow users to view their previous calculations and results, providing them with a convenient way to reference their work.

Changes Made:

Created a data structure (dictionary) to store the history of calculations.
Whenever a calculation is performed, stored the input expression and its result in the data structure.
Provided a command for users to view their calculation history. Research and Challenges: Researched data structures suitable for storing calculation history. The main challenge was ensuring efficient retrieval and display of history. Interactions with Maintainers: No direct interactions with maintainers for this issue.

Difficulties Faced and Solutions: Designing the data structure for history storage required careful consideration. Ultimately, a dictionary proved to be an effective choice for this feature.
Pull Request: Link to Pull Request

Multilingual Support in image_to_sound

alikhan1998 — Wed, 01 Nov 2023 11:45:05 +0000

Issue Details: Currently, the code converts text to speech in English ("en"). It would be beneficial to extend this functionality to support multiple languages. Users should be able to specify the
target language for the generated audio.

Changes Made:

Allowed users to input the target language code or name as an argument when calling the image_to_sound function.
Implemented logic to select the appropriate language for the gTTS module based on the user's input. Research and Challenges: Researched the gTTS documentation and language codes. The main challenge was ensuring compatibility with different language inputs.

Interactions with Maintainers: No direct interactions with maintainers for this issue. Difficulties Faced and Solutions: Understanding the gTTS API and integrating multilingual
support required careful reading of the documentation. Regular testing helped verify the implementation.
Pull Request: Link to Pull Request

Refactoring OncoNet Script

alikhan1998 — Wed, 01 Nov 2023 11:42:47 +0000

Issue Link: yala/Mirai #9
Issue Details: The provided script is a part of the OncoNet project and is used for training, evaluating, and predicting on a dataset. While the script appears to be functional, there are opportunities for improvement in terms of code organization and documentation.

Changes Made:

Modularized the code: Broke down the script into smaller, well-defined functions and classes to improve code structure and maintainability.
Added Comments and Documentation: Documented complex logic and provided context for certain operations to enhance code understanding.
Improved Variable Naming: Ensured that variable and function names are descriptive and follow a consistent naming convention.
Implemented Error Handling: Added appropriate error handling to handle scenarios where files or resources may not be found.
Utilized os.path.join(): Used this function to construct file paths, ensuring compatibility across different operating systems.
Research and Challenges: Researched best practices for code organization and documentation. The main challenge was understanding the existing code and identifying opportunities for improvement.

Interactions with Maintainers: No direct interactions with maintainers for this issue. Difficulties Faced and Solutions: Understanding the complex logic in the script was challenging.
However, breaking it down into smaller functions and adding comments greatly helped in comprehending the code. Pull Request: Link to Pull Reques

Latest addition to the TIL (Today I Learned) Tool

alikhan1998 — Mon, 30 Oct 2023 11:47:06 +0000

Greetings, fellow developers! Today, I am thrilled to announce the latest addition to the TIL (Today I Learned) Tool.

As part of our continuous enhancement efforts, we've incorporated a new metadata feature that significantly augments the generation of
HTML files from Markdown content. This blog post delves into the inception, development, and the functionality brought about by this new feature.

Description of the Feature: The metadata feature is designed to augment the contextual information available within the generated HTML files. Users can now include additional metadata while converting Markdown files to HTML through the TIL Tool.
This metadata provides crucial additional information about the content being converted. It enables users to embed information such as author details, creation dates, categories, and much more directly into the HTML output.

How It Works and the Problems It Solves: The implementation introduces command line arguments (-m or --metadata flags) to accept user input for metadata. This capability allows users to provide relevant contextual details while processing Markdown
content, thereby enhancing the overall utility of the tool. With this feature, users can enrich the output HTML files with important details related to the content, making them more informative and useful.

Development Insights: The feature was implemented by extending the existing script to accommodate additional command-line arguments and processing logic. It was inspired by the need for more contextual information within the HTML output and driven by the goal of making the tool more user-centric and feature-rich. Similar to Docusaurus, our aim was to provide an intuitive and extensible solution, all while maintaining simplicity and usability.

Differences from Docusaurus: While Docusaurus served as an inspiration, the metadata feature implementation in the TIL Tool is geared specifically towards enhancing the content and contextual information within generated HTML files, making it a tool that's focused on the transformation of Markdown content to HTML with
augmented contextual information.

Next Steps and Community Involvement: For the future, our next steps involve addressing any feedback, improving the metadata feature, and enhancing its capabilities based on user interactions. We've filed issues within our repository related to this feature to keep track of enhancements, and we welcome contributions from the
community.

Adding a TOML Config File Feature in Collaborative Development with Remotes

alikhan1998 — Fri, 06 Oct 2023 16:21:18 +0000

It's wonderful to work on new features for projects, but cooperating with others, especially when you have to access their repository, makes it even more intriguing. I'd like to share with you my experience adding TOML configuration file functionality to a fellow student's GitHub repository recently.

The Problems and Challenges of Code Implementation:
Understanding the current codebase and figuring out how to effortlessly incorporate the new feature were the initial challenges. Fortunately, the owner of the repository had specified clear instructions and prerequisites in the GitHub issue, making the first setup pretty simple.

The TOML configuration file's parsing presented a significant issue. To get around this, I used an up-to-date TOML parsing package rather than creating a parser from scratch. This choice ensured the dependability of the code while also saving time.

Handling circumstances when the configuration file was either missing or unable to be correctly processed presented another issue. To fix this, I added error handling that, when required, gently ended the program and presented clear error messages.

Working together with Git Remotes

Utilizing Git Remotes:
When you need to coordinate your modifications with those of another person, working on their repository adds an additional level of complication. This is how I handled the situation:
1.Forking and Cloning: Initially, I forked the repository to my GitHub account before cloning it to my local computer. As a result, I had my own copy of the project to work on.
2.Branching: Using branches, I made a new branch for my work, making sure the name was appropriate and reflected the task I was working on. Clarity was maintained by using naming conventions like "issue-6" or "config-file".
3.Regular Pushes: I frequently pushed my branch to my fork in order to keep my work current on GitHub and to keep a copy of my improvements.

4.Draft Pull Request: Early on in the process, I made a Draught Pull Request. Draught PRs are wonderful for work in progress since they let me keep adding fresh commits while also asking the repository owner for comments.
5.Communication: It was essential to have good communication with the repository owner. I updated the GitHub issue, asked questions, and talked about any problems or ambiguities that came up during development.
Git Problems and Learning Challenges encountered and solutions:
Although the procedure was largely straightforward, using Git remotes did provide some difficulties:

•Managing Merge Conflicts: When people work together on a project, merge conflicts can arise. When you and the repository owner make modifications to the same files, these conflicts may occur. Clear communication and coordination with the owner are crucial to resolving this. Collaboration was used to resolve disagreements and guarantee that both sets of improvements were easily incorporated into the final codebase.

•Tracking Branches Updating: I had to use git pull name-of-student> branch-name> to keep my local tracking branch current with the modifications the repository owner made. This made sure that my branch had the most recent updates.

What I Would Change Looking back, I would place even greater emphasis on proactive contact with the repository owner. Teamwork is at the heart of collaboration, and regular updates and debates can promote more orderly growth.

Main Points
In a team setting, developing a new feature taught me numerous important lessons.

1.Effective Communication: When working with others, especially when making modifications to their codebase, it's critical to communicate clearly and promptly.

2.Git Mastery: Working with Git remotes may initially appear difficult, but with practice it becomes more manageable. Don't be afraid to ask for assistance if you run across problems.

3.Planning and Problem-Solving: The development process can be made simpler by thoughtful planning, comprehension of the existing codebase, and the selection of the appropriate libraries.

4.Teamwork: Collaboration is about working together, and it's a fulfilling experience when you can add your expertise to a project to make it better.
Conclusion
In conclusion, it was difficult and satisfying to add a TOML configuration file functionality through collaborative development to a repository. It not only taught me technical skills but also the value of cooperation and clear communication. I'll apply these principles I've learned as a developer as I continue to advance, promoting teamwork and developing my problem-solving abilities as I go.

Building a "Today I Learned" (TIL) Tool in Python

alikhan1998 — Sun, 17 Sep 2023 17:55:08 +0000

Introduction

In the realm of programming and open source development, the concept of "Today I Learned" or TIL posts has gained significant popularity. These posts serve as a means to share bite-sized nuggets of knowledge and insights discovered during various technical endeavors. Beyond its utility in disseminating knowledge to others, TIL posts also serve as personal repositories of learning for future reference.

This article embarks on the journey of constructing a straightforward command-line TIL tool in Python. The tool's primary function is to transform Markdown files into HTML format, facilitating the sharing of newfound wisdom on the web.

Prerequisites

Before we dive into the technicalities, let's ensure we have the prerequisites in place:

A working installation of Python.
A fundamental grasp of Python programming.
Familiarity with Markdown, a lightweight markup language.

Step 1: Language Selection

Our first task involves choosing an appropriate programming language for our TIL tool. We've opted for Python, primarily due to its simplicity and the availability of libraries catering to Markdown and HTML processing. However, you're welcome to use a language of your preference if you're more comfortable with it.

Step 2: Project Initialization

To kickstart our project, we initiate a GitHub repository to facilitate version control and collaboration with fellow developers. If you're new to GitHub, don't worry; you can refer to GitHub's comprehensive guide on creating a new repository.

Upon establishing the repository, it's essential to include a license file (e.g., MIT) and craft a detailed README.md to comprehensively document the project's purpose and usage.

Step 3: Implementing Core Functionality

The heart of our TIL tool revolves around executing the following key functions:

Parsing command-line arguments to specify input files and output folders.
Reading the content of input Markdown files.
Transforming Markdown to HTML using the markdown library.
Writing the HTML content to corresponding output HTML files.

Our Python script encapsulates these functionalities. Here's a simplified version:

import os
import argparse
import markdown

# Function to convert Markdown to HTML
def convert_to_html(markdown_text):
    # Convert Markdown to HTML
    html_content = markdown.markdown(markdown_text)
    return html_content

# Function to process a single input file
def process_file(input_file, output_folder):
    # Read the content of the input file
    with open(input_file, 'r') as file:
        markdown_text = file.read()

    # Convert Markdown to HTML
    html_content = convert_to_html(markdown_text)

    # Create the output file path
    input_filename = os.path.basename(input_file)
    output_file = os.path.join(output_folder, input_filename.replace('.txt', '.html'))

    # Write the HTML content to the output file
    with open(output_file, 'w') as file:
        file.write(html_content)

# Main function
def main():
    # Parse command-line arguments
    parser = argparse.ArgumentParser(description='TIL Tool - Convert Markdown to HTML')
    parser.add_argument('input', help='Input .txt file or folder of .txt files')
    parser.add_argument('-o', '--output', default='til', help='Output directory for HTML files')
    args = parser.parse_args()

    # Create the output folder if it doesn't exist
    os.makedirs(args.output, exist_ok=True)

    # Process the input (file or folder)
    if os.path.isfile(args.input):
        process_file(args.input, args.output)
    elif os.path.isdir(args.input):
        # Process all .txt files in the input folder
        for filename in os.listdir(args.input):
            if filename.endswith('.txt'):
                input_file = os.path.join(args.input, filename)
                process_file(input_file, args.output)

if __name__ == '__main__':
    main()

Step 4: Incorporating Optional Features

While our TIL tool covers the essentials, it can be further enriched with optional features. These include the ability to specify a custom stylesheet, handling titles, and enhancing the visual appeal of generated HTML pages. Depending on your preferences and project goals, you can choose from these optional features provided in the assignment.

Step 5: Testing the TIL Tool

Before sharing your TIL tool with others, rigorous testing is imperative. Create sample TIL posts in Markdown format, and employ your tool to convert them to HTML. It's vital to verify that the generated HTML aligns with your expectations.

Step 6: Documentation and README

A meticulously documented project is indispensable for open source development. Elevate your project's README.md to offer precise instructions on how to harness your TIL tool. Include comprehensive details regarding available features, command-line arguments, and illustrative examples.

Step 7: Publishing Your TIL Posts

Once your TIL tool is fully operational, commence composing TIL posts. Establish a dedicated folder for your TIL posts, pen them in Markdown, and utilize your tool for the transformation into HTML. Subsequently, you can broadcast these HTML files on a website, blog, or platform of your choosing.

Conclusion

Building a Python-based TIL tool is an excellent conduit for disseminating knowledge and discoveries within the community. This project imparts valuable insights into open source development conventions, command-line utilities, and Markdown-to-HTML conversion. Personalize and enhance your tool to augment its utility for your TIL posts.

Happy TIL-ing!

Unlocking EverShop: A Journey into Open Source E-Commerce

alikhan1998 — Tue, 12 Sep 2023 22:52:14 +0000

Greetings, folks!

I go by the name Sher Ali Khan, but you can call me Ali – it's simpler, snappier, and easier to remember. Now, you might be wondering why I've embarked on the OSD600NSA course at Seneca – well, that's a question only the curious minds among you might ask.

Open source, my friends, has always tickled my intellectual taste buds. It's like a global potluck of innovation, where brilliant minds from around the planet converge to cook up a storm of collaborative code for the greater good. Think of it as the coolest party in the tech world – transparent, exclusive (in a good way), and filled with a spirit of innovation that's positively contagious.

Contributing to an open-source gem like EverShop is like embarking on a transformational odyssey of learning. It's not just about sharpening your technical toolkit; it's about crafting your soft skills, embracing the open source ethos, and uncovering a world of development and collaboration you never knew existed. The journey is more profound than lines of code; it's about shaping your career and personal growth.

EverShop, my dear reader, isn't your run-of-the-mill e-commerce platform; it's a bustling community-driven marketplace where e-commerce dreams come to life. With transparency as its guiding star, a welcoming community, and an unwavering commitment to improvement, EverShop is like the friend who's always got your back in the world of open source e-commerce.

So, why would someone like me choose EverShop? Well, it's like a box of goodies from the open source treasure chest: the thrill of openness, the joy of customization, the comfort of a supportive community, the savings of cost-effectiveness, the adaptability of versatility, and the security of a watchful guardian. Whether you're a business maven seeking the perfect e-commerce solution or a coding whiz searching for an open source project to infuse with your brilliance, EverShop beckons as a compelling choice in the bustling e-commerce landscape.

Link: https://github.com/alikhan1998/evershop