DEV Community: Maryam

Triumph in Testing: Enhancing PCGA's Reliability

Maryam — Sun, 10 Dec 2023 20:08:07 +0000

Hello Tech Enthusiasts!

Today, I'm thrilled to announce that I've completed the testing phase for the Proportions Controlling Genetic Algorithm (PCGA). This milestone marks a significant enhancement in the algorithm's stability and reliability.

Mission Accomplished

The journey from planning tests to executing them has been a marathon of learning and problem-solving. Each test added has made PCGA more robust and ready to handle diverse scenarios.

Key Takeaways

Testing has taught me the importance of patience and attention to detail. From simple unit tests to complex integration tests, each step has been crucial in fortifying PCGA.

What's Next?

While the testing phase is complete, the journey doesn't end here. Continuous improvement is key in software development, and I'm already looking forward to the next challenge.

Thank you for joining me on this exciting journey of enhancing PCGA. Here's to many more milestones ahead!

Navigating Through the Testing Maze of PCGA

Maryam — Sun, 10 Dec 2023 20:03:04 +0000

Hi All!

It's time for an update from the testing trenches of the PCGA project. The journey so far has been both challenging and rewarding, and I'm excited to share my progress with you.

Test Development

I've been busy writing a variety of tests. Starting with the simpler helper functions and gradually moving to the more complex core components, each test is like a puzzle piece fitting into the bigger picture of PCGA's reliability.

Challenges Galore

One of the biggest hurdles was testing the private methods. It pushed me to explore and learn more about Python's capabilities and limitations. Every challenge tackled has been a step forward in ensuring the robustness of PCGA.

A Sneak Peek

So far, the tests are doing their job – identifying minor bugs and providing insights for optimization. There's more to be done, but I'm thrilled with the progress.

Stay tuned for more updates, and thanks for following my journey in enhancing PCGA's reliability through testing!

Setting the Stage for Robust Testing in PCGA

Maryam — Sun, 10 Dec 2023 19:58:19 +0000

Hey Everyone!

I'm embarking on an exciting phase in the Proportions Controlling Genetic Algorithm (PCGA) project – the planning of a comprehensive testing strategy. My goal is to ensure the algorithm not only performs as intended but also stands resilient against potential bugs and future enhancements.

Why Testing?

Having worked with PCGA, I realized that while it's powerful, it lacks a safety net. This is where testing comes in – it's like putting on a seatbelt before a thrilling drive.

The Game Plan

My plan is to dissect the algorithm and understand its inner workings. This will help me identify key areas that need testing. From basic unit tests for helper functions to more complex ones for the algorithm's core logic, everything needs to be scrutinized.

A Heads-Up

This phase is all about blueprints and strategies. It's where I lay down a solid foundation for the tests that will shape the future of PCGA. So, stay tuned as I dive into this crucial part of software development!

Journey to the First Release of `tml` - A Markdown to HTML Converter

Maryam — Thu, 23 Nov 2023 15:13:34 +0000

Hello fellow developers and curious minds,

Today, I want to share my journey of releasing tml, a command-line tool designed to convert .txt and .md files into .html format. This blog post will outline the process from choosing a release tool to user testing, aiming to provide a helpful guide for those looking to do the same.

Choosing a Release Tool and Package Registry

For tml, I chose to distribute the package using PyPI, the Python Package Index, which is the de facto package registry for Python projects. PyPI is a repository of software for the Python programming language that helps users find and install software developed and shared by the Python community.

The Release Process

The process began with organizing the project structure. Ensuring that the code was in a state that would be recognized by Python's packaging tools was key. This meant creating a src directory, adding an __init__.py file, and updating the import statements accordingly.

Next, I created a setup.py file at the root of the project. This script is crucial as it contains all the metadata about your package, such as the name, version, author, and dependencies.

With the setup.py in place, the next step was to build the distribution files. I used the following commands:

python setup.py sdist bdist_wheel

These commands create a source distribution and a wheel, respectively. After building the distributions, I uploaded them to PyPI using Twine, a utility for publishing Python packages on PyPI.

The command was simple:

twine upload dist/*

Learning and "Aha!" Moments

Throughout this process, I learned the importance of a well-organized codebase. One of my "aha!" moments was when I realized the significance of the __init__.py files. They may be empty, but they play an essential role in defining package structures.

I also learned about semantic versioning, which is a 3-part system for versioning software in the format of MAJOR.MINOR.PATCH. This was an "aha!" moment as I understood how it helps communicate the scope of changes in a release.

Alterations to Accommodate the Release

Adjusting the project to fit the packaging structure required moving files around, creating new directories, and ensuring the setup.py script accurately represented the project's dependencies and metadata. Thankfully, the alterations were minimal as my code was already modular.

User Testing Session

User testing was an enlightening experience. Watching someone interact with tml without any context exposed some assumptions I had made in my documentation. My tester got stuck on the installation process, as I had omitted the command to install tml from PyPI. After this session, I updated the README.md to clarify the installation and usage instructions.

Installation and Usage Post-Release

Users can now install tml using pip:

pip install tml

Once installed, you can convert files with the following command:

tml <path-to-file>

To specify an output directory:

tml <path-to-file> --output <path-to-output-directory>

The complete instructions are available on the project's README.

In conclusion, releasing tml was a journey filled with learning experiences. I hope that sharing my process will help demystify the release process for other developers. The project is now available for use and contribution, and I welcome any feedback to make tml even better.

Thank you for reading!

Tackling the Button Size Issue in an Open-Source Fitness App

Maryam — Sat, 18 Nov 2023 22:21:46 +0000

Introduction:

Contributing to open-source projects can be an enlightening experience. Recently, I had the opportunity to work on an open-source fitness app, where I faced a unique challenge: resolving the button size inconsistency on the workout screen. In this blog post, I'll share my journey in addressing this issue and how it helped improve the app's user interface.

Getting Started:

My adventure began when I expressed interest in contributing to the fitness app's development. To my delight, the project maintainer promptly assigned me to a task – fixing the button size issue on the workout screen. This experience provided me with valuable insights into open-source collaboration and problem-solving.

Understanding the Problem:

The button size inconsistency was a pre-existing issue that had been affecting the app's usability. As I dived into the project's codebase, I had to familiarize myself with its structure and coding conventions, ensuring that my contributions aligned with the project's existing standards.

Identifying the Culprit:

The primary challenge I faced was locating the specific code responsible for controlling button sizes on the workout screen. The app was built using React Native, and styles were defined using a combination of inline styles and external style sheets. Despite my experience with React Native, pinpointing the exact code affecting button sizes proved to be a bit of a puzzle.

The Solution:

After meticulous code exploration, I successfully identified the root cause of the button size inconsistency. It turned out that some button components lacked consistent size attributes. To resolve this, I added width and height properties to the button styles, ensuring uniformity in button sizes throughout the workout screen.

Appreciation for Feedback:

I am grateful for the opportunity to work on this open-source fitness app and contribute to its improvement. The button size issue may have been a small hiccup, but it served as a reminder of the power of collective contributions. Open source is a vibrant ecosystem where developers come together to create something greater than the sum of its parts.

Conclusion:

My journey of addressing the button size issue in this open-source fitness app was both rewarding and educational. It highlighted the importance of collaboration, problem-solving, and maintaining a consistent user interface. As I continue to contribute to open-source projects, I look forward to more opportunities to make a positive impact on the software development community.

My Journey of Improving the MaweJS Editor's Search Feature

Maryam — Sat, 18 Nov 2023 20:09:37 +0000

Hello, fellow coders and tech enthusiasts! Today, I want to share my recent adventure in contributing to an open-source project, MaweJS. It's a unique story editor tailored for a special kind of writer, blending the spontaneous style of "pantsers" with the methodical approach of "planners." My focus was on a seemingly small but impactful aspect: enhancing the search functionality within its editor.

The Challenge: Balancing Keyboard and Mouse Interactions

The challenge was intriguing: how do you make the search feature more user-friendly, especially for those who prefer using a mouse, without disrupting the flow for keyboard shortcut fans? As a developer, I knew this was about striking a delicate balance between accessibility and efficiency.

The Approach: Clear and Navigate

The solution boiled down to two key enhancements:

Clear Search Button: A simple addition, but what a difference it makes! This button allows users to quickly erase their search query, making the process smoother and more intuitive.
Navigation Buttons: I added two buttons for moving to the next and previous search results. This small change significantly enhanced the user experience, particularly for those who rely on mouse navigation.

Keeping the Old School Charm

In the world of programming, respecting legacy functionalities is as important as innovating. That's why I ensured that all the beloved keyboard shortcuts, like Ctrl-F and Ctrl-G, remained intact and functional. After all, why fix something that isn’t broken?

The Outcome: A More Inclusive User Experience

After thorough testing and tweaking, the new search functionality was ready. The result? A more inclusive and user-friendly search experience that caters to both mouse users and keyboard shortcut lovers. It’s a testament to how small changes can make a big impact on usability.

The Takeaway: It's All About the User

This experience reinforced a vital lesson for me: always keep the user in mind. Whether it's a massive feature overhaul or a minor tweak, the end goal is to enhance the user experience.

Reflections and Looking Forward

As I wrap up this post, I can’t help but feel excited about the future of MaweJS and open-source projects in general. It’s amazing how a community of passionate individuals can come together to create something truly remarkable. And I’m just glad to be a part of this journey.

If you're curious about MaweJS or want to contribute, check out their repository. Let's keep building and improving together!

A Developer's Dive into GitHub Actions CI

Maryam — Fri, 17 Nov 2023 03:52:53 +0000

Introduction

In the developer's toolkit, Continuous Integration (CI) is an essential asset, and GitHub Actions represents a modern approach to this practice. My recent exploration into setting up a GitHub Actions CI workflow for my tml project, and contributing tests to a fellow developer's project, was a journey worth sharing. From YAML configurations to different project structures, here's how it unfolded.

Setting Up GitHub Actions CI

Crafting the Workflow

My project, a text-to-HTML converter named tml, needed a robust way to ensure code quality. Enter GitHub Actions. The setup involved creating a YAML file in the .github/workflows directory, defining the conditions under which the CI pipeline would trigger.

Inside the YAML

The YAML file, named main.yml, was the blueprint. Here’s a peek at its structure:

name: Python application test

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v2
    - name: Set up Python
      uses: actions/setup-python@v2
      with:
        python-version: '3.8'
    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install pytest tomli requests
    - name: Run tests
      run: |
        pytest

This script essentially sets up the environment, installs dependencies, and runs pytest to check the integrity of the codebase.

Experience with a Partner’s Repository

Observing Variations

My partner, also working on a Python project, adopted a different CI strategy. Their setup was tailored to their specific project needs, employing Python's latest versions and its native testing frameworks. This divergence highlighted the flexibility of GitHub Actions, accommodating various workflows and testing strategies.

Writing Tests for Different Setups

Contributing tests to a project I didn't initially create was both challenging and rewarding. It demanded a deep dive into understanding another developer's logic and code structure. This process emphasized the importance of writing clear, maintainable code and tests in collaborative environments.

Reflecting on CI in Development

CI as a Unifying Force

Despite the differences in our CI setups, the essence of CI remained consistent – automating the testing process to maintain high code quality. My experience highlighted CI's role as a unifying force in software development, adaptable to different environments yet consistently ensuring reliability.

The Learning Curve and Benefits

The initial setup of CI was a learning curve, involving understanding YAML configurations and troubleshooting workflow issues. However, the benefits became quickly apparent – CI acts as a safeguard, catching issues early and providing peace of mind with each new code integration.

Conclusion

Setting up and experiencing GitHub Actions CI in my own project and observing a different approach in my partner's project was an enlightening experience. It underscored the versatility of CI tools and the importance of automated testing in modern software development. As I continue my development journey, the lessons learned from this experience will undoubtedly shape my approach to coding and collaboration.

Easy Testing in Python with pytest

Maryam — Wed, 08 Nov 2023 19:49:53 +0000

Hi friends in code!

I've been tinkering with testing in Python using a super handy tool called pytest. It’s a straightforward way to check that your code is doing its job correctly. I want to share my journey, and perhaps you'll get the testing bug too (the good kind)!

Why pytest?

For my project, pytest turned out to be a no-brainer. It’s user-friendly for both new and seasoned coders and packs a punch in utility. You can learn more about pytest and what it can do for you by visiting pytest's documentation.

Setting Up the Scene

Getting pytest up and running was like prepping a new gadget — do it once, and you reap the benefits every time thereafter. Here's what I did:

Installation: I added pytest to my virtual environment using pip install pytest.
Organizing Tests: All my test files found their home in a tests directory, neatly packaged and easy for pytest to recognize.
Writing Tests: Crafted each test with the attention it deserves, ensuring they interrogate my code in all the cunning ways I could muster.
Running the Show: A simple pytest command in my terminal and voila, it's showtime for testing!

Learnings and Surprises

The Lightbulb Moments

Setting up test "fixtures" felt like unlocking a new level in a game. It prepared my test environment in a snap.

The Bug Hunt

Yes, I encountered bugs — sneaky ones that played hide and seek with file names and logic. But catching them was oddly satisfying.

The True Value of Testing

I used to push testing aside, but not anymore. It's an investment in the sanity of your future self and the clarity for anyone who picks up your code.

Contributing to the Garden

I also updated the CONTRIBUTING.md in my project repository with instructions on how to use pytest for any new contributors. It’s a small step towards collective code quality and helps maintainers understand how to run and write tests, ensuring everyone’s on the same page.

In Conclusion

Imagine pytest as a compass for your coding journey. It points you in the right direction and ensures you don't lose your way. If you haven't begun testing, now's a great time to start. It's not just about finding bugs; it’s about creating a map for others to follow in your footsteps with confidence.

Take the plunge, start with pytest, and you might just find it’s a key part of your development toolkit.

Happy coding!

Making Coding Easier: My Story with Cool Coding Tools

Maryam — Sat, 04 Nov 2023 23:16:00 +0000

Hi everyone! I want to share my story about making coding a lot easier and more fun with some cool tools.

The Tools I Used

Prettier

Think of Prettier like a broom that sweeps your code and makes it look neat. It's not usually used for Python, the language I write in, but with a special add-on, it can tidy up Python code too.

Flake8

Flake8 is like a friendly teacher who points out where you might have slipped up in your Python homework. It tells you about little mistakes and helps you write better code that looks good and follows the rules.

Visual Studio Code

VSCode is like my digital toolbox. It lets me write and fix code, and I can add all sorts of tools to it, like Prettier and Flake8, to make coding easier.

Setting Them Up

First, I set up Prettier to make sure my code lines are all nice and even. Then I put Flake8 in place to catch mistakes and keep everything super clean. I even made sure they both work right inside VSCode, so I can see and fix problems on the fly, just like autocorrect when you're typing a message.

Fixing Up My Code

When I got these tools working, they showed me a few spots where my code was a bit messy or could be better. I fixed those up, and now the code looks great and is easy to read.

Running the Tools Without a Hassle

To check my code, I can type a few words into my computer's command line (like asking it to do a quick check-up) and see if anything needs fixing. It's like having a spellchecker for coding.

Making Them Work With My Toolbox

I told VSCode to use these tools to tidy up my code every time I save a file, just like how your phone fixes typos automatically.

What I Learned

Having tools to clean up your code is awesome because it saves you time and helps you write better code.
Putting these tools right into the editor means less jumping around between programs.
Spending a bit of time to set things up makes everything easier later.

That's it! Using these tools was like getting a helping hand that's always there to make sure I write code that not only works but is also clean and easy for others to understand.

Introducing Link Management Inspired by Docusaurus

Maryam — Sun, 29 Oct 2023 17:44:46 +0000

Hello, friends! Today, I'd like to tell you about a new feature I made for my tool. I was really inspired by how Docusaurus, a popular tool, does things. Let's dive in!

What's My New Thing?

I made a new part for my tool. It does two main things:

Looking at Links: It looks at all the links in a piece of writing to see if they work.
Finding Broken Links: If a link doesn't work, my tool will tell you!

Docusaurus Gave Me an Idea!

Docusaurus is like a big brother tool. It has a smart way to handle links in writings. After seeing how Docusaurus works, I got an idea for my tool.

How Are They Alike?

Remember when we talked about this before? Here's how the two are alike:

1. Checking Links:

Docusaurus: Docusaurus checks every link to make sure it works.
My Tool: My tool does the same thing. It checks every link to see if it's correct.

2. Telling You About Bad Links:

Docusaurus & Our Chat Before: Docusaurus will tell you if a link is broken.
My Tool: My tool does that too! If a link is broken, it will let you know.

That's my story of how I made a new part for my tool. It's like giving it a new toy to play with. Thanks, Docusaurus, for the cool idea! And thank you for joining me on this fun journey.

you can find the code I got inspired by here
My Tool

Understanding How Docusaurus Fixes and Checks Your Links: A Simple Explanation

Maryam — Sat, 28 Oct 2023 18:32:30 +0000

What We’re Talking About Today

When you’re creating a website, especially one that holds a lot of information like a documentation site, it’s really important that all the links (you know, those clickable texts that take you to another page) work well. Today, we’re exploring a part of Docusaurus, a tool that helps people create these websites, which makes sure all your links are in good shape.

Quick Overview: What’s This Feature All About?

Imagine you’re organizing a big book with lots of chapters and pages. Some pages talk about other pages, and you want to make sure that when you say “Hey, look at Page 5 for more info,” Page 5 really has that info. Docusaurus does this for websites. It checks all your "Hey, look over there" directions (or links) to make sure they actually go to the right place.

How It’s Done: Looking at the Code

The Gatekeeper: `index.ts`

Think of index.ts as the front door. Every time you want to add or change something on your website, it needs to go through this door. What it does for links is simple: it takes them, hands them over to a helper (another piece of code) named linkify, and says, “Make sure these links go to the right place, will you?”

The Helper: `linkify.ts`

linkify is where the real action happens. It’s like having a smart assistant. You give it a bunch of directions (links), and it goes through each one, making sure they go to the right page. If it finds a direction that’s broken or goes nowhere, it takes a note and tells you, “Hey, this one’s not right!”

What I Learned and Found Tricky

Reading through this code felt a bit like solving a puzzle. It’s written in a special computer language that’s very precise, and it’s meant to do its job super efficiently.

Learning to Be Precise: I saw how important it is to be super precise and clear when giving instructions to computers.
Dealing with Mistakes: I loved seeing how the code is ready to find and point out mistakes, making sure everything runs smoothly.
Understanding the Language: Sometimes, the language of the code was a bit like learning a new language. But with some patience, it started making sense!

How I Figured It Out

Reading code can be like trying to understand a recipe written by a master chef. You might not get everything at first, but with some time and maybe a bit of help from Google or friendly tools like ChatGPT, it starts to make sense.

Wrapping It Up

So, that’s my adventure in Docusaurus’s world of fixing and checking links! It’s a bit like having a super-smart librarian in a giant library, making sure every “This book is over there” sign actually points to the right book. And that, my friends, makes finding and using information a whole lot easier and more fun!

My Open Source Adventure: A Friendly Recap

Maryam — Thu, 26 Oct 2023 15:36:51 +0000

My Open Source Adventure: A Friendly Recap

Hello, friends! 👋 I've been on some fun coding adventures recently, and I can’t wait to tell you all about them. Grab a cup of coffee, and let’s chat!

1. Tidying Up the Uno Platform 🧹

What I Did: Found two methods, RestoreBindings and ClearBindings, that weren’t doing anything and removed them.
The Learning Part: Got to know the Uno Platform really well, especially how it connects different parts of programs.
The Tough Part: Making sure that taking away these methods didn’t mess up anything else because the Uno Platform is huge!

2. Making Podcast Words Better 🎙

What I Did: Fixed up the text version of a podcast to make sure it matched exactly what was said.
The Learning Part: My grammar skills got a nice workout, and I learned some new techy words.
The Tough Part: Had to listen super carefully to the podcast, sometimes more than once, to catch every word.

3. Making the Curio Logo Clickable 🖱

What I Did: Made it so when you click on the Curio logo, it actually takes you back to the home page.
The Learning Part: Felt really part of the coding community and loved making the website nicer for users.
The Tough Part: The challenge was just right, but it was my friend who gave me the nudge to jump in and try.

4. Helping with the Python Port Scanner 🔍

What I Did: Made error messages clearer and gave better feedback during scans.
The Learning Part: Got even better at Python and learned heaps about network scanning.
The Tough Part: Focusing on making the tool super user-friendly and helpful.

To Wrap It Up

And that’s my story! I had heaps of fun, learned a lot, and it felt awesome to help out. Open source is all about everyone chipping in, and I’m stoked to be part of that. Thanks for reading, and happy coding! 🎉

DEV Community: Maryam

Triumph in Testing: Enhancing PCGA's Reliability

Navigating Through the Testing Maze of PCGA

Setting the Stage for Robust Testing in PCGA

Journey to the First Release of `tml` - A Markdown to HTML Converter

Choosing a Release Tool and Package Registry

The Release Process

Learning and "Aha!" Moments

Alterations to Accommodate the Release

User Testing Session

Installation and Usage Post-Release

Tackling the Button Size Issue in an Open-Source Fitness App

Introduction:

Getting Started:

Understanding the Problem:

Identifying the Culprit:

The Solution:

Appreciation for Feedback:

Conclusion:

My Journey of Improving the MaweJS Editor's Search Feature

The Challenge: Balancing Keyboard and Mouse Interactions

The Approach: Clear and Navigate

Keeping the Old School Charm

The Outcome: A More Inclusive User Experience

The Takeaway: It's All About the User

Reflections and Looking Forward

A Developer's Dive into GitHub Actions CI

Introduction

Setting Up GitHub Actions CI

Crafting the Workflow

Inside the YAML

Experience with a Partner’s Repository

Observing Variations

Writing Tests for Different Setups

Reflecting on CI in Development

CI as a Unifying Force

The Learning Curve and Benefits

Conclusion

Easy Testing in Python with pytest

Why pytest?

Setting Up the Scene

Learnings and Surprises

The Lightbulb Moments

The Bug Hunt

The True Value of Testing

Contributing to the Garden

In Conclusion

Making Coding Easier: My Story with Cool Coding Tools

The Tools I Used

Prettier

Flake8

Visual Studio Code

Setting Them Up

Fixing Up My Code

Running the Tools Without a Hassle

Making Them Work With My Toolbox

What I Learned

Introducing Link Management Inspired by Docusaurus

What's My New Thing?

Docusaurus Gave Me an Idea!

How Are They Alike?

1. Checking Links:

2. Telling You About Bad Links:

Understanding How Docusaurus Fixes and Checks Your Links: A Simple Explanation

What We’re Talking About Today

Quick Overview: What’s This Feature All About?

How It’s Done: Looking at the Code

The Gatekeeper: index.ts

The Helper: linkify.ts

What I Learned and Found Tricky

How I Figured It Out

Wrapping It Up

My Open Source Adventure: A Friendly Recap

My Open Source Adventure: A Friendly Recap

1. Tidying Up the Uno Platform 🧹

2. Making Podcast Words Better 🎙

3. Making the Curio Logo Clickable 🖱

4. Helping with the Python Port Scanner 🔍

To Wrap It Up

The Gatekeeper: `index.ts`

The Helper: `linkify.ts`