Tag: Personal Growth

Posted on

Passwords, Please: Why Your Cat’s Name Isn’t Good Enough

Day 26 of 100 Days Coding Challenge: Python

As someone who is doing accounting for a living—and not just the easy kind, mind you, but the multi-state, bank-reporting, ERP-wrangling kind—I juggle more passwords than a magician with trust issues. At last count, I had around near 20 different passwords scattered across platforms like SAP, Microsoft, banks, state websites, and yes, even the mysterious beast that is Windows.

Now, an ERP system like SAP doesn’t mess around. It demands long, complex passwords that look like someone accidentally fell asleep on the keyboard. So, I figured—if I can understand how these systems judge password strength, maybe I can outsmart them. Or at least, use the same logic to fortify my Amazon or bank logins. I mean, no one’s hacked me (yet), but why wait for disaster when I can beat the bots at their own game? Today’s mission: test the strength of my passwords using Python. Because if I can calculate depreciation schedules, I can definitely calculate how weak “Fluffy2021!” really is.

Today’s Motivation / Challenge

Let’s face it—most of us are one sticky note away from giving up on remembering our passwords. That’s what makes today’s project kind of brilliant: instead of memorizing 27 variations of “qwerty123!”, we’re learning to evaluate passwords for strength. It’s a practical tool with just enough spy-movie flair to feel exciting. Plus, there’s something satisfying about making a program that judges your passwords before a hacker does.

Purpose of the Code (Object)

This simple program acts like a personal password bouncer. You hand it a password, and it tells you whether it’s weak, moderate, or strong. It does this by checking for things like length, numbers, special characters, and uppercase letters—basically the same stuff most secure systems look for, minus the scolding tone.

AI Prompt:

Create a Python program that evaluates password strength based on length, use of uppercase and lowercase letters, digits, and special characters. Return a score and give user-friendly feedback.

Functions & Features

  • Checks password length and gives points accordingly
  • Evaluates if you used uppercase + lowercase letters
  • Looks for numbers and special characters
  • Provides a strength rating: Weak, Moderate, or Strong
  • Offers suggestions to improve your password

Requirements / Setup

You’ll need:

Python 3.x

No extra libraries needed. Just plug and play.

Minimal Code Sample

import re

def check_strength(pwd):

    score = 0

    if len(pwd) >= 12: score += 2

    if re.search(r'[A-Z]’, pwd) and re.search(r'[a-z]’, pwd): score += 1

    if re.search(r’\d’, pwd): score += 1

    if re.search(r'[!@#$%^&*]’, pwd): score += 1

    return score

This snippet scores a password based on length and character variety.

Password Checker GUI

Notes / Lessons Learned

The program was surprisingly easy to write—and even easier to obsess over. It’s just a few if-else checks and a running score tally, but the real fun starts when you feed in your actual passwords. I tried mine. Every single one came back as “Moderate.” Not “Weak,” which was a relief, but not “Strong” either. Apparently, I’m living in the password middle class. Turns out, all I need is a few more letters or symbols to boost my score. So maybe it’s time to retire “Fluffy2021!” and embrace something like “S@pTaxQueen2025.” Catchy, no?

Optional Ideas for Expansion

  • Add a live strength meter (green/yellow/red bar) using Tkinter for a GUI
  • Store password feedback history in a CSV for tracking
Day 25
Day 27

Posted on

Ending It Nearly Completed All Tasks With Time Management Skills

Brian’s fitness journal after a brain stroke

Today, I forced myself out of bed—feeling surprisingly rested and recovered—but immediately remembered one inconvenient truth: it was cold. Very cold. Cold enough to make running sound like a poor life choice. Still, I started my day on time.

I checked the weather app and plotted the optimal moment for my run like a general preparing for battle. Cold-weather gear would be required, but I could afford to wait a bit for marginally better conditions. Unfortunately, waiting too long wasn’t an option—I had a long list of chores left over from yesterday.

Thanksgiving 2025 was a genuinely lovely family gathering. The food was excellent. The company was even better. But holidays have a way of borrowing time from the future, and today was the repayment day. With a full slate of chores waiting, time management suddenly mattered a lot.

Despite my worry that I’d overworked the evening after returning from my sister’s house yesterday, I managed to power through. As soon as we got home, I transferred clothes from the washer to the dryer, then went upstairs to finish the dishes while the kombucha water boiled. Multitasking isn’t glamorous, but it’s effective.

Once those tasks were underway, I checked the dryer timer and realized I had just enough time to eat a piece of leftover pizza before the next wave of responsibilities arrived. On days like this, I have to work systematically—doing the task that fits into the gaps while something else runs in the background.

When the laundry finished, I folded and put away everything except the sheets. Those had twisted themselves into an impressive knot and hadn’t fully dried, so they earned another spin in the dryer and a postponement until tomorrow. At that point, the sheer volume of tasks was starting to feel heavy.

By the time I finally stopped moving, I was completely exhausted and very ready for sleep.

My Time Management Method

To manage days like this, I rely on task chains—doing one thing that naturally leads to the next—so I don’t have to hold everything in my head at once. These are coping strategies I’ve learned since my brain stroke. When your brain has been injured, remembering things isn’t automatic. Systems matter.

Out of curiosity, I checked on my wife. She’s been off since Wednesday and will be until the end of the week, which usually means more chores—not fewer. But she had already completed most of her tasks yesterday, knowing how packed the week before our family gathering had been. Planning ahead: her specialty.

I’m still working on my time-management skills. But today, I got most of what needed to be done—and that’s good enough. The rest can wait until tomorrow. Progress doesn’t always look energetic.
Sometimes it looks like finishing the day tired—and still satisfied.

Back
Posted on

Shrink Me, Baby, One More Time

Day 25 of 100 Days Coding Challenges: Python

When I post a blog, there’s always that option to clean up the slug and make the URL look like it spent a summer at finishing school. I’ve done it occasionally—shortened a few links here and there like trimming bangs on a whim—but I never committed. I wasn’t sure if it really made a difference, or if I was just breaking up with my beautifully descriptive blog titles for no good reason.

But here’s the thing: shorter URLs are easier to share, easier to remember, and—let’s be honest—they just look more confident. Like a blog post that walks into a party and knows exactly where the snacks are. How about I create my own Python URL shortener script?

So I stopped overthinking and built a Python script to handle URL shortening. It’s a humble subroutine for now, but it could easily become part of a larger “Blog Publishing Flow”—one that’s as sleek as my ambition to automate everything, including procrastination.

Today’s Motivation / Challenge

Ever copy-paste a long blog URL into a text, only to watch it stretch across the entire message like it’s trying to steal the spotlight? Me too. Today’s challenge was about making my blog links compact and elegant—like a haiku for URLs. Plus, I wanted a reusable, no-fuss script I could tuck into my content workflow.

Purpose of the Code (Object)

This little Python script takes a long URL and turns it into a neat, short version using the TinyURL service. It’s a great way to tidy up links before sharing them on social media, email newsletters, or in text messages to your less tech-savvy relatives who panic when they see a string with too many slashes.

AI Prompt:

Create a Python script to clean up my URL code.

Functions & Features

  • Takes any valid URL and returns a shortened version
  • Uses the TinyURL API (via pyshorteners) to handle the shortening
  • Simple enough to run as a subroutine in a larger automation flow

Requirements / Setup

pip install pyshorteners

Works on Python 3.6 and above.

Minimal Code Sample

import pyshorteners

def shorten_url(long_url):

    return pyshorteners.Shortener().tinyurl.short(long_url)

# Example usage:

print(shorten_url(“https://yourblog.com/very/long/descriptive/link”))

This function takes your long-winded link and trims it into something social-media-ready.

Console URL Shortener

Notes / Lessons Learned

I tested it using one of my husband’s blog posts:
https://kaizennekoproject.com/the-case-of-the-missing-kilometers-a-summer-running-mystery/
It transformed into:
https://tinyurl.com/2y8vt6v5

Yes, it’s shorter—but now I can’t immediately tell what the post is about: running, whether rue crime; or a mileage-based ghost story.

And then the SEO question popped into my head like a banner ad: Does a shorter link help me show up in search results? Spoiler: probably not—at least not when using a third-party shortener. I still have some investigating to do. But the code itself? It works. And sometimes, finishing something is more satisfying than overthinking it.

Optional Ideas for Expansion

  • Add a clipboard copy feature to automatically copy the short URL
  • Let users choose their shortener service (e.g., Bit.ly, is.gd)
  • Build a simple Tkinter GUI for those who like buttons more than typing

Day 24
Day 26

Posted on

Thought Keeper: A GUI Journal App for Your Inner Monologue

Day 24 of 100 Days coding Challenge: Python

Growing up, I was that kid who scribbled thoughts into any notebook I could find—even the back of my math homework. Writing was my thing. But journaling? That felt too… reflective. It took a few years (and a few existential crises) before I warmed up to the idea.

Now, I journal every day—usually with pen and paper, in my own cryptic shorthand. No one’s supposed to read it (and frankly, no one could). But writing helps me think about how I think.

What motivates me, what annoys me, what I pretend not to care about but actually do. Today, I decided to take that analog habit and try building a digital version—my own daily Python journal app. Less ink smudging, more save buttons.

Today’s Motivation / Challenge

There’s something meditative about journaling—until you forget where you left your notebook… again. I wanted to create a simple desktop app that captures those thoughts without needing a physical page. The goal? Combine my love for writing with my desire to build something functional, cozy, and just retro enough to feel like a Windows 95 flashback.

Purpose of the Code (Object)

This little project creates a journal app with a user-friendly window where you can type your thoughts and click “Save” to store them. Each entry is saved in a file named by date, organized neatly in a folder. It even includes a menu bar—just like those old-school apps—with options to save or exit the program.

AI Prompt:

“Create a GUI journal app in Python using tkinter. Include a menu with Save and Exit options. Journal entries should be saved to a dated text file in a folder.”

Functions & Features

  • Opens a clean text window for writing your journal entry
  • Saves entries to a daily .txt file with a timestamp
  • Automatically organizes files in a journals/ folder
  • Includes a classic File menu with “Save Entry” and “Exit” options

Requirements / Setup

  • Python 3.x
  • No external libraries needed—just good ol’ tkinter (which comes with Python)

Minimal Code Sample

def save_entry():

    text = text_area.get(“1.0”, tk.END).strip()

    if text:

        with open(get_journal_filename(), “a”, encoding=”utf-8″) as file:

            file.write(f”\n[{datetime.now().strftime(‘%H:%M’)}]\n{text}\n”)

This function grabs the typed text and saves it with a timestamp to a dated file.

Python Encrypted Diary

Notes / Lessons Learned

I started with a no-frills version that ran in the terminal. It was basic—you hit “Enter” twice to save, which felt like submitting your soul to the void with no takebacks. Naturally, I couldn’t resist making a GUI. But my first try was a mystery: the “Save Entry” button vanished like my motivation on a Monday. Turns out, I’d set the window height too short (root.geometry(“500×400”)), hiding the button like a shy turtle. Bumping it up to 500×600 fixed it.

Then I got bold—scrapped the button and added a File menu like a proper ’90s app. “File > Save Entry” and “File > Exit” made it feel almost professional. While I still prefer scribbling on paper, this app could easily be adapted as a task logger or even a minimalist idea tracker. Plus, it was fun building something that looked like software from a time when dial-up internet still screamed.

Optional Ideas for Expansion

  • Add keyboard shortcuts (Ctrl+S to save, Ctrl+Q to quit)
  • Include a date-picker to view or edit past entries
Day 23
Day 25

Posted on

Sore Quads, Smart Squats, and Rethinking My Training

Brian’s fitness journal after a brain stroke

I’ve been running for nearly a decade. A few years ago, I added resistance training. And yet—brace yourself—there’s one thing I somehow never did: leg strength training.

Yes, I run. A lot. I convinced myself that running was leg day. Turns out, that logic only works until it doesn’t—usually in the form of injury. Somewhere along the way, it finally clicked: runners also need resistance training for their legs.

My wife has known this all along.

She does resistance training six days a week, and she works her legs especially hard. Her reasoning is simple: cardio doesn’t fully train leg strength. Recently, she’s taken it even more seriously, and the results are obvious. Her legs are noticeably stronger than before.

So I made a decision.
I would join leg day—late, but sincere.

I introduced squats into my routine, and my quadriceps responded immediately by filing soreness reports. That’s how I know something new is happening. I do have to be careful, though. Once a week, I already run 10 kilometers, and our neighborhood is aggressively hilly. My legs aren’t exactly underworked.

Still, the soreness tells me something important: I’m using muscle fibers that running alone doesn’t reach. Whether increasing strength first will eventually improve my speed is still an open question—but early signs suggest I’m on the right path.

As with everything else, I’m introducing this change slowly. My kidney condition limits how much protein I can consume, so I can’t afford to destroy too many muscle fibers at once. At the same time, muscle growth requires some breakdown. Balancing those two realities is the real workout.

To stay honest, I track my biometrics using our scale—water percentage, protein, bone mass, muscle mass, weight—and I cross-check all of that with quarterly blood work. Numbers don’t lie, even when motivation does.

For now, the goal isn’t speed.
The goal is durability.

I’ll continue monitoring, adjusting, and easing leg exercises into my routine over the next few months. After nearly ten years of running, it seems only fair to finally give my legs the attention they deserve—outside of just asking them to carry me uphill.

Back

Posted on

How to Build a Python Email Validator (That Actually Catches Your Typos)

Day 23 of 100 Days Coding Challenge: Python

Today, I built a Python Email Validator, and this is why I got my inspiration.

A long time ago—back when dinosaurs roamed the earth and PDF forms were considered cutting-edge—I managed to sabotage my own job application by giving them the wrong email address. Not wrong like a typo. Wrong like “here’s someone else’s inbox, enjoy!” The form was printable, fillable, but still very much analog when it came to submitting. I only realized my blunder when I sat waiting for a reply that never came. Cue a long, awkward phone call to the admissions office where I had to prove I was me—without sounding like a scammer. They had to resend the link. I had to verify my identity. It was a whole saga. So today, I’ve decided to write a simple email validator. Nothing too fancy—no AI, no spam filters, just the basic “Is this an actual email address or did your cat walk across your keyboard?” kind of check.

Today’s Motivation / Challenge

Let’s be real: checking whether an email is valid feels like it should be automatic—and these days, it often is. But behind that little red warning that says “please enter a valid email” is a small, mighty piece of logic. Today’s project is about building that logic yourself, understanding how to spot a bad address before it sneaks into your system and causes a customer service meltdown. It’s a nod to every web form you’ve ever cursed at.

Purpose of the Code (Object)

This program checks whether the email address someone typed in looks like a real email. That’s it. No email is actually sent—just a quick format check to catch things like missing “@” symbols or suspiciously dot-less domains. It’s like a bouncer for your inbox: if you don’t look the part, you’re not getting in.

AI Prompt:

Write a simple email validation program in Python using regular expressions. The program should have a function that takes an email address and returns whether it is valid. Include a basic GUI using Tkinter where users can input their email and get immediate feedback.

Functions & Features

  • Accepts user input via a graphical interface
  • Validates email format using a regular expression
  • Provides instant feedback: “Valid” or “Invalid”
  • Friendly UI with no command line needed

Requirements / Setup

Python 3.x (Tkinter is included by default)

No pip installs needed!

Minimal Code Sample

import re

def is_valid_email(email):

    return re.match(r’^[\w\.-]+@[\w\.-]+\.\w+$’, email)

This function checks if the email follows the basic format: name@domain.extension

Python Email Validator GUI

Notes / Lessons Learned

I thought this code would be a tangled mess of symbols, but it’s surprisingly short and sweet. Here’s the kicker: when I typed xxxxx@mail.com instead of xxxxx@gmail.com, it still counted as valid. So did hello@whatever.io. But hello@gmail? Nope—no dot, no go. It turns out, this kind of validation only cares about structure. It doesn’t know or care whether the domain actually exists—it just wants to see an “@” followed by some dots in the right places. It’s like someone who judges whether a movie is good based only on the poster.

Optional Ideas for Expansion

  • Add a domain blacklist to reject shady or disposable email providers
  • Highlight formatting errors as you type (e.g., missing “@” or extra spaces)
  • Connect to an email verification API for real-time existence checks

Day 22
Day24

Posted on

Punkt Happens: A Throwback to Pre-AI Summarizing

Day 22 of 100 Days Coding Challenges: Python

I woke up today with a peculiar mission: build a text summarizer without relying on AI. Yes, I willingly traveled back in time—back to the days before ChatGPT could just nod and condense a thousand words into ten. Why? Curiosity, mostly. I wanted to know how the old-school extractive methods worked. Spoiler alert: they’re kind of charming in their own clunky way.

Did it work on the first try? Of course not. I wrestled with broken libraries, mysterious errors, and one particularly judgmental error message about “punkt_tab” that seemed to imply I should know what that is. I wrote one version, then another. Tried a different library. Threw a mini tantrum. Eventually, I ditched NLTK entirely, kicked open the spaCy door, and got a summarizer working. Is it perfect? Nope. Is it lovable in its quirky way? Absolutely.

Today’s Motivation / Challenge

You ever read something and think, “Wow, that could’ve been a tweet”? That’s the spirit behind today’s project. Summarizing text is a superpower—whether it’s for condensing long articles, making notes from journal entries, or just helping your brain cope with too much information. While AI can do it effortlessly now, building one from scratch is like learning to cook pasta before using a microwave: humbling but worthwhile.

Purpose of the Code (Object)

This code takes a chunk of text and extracts the most important sentences. Instead of “understanding” like AI, it just finds which words show up the most and grabs the sentences that use them. It’s a bit like highlighting the loudest parts of a conversation and calling it a summary—but hey, it kind of works.

AI Prompt:


“Write a Python program that summarizes text using classical NLP techniques. Do not use deep learning. Use word frequency and sentence scoring instead.”

Functions & Features

  • Tokenizes text into words and sentences
  • Removes common words like “the” and “is” (stopwords)
  • Scores sentences based on word importance
  • Extracts and returns the top N sentences as a summary

Requirements / Setup

pip install spacy  

python -m spacy download en_core_web_sm

Minimal Code Sample

python

CopyEdit

doc = nlp(text)

sentences = list(doc.sents)

word_freq = {word.text.lower(): word_freq.get(word.text.lower(), 0) + 1 for word in doc if not word.is_stop and not word.is_punct}

summary = ‘ ‘.join([sent.text for sent in heapq.nlargest(3, sentences, key=lambda s: sum(word_freq.get(w.text.lower(), 0) for w in s))])

This grabs the top 3 most important sentences using word frequency as a guide.

Spacy Text Summarizer GUI

Notes / Lessons Learned

Oh, the joys of punkt_tab. Today’s real adventure was less about Python logic and more about survival. The original plan was to use NLTK—but it had other ideas. It kept yelling at me about a missing “punkt_tab” resource, which sounded more like a 90s German punk band than a tokenizer. I redownloaded, wiped caches, and whispered sweet nothings to the command prompt. Nothing.

Eventually, I gave up and pulled in spaCy instead—and guess what? It just worked. Sometimes, letting go of the buggy route is the bravest choice. Along the way, I learned how to uninstall libraries cleanly, delete hidden cache folders, and even navigate the Windows file system like a seasoned hacker. It didn’t summarize exactly like a human or an LLM, but it got the job done. And now, I’m much more confident using Python from the command line. NotebookLM still wins at summarizing, but my little app gets a gold star for effort.

Optional Ideas for Expansion

  • Let the user choose how many sentences they want in the summary
  • Add a “read from file” button so you can summarize documents directly
  • Highlight the summary sentences in the original text to show what was picked
Day 21
Day 23

Posted on

When I Optimized for Temperature and Forgot About Time

Brian’s fitness journal after a brain stroke

This morning, I made what felt like a perfectly reasonable decision: stay in bed a little longer because it was cold. Very cold. Also, there was no immediate pressure to run—it wasn’t even close to the warmest part of the day yet.

This logic was flawless.
Unfortunately, it was also dangerous.

I waited too long.

By the time I finally started my day, my carefully imagined schedule had already begun to unravel. Saturdays are chore-heavy for me. I do a lot around the house and fit in a 10-kilometer run on top of it. Delaying the start meant everything else slid later… and later… and later.

When I returned from my run, dinner was already behind schedule. I could tell immediately—my wife was not thrilled.

My wife runs life on a timeline. She schedules days and weeks in advance. Cold days and hot days do not interfere with her morning exercise routine. Her internal clock does not negotiate. Sometimes I think she wishes I were more like her. Today, I wished that too.

I felt bad knowing I’d disrupted her carefully structured day.

Normally, when things go wrong because of me, my wife quietly adjusts her tasks so she doesn’t waste time waiting. Today, though, the ripple effects were harder to contain.

Saturday evening is grocery time—specifically a very precise window when the store is less crowded. She also meal-preps for the following week, packing ingredients with recipes so cooking is easy for me. Any delay pushes everything later, including bedtime. She doesn’t like food sitting around unorganized. Neither does her conscience.

By the time I started washing dishes, we were already 45 minutes past our usual grocery time. I panicked, stopped mid-dish, and suggested finishing later—without realizing that this decision now blocked her from organizing groceries afterward.

Efficiency, I had learned, was optional today.

While I was scrambling, my wife quietly rearranged some of her Sunday tasks just to keep the day moving. Then she tackled grocery sorting anyway, because that’s what she does. Later, she gently reminded me of a lesson I apparently needed to relearn: schedule backward.

Start with the fixed commitments.
Work back to the run.
Then decide when sleeping in is actually allowed.

So yes, next time I’m tempted to wait for optimal running temperatures, I’ll also remember this: time waits for no one—and neither does the grocery schedule.Warm legs are nice.
An undisturbed household system is nicer.

Back

Posted on

Why Didn’t I Think of This in 2005?

Day 21 of 100 Days Coding Challenge: Python

When I saw “audio-to-text converter” on the list, my brain did a dramatic slow turn and whispered, “Where were you twenty years ago?” I mean, really—this could’ve saved me hours of repeating the word “vegetable” into a cassette recorder, trying to sound less like an anime character doing karaoke. Back then, I was on a one-woman mission to master English pronunciation, and a tool like this would’ve felt like cheating—but the good kind. Now, with AI and a little Python magic, I have made a program that converts my voice into readable text. Only catch? It plays favorites with WAV files. No love for MP3s. So naturally, I whipped up an MP3-to-WAV converter on the side, because why not? I recorded my voice straight from my laptop, half-expecting it to transcribe me saying something profound. Instead, I got back “this is a test.” Which is fair. It was.

Today’s Motivation / Challenge

Today’s project is the kind of tool you don’t know you need until you really need it—like when you’re trying to capture a brilliant idea mid-shower, but this time, it’s your voice memos from a walk, an interview, or that rambling TED Talk you gave to your cat. Audio-to-text isn’t just practical—it’s empowering, especially for learners, note-takers, and people who speak faster than they type.

Purpose of the Code (Object)

This simple program listens to your audio file and writes down what you said. That’s it. You talk, it types. It works best with clear speech and doesn’t judge your accent (too much). You can even record yourself with a laptop mic and see your words appear as text. It’s like magic—but with WAV files.

AI Prompt:

Create a Python script using the SpeechRecognition library that takes an audio file (preferably WAV), converts it to text, and prints the result. Add basic error handling. Bonus: include a simple MP3-to-WAV converter using pydub.

Functions & Features

  • Load an audio file (WAV preferred)
  • Convert speech in the file to text
  • Display transcription
  • Convert MP3 to WAV if needed

Requirements / Setup

bash

CopyEdit

pip install SpeechRecognition

pip install pydub

You’ll also need ffmpeg installed and added to PATH for MP3 support.

Minimal Code Sample

import speech_recognition as sr

recognizer = sr.Recognizer()

with sr.AudioFile(r”C:\path\to\your.wav”) as source:

    audio = recognizer.record(source)

    text = recognizer.recognize_google(audio)

    print(text)  # This prints your spoken words

Audio to Text GUI

Notes / Lessons Learned


 So here’s the thing: I wrote audio_file = “C:\Users\tinyt\OneDrive\Desktop\Test\Recording.wav” and, well… Python had a meltdown. Apparently, \t is not just a cute path separator—it’s a tab. Classic Windows-path betrayal. Once I added a humble little r in front like this—r”C:\Users\tinyt\…”—the program stopped being dramatic and worked like a charm. But let’s be real: rewriting the file path in code every time?

That’s a cry for a GUI. So, I made one. And it was glorious. Click, select, transcribe—done. Also, a fun fact: if you skip articles in your speech, the program skips them in your text too. No article, no mercy. And if your grammar is questionable? The output will happily reflect that. It’s an honest mirror, not a grammar teacher.

Optional Ideas for Expansion

  • Add a “Save as TXT” button for transcribed text
  • Let users choose between multiple languages for transcription
  • Record audio directly in the app, no file needed

Day 20
Day 22

Posted on

You Had One Job, Resume!

Day 20 of 100 Days Coding Challenge: Python

Do you know what an ATS resume keyword checker is? About 15 years ago, I had a chat with a friend in HR who casually dropped the term “Applicant Tracking System,” or ATS, as if it were common knowledge. I nodded like I totally knew what she meant, but inside I was thinking, “Ah, yes, the mythical software that eats resumes for breakfast.” She explained that ATS was used to sort through the avalanche of job applications—often over a thousand per listing. But here’s the kicker: the system also had a habit of rejecting the best candidates because they didn’t use the “right” words. The irony stuck with me.

So today, I decided to take matters into my own hands and see if I could make a mini version of this digital gatekeeper, ATS resume keyword checker. Because if robots are going to judge us, we may as well peek under their hood.

Today’s Motivation / Challenge


 We’ve all seen those job listings with 50 “required” skills. And let’s be honest—some of them are just buzzword soup. Today’s challenge was about building a tool to fight back. The goal: create a little program that reads your resume and checks it against keywords from a job description. It’s like prepping for a job interview with a cheat sheet—except you built the cheat sheet yourself.

Purpose of the Code (Object)


 This code scans your resume and tells you how well it matches a job posting based on keywords. It’s not reading your experience like a recruiter—it’s just playing word bingo. If you mention “Excel,” and the job wants “Excel,” that’s a point for you. The higher the match score, the more likely you are to pass the digital bouncer at the job club door.

AI Prompt: 

 Build a Streamlit app that uploads a resume (.txt or .pdf), compares it against comma-separated keywords, shows which ones are matched and which are missing, and calculates a match score.

Functions & Features

  • Uploads resume in .txt or .pdf format
  • Accepts comma-separated job keywords
  • Checks which keywords are present in the resume
  • Calculates a match score (%)
  • Displays found and missing keywords in separate lists

Requirements / Setup


 Install these before running:

bash

CopyEdit

pip install streamlit PyPDF2

Then run the app using:

bash

CopyEdit

streamlit run your_script.py

Minimal Code Sample

python

CopyEdit

def check_keywords(text, keywords):

    found = [kw for kw in keywords if kw.lower() in text.lower()]

    missing = [kw for kw in keywords if kw.lower() not in text.lower()]

    return found, missing

This function splits your keywords into found and missing by checking if they show up in the resume text.

Resume Checker App_GUI

Notes / Lessons Learned


 The programming part was smooth. Honestly, I was feeling confident—until I tried to run my Streamlit app like a normal Python script. That’s when Streamlit wagged its finger at me: “Session state does not function when running a script without streamlit run.” Touché, Streamlit. Once I launched it the proper way, everything clicked. I tested the app with a job listing from Indeed and my own five-year-old resume. The result? A humble 50% match. Moral of the story: your resume may be a masterpiece, but if it doesn’t speak ATS language, it’s not getting past the door. Tailoring your resume for each job isn’t just good advice—it’s algorithmic survival.

Optional Ideas for Expansion

  • Add an option to upload a job description file and auto-extract keywords
  • Highlight matched keywords directly in the resume text
  • Export the results as a PDF or CSV for review
Day 19
Day 21