Tag: Coding

Posted on

Calendar Chaos: Now Starring You

Day 31 of 100 Days Coding Challenge: Python

Back in the pre-Google-stone age, I was the kind of person who printed out monthly calendars like I was running a tiny print shop. Menu plans, exercise routines, music lessons, sports schedules—you name it, it lived on my calendar. When I was a student, if it wasn’t written down, it didn’t exist. My calendar was my brain’s external hard drive. Fast forward to my first real adult job: I marched into a store and proudly bought myself a Franklin Covey agenda. The deluxe version. It felt like holding the crown jewels of time management. I’ve always loved the feeling of flipping to a fresh week, filling it with possibility (and color-coded chaos). So, when I realized I could make my own Python calendar app from scratch? Let’s just say I had a moment. Sure, it’s not going to dethrone Google Calendar anytime soon, but it’s mine—and it doesn’t send me passive-aggressive push notifications.

Today’s Motivation / Challenge

Calendars are one of those tools we don’t think about until we need them—or lose them. Today’s project taps into the part of us that loves order, hates forgetting birthdays, and secretly dreams of color-coded to-do lists. Building a calendar app is a great way to connect programming with everyday life. Plus, who doesn’t want to click a button and feel like they’ve conquered time?

Purpose of the Code (Object)

This little app lets you view any month and year in a simple graphical layout. You can click on a day to add a note (because you will forget Aunt Susan’s birthday), and today’s date gets a nice highlight so you don’t accidentally time-travel. It’s not fancy, but it’s useful—and surprisingly satisfying.

AI Prompt: 

Add features to highlight today’s date, allow users to click on a date to add a note, and save those notes in a local file. Keep the interface clean and simple.

Functions & Features

  • View any month and year in a calendar grid
  • Highlight today’s date in green (because you deserve attention)
  • Click on a date to add a note or reminder
  • Save notes automatically in a JSON file
  • Bold and blue font indicates a note exists

Requirements / Setup

Python 3.x

No external packages required

Minimal Code Sample

btn = tk.Button(…, command=lambda d=day: self.add_note(d))

if day == today.day and month == today.month and year == today.year:

    btn.config(bg=”lightgreen”)  # Highlight today’s date

This sets up each calendar button and highlights today’s date.

Customizable Calendar

Notes / Lessons Learned

This time, I jumped right into the GUI version because—let’s be honest—it’s way more fun to see a calendar than to stare at a wall of text. At first, all it did was show the month. Cool… but also about as interactive as a printout taped to your fridge. So I started tinkering. First, I made it highlight today’s date—because every hero needs a spotlight. Then I added the ability to attach notes to specific days. Now, do those notes pop up when you hover or click? Not yet. But the font turns blue and bold, and that’s enough to make my inner calendar nerd happy. For someone who thrives on color-coding their life down to what to eat on Tuesday, this project hit all the right buttons. Literally.

Optional Ideas for Expansion

  • Add a note viewer pane to display saved events when clicked
  • Export notes as a CSV for your future time-travel journal
  • Add color tags for event types (work, personal, world domination)

Day 30
Day 32

Posted on

Crunching Numbers with Style: My Python EMI Calculator App

Day 30 of 100 Days Coding Challenge: Python

Back in university, I survived a finance course where one of the big thrills was figuring out how much you’d owe on a mortgage—because nothing says fun like watching compound interest quietly ruin your weekend. We used financial calculators that looked like relics from a Cold War museum, and if the professor was feeling futuristic, we’d get to use Excel. These days, of course, you can find slick EMI calculators on almost every bank’s website. But today I wondered—could I make one myself? Turns out, yes. I built a simple Python EMI calculator app. It’s not glamorous, it doesn’t sparkle, and it definitely won’t win UX awards, but it works. No spreadsheets. No arcane formulas. Just pure, functional code—and the oddly satisfying thrill of watching your hypothetical loan turn into very real monthly heartbreak.

Today’s Motivation / Challenge

Ever tried to figure out how much you’re actually paying the bank for that “affordable” loan? Spoiler: it’s more than you think. Today’s challenge was a practical one—create a loan/EMI calculator to see the real cost of borrowed money. It’s part nostalgia (throwback to finance class) and part grown-up reality check. Plus, building this in Python and Streamlit let me stretch some GUI/web muscles without losing my mind.

Purpose of the Code (Object)

This code calculates your monthly loan payment (EMI), the total amount you’ll pay back, and how much of that is interest. You just punch in the loan amount, interest rate, and loan period. It does the math, so you don’t have to reach for that dusty calculator—or guess wildly.

AI Prompt: 

Create a loan/EMI calculator in Python that asks for principal, interest rate, and tenure, then calculates and displays the monthly EMI, total repayment, and total interest. Include both a Streamlit app and a Tkinter GUI.

Functions & Features

  • Takes user input for loan amount, interest rate, and tenure
  • Calculates monthly EMI using a standard financial formula
  • Displays total repayment and total interest
  • Offers both a desktop GUI and a Streamlit web app interface

Requirements / Setup

pip install streamlit

For GUI:

  • Built-in tkinter (no install required on most Python versions)

Minimal Code Sample

emi = (P * r * (1 + r)**n) / ((1 + r)**n – 1)

This formula calculates your monthly payment using principal (P), monthly interest rate (r), and loan term in months (n).

Loan Emi Calculator Streamlit

Notes / Lessons Learned


 The code wasn’t hard to write. What tripped me up? Forgetting I wasn’t in Python 101 anymore—I was in Streamlit land. So when I ran it the usual way (python scriptname.py), nothing happened. No errors. Just silence. A tumbleweed moment. Then I remembered: it’s streamlit run scriptname.py. Once I got that right, the app popped open in my browser like a well-behaved web butler. Lesson learned: the right tool needs the right doorbell.

Optional Ideas for Expansion

  • Add a pie chart showing principal vs. interest breakdown
  • Allow users to export results as a CSV or PDF
  • Include an “extra payment” option to see how prepayments affect the loan term

Day 29
Day 31

Posted on

Button-Free Brilliance: A Calculator That Doesn’t Judge Your Math

Day 29 of 100 Days Coding Challenge: Python

Have you ever stopped mid-calculation and thought, “Wait, how does this magic actually happen?” I mean, when I type “=SUM(A1:A5)” into Excel, I don’t pause to thank the spreadsheet gods. But today, I did. Mostly because I was tired of relying on apps, a Python calculator with history, and wanted to see if I could recreate the magic myself—with a twist. You see, I do most of my calculations on my phone or in a spreadsheet (because who has time to calculate sales tax manually?). But something about writing my own calculator in Python felt strangely empowering, like building a mini-math butler. And hey, once you’ve got this running, you can actually reuse it in all sorts of future projects. Nothing fancy—just a bit of logic, a few lines of code, and voilà: your own digital brain.

Today’s Motivation / Challenge

Today’s challenge was about demystifying the tool we all use but never think about—calculators. Behind that slick interface on your phone lies a surprisingly simple system. By building one ourselves, we not only learn how math works in Python, but we create a tool that’s instantly useful. Also, let’s be honest: there’s something satisfying about typing in 3 * (5 + 2) and seeing your own code proudly deliver the answer.

Purpose of the Code (Object)

This program lets you enter math problems (like 4 + 4 or 12 / 3) into a simple GUI window and gives you the answer. It also remembers every calculation you’ve done during that session, so you can scroll back and admire your math skills—or catch the moment it all went wrong. It’s like your phone calculator, but with less judgment and more transparency.

AI Prompt: 

Write a GUI-based calculator in Python with history tracking. It should evaluate expressions typed into an input box, display results below, and keep a scrollable history of all calculations.

Functions & Features

  • Accepts math expressions like 5 + 2 or 3 * (4 – 1)
  • Calculates and displays the result immediately
  • Keeps a scrollable history of all calculations
  • Handles syntax errors without crashing
  • Lets you clear the history with one click

Requirements / Setup

Just make sure you have Python 3 installed—nothing else needed.

# No pip install needed—just run the script

python gui_calculator_with_history.py

Minimal Code Sample

expr = entry.get().strip()

result = eval(expr, {“__builtins__”: None}, {})

This takes the user’s input, evaluates it safely as a math expression, and returns the result.

GUI Calculator with History

Notes / Lessons Learned

The program works surprisingly well—until you get cheeky. It’s text-based, which means it expects, well… math. If you type in your file name or something like >>> 2 + 2, it will blink at you and throw a syntax error. Why? Because it’s trying to evaluate whatever you typed as math. This is not a chatbot—it doesn’t care about small talk. It only wants 2+2, not your life story. So yes, it’s a bit rigid, like a teacher who only answers what’s on the test. But once you get used to that, it’s fast, reliable, and kind of fun. Also, building it made me realize just how often I rely on tools without knowing how they work under the hood. Now I do—and so do you.

Optional Ideas for Expansion

  • Add buttons for digits and operators to make it feel like a real calculator
  • Save calculation history to a .txt or .csv file
  • Add a dark mode toggle for extra flair and eye comfort

Day 28
Day 30

Posted on

Dear Diary, You’ll Never Guess What I Encrypted Today

Day 28 of 100 Days Coding Challenge: Python

I’ve always kept a journal—both digital and analog. In fact, I still scribble in a notebook with a pen, even though my handwriting is the kind of cryptic mess that could double as a CAPTCHA test. But I’m oddly comforted by the idea that if someone tried to read it, they’d either go blind or start decoding it like a Cold War cipher. That said, I still remember the sheer horror of a sibling (yes, the nosy one) reading my diary out. Since then, I’ve had a deeply personal vendetta against unsecured journaling. So, I finally did it: I built my own diary app—with encryption. No prying eyes. No traumatic readings. Just me, my thoughts, and a very tight password.

Today’s Motivation / Challenge


 Journaling is personal. Like, really personal. Whether you’re logging your feelings, goals, or that weird dream you had about sentient laundry, it deserves privacy. I wanted to make a journal that felt like a digital vault—simple to use, but impossible to crack without the key. And since I’m also practicing my GUI skills, I figured, why not make it look nice while I’m at it?

Purpose of the Code (Object)


 This app is a private digital diary. You can write journal entries, save them securely, and read them later—only if you enter the correct password. It uses encryption to make sure no one but you can read what you’ve written, and it now includes automatic timestamps so you can look back and see exactly when you had that existential crisis.

AI Prompt:

Build a GUI-based personal diary app in Python that encrypts each entry using a password-based key. Include timestamped entries and secure storage using the cryptography library. Use tkinter for the interface.

Functions & Features

  • Password-protected access
  • Add new diary entries
  • View previously written entries
  • Each entry automatically includes a timestamp
  • Clean, scrollable GUI built with Tkinter

Requirements / Setup


 To run this app, you’ll need:

pip install cryptography

Python version: 3.8 or higher recommended

Minimal Code Sample

timestamp = datetime.now().strftime(“%Y-%m-%d %H:%M:%S”)

full_entry = f”[{timestamp}]\n{entry}”

encrypted = cipher.encrypt(full_entry.encode())

This adds a timestamp to your diary entry and encrypts it before saving.

Encrypted Diary (GUI)

Notes / Lessons Learned

With the help of an AI prompt, building this script was surprisingly smooth—until I hit my first “I forgot to install the cryptography library” moment. Classic. Then came the part where the program asked me to set a password, but nothing appeared on screen. For a split second, I thought my keyboard had staged a walkout. Turns out, the password input was just being ultra-stealthy—so stealthy that I couldn’t see what I typed. But hey, that’s security. If you mess up your password confirmation, it makes you do it all over again. Fair enough.


Later, I decided to ditch the command line and build a GUI version. Because honestly, clicking buttons is more satisfying than typing commands, especially when you’re just trying to jot down how your day went. And I added timestamps—because every journaling tool I love (Notion, Obsidian) includes them, and they make going back in time feel like digital archaeology.


Honestly, if I’d had this kind of encrypted diary app when I was a teenager, I probably would’ve written about a hundred volumes of emotional drama—and no one would’ve ever been able to decode my secret crushes.

Optional Ideas for Expansion

  • Add a “Search by date” function
  • Export selected entries to a readable .txt file
  • Add light/dark mode toggle for late-night journaling vibes

Day 27
Day 29

Posted on

How to Build a Simple Python Chatbot (No AI Required!)

Day 27 of 100 Days Coding Challenge: Python

About a year ago, I was trying to get help from a state government website—you know, the kind that promises “24/7 assistance” via a chirpy chatbot. Except, instead of assistance, I got a face full of code errors. Repeatedly. The bot was supposed to reduce agent time, but apparently, it had decided to take a permanent coffee break. I asked nicely, refreshed, and even pleaded. Nothing. That little robot ghosted me.

Naturally, I got curious—how hard could it be to build a simple chatbot that actually responds? And here we are: this is not some ultra-sophisticated AI oracle; this is a humble, pre-AI chatbot. No deep learning, no fancy brain. Just old-school logic and a love for the “if-else” life.

Today’s Motivation / Challenge

Today’s challenge is nostalgic. We’re going back to a simpler time—before neural networks and hallucinating chatbots—when your digital assistant was more rule-follower than mind-reader. This project connects to that curious urge we all get when tech breaks: “Could I make something that works better than this?” Well, maybe. Today’s your chance to try.

Purpose of the Code (Object)

This code creates a chatbot that responds to common phrases using plain, predictable rules. It doesn’t learn, guess, or improvise. Instead, it listens for keywords and responds accordingly—like a polite robot butler who doesn’t like surprises.

AI Prompt

Build a rule-based chatbot in Python that recognizes user input using keyword matching and gives relevant responses about greetings, time, weather (simulated), jokes, and simple math. Add a fallback response for anything it doesn’t understand.

Functions & Features

  • Recognizes greetings, goodbyes, and help requests
  • Simulates a weather response (pure imagination)
  • Tells the current time using your system clock
  • Solves basic math expressions (like “What is 3 + 5?”)
  • Tells a (very polite) joke
  • Politely admits confusion when it doesn’t know what you said

Requirements / Setup

  • Python 3.x
    (No external libraries are needed—just plain Python)

Minimal Code Sample

if “time” in user_input:

    current_time = datetime.datetime.now().strftime(“%H:%M:%S”)

    return f”The current time is {current_time}.”

Checks if the user asked for the time and responds with the current system time.

Rule Based Chatbot

Notes / Lessons Learned

The first basic chatbot worked great. So naturally, I got ambitious. I layered on more logic, more keywords, and more “features.” That’s when it happened: chaos. The code refused to run. I suspected a directory issue—maybe I saved the file in the wrong place? Nope. The file was there. It was my code that was broken, all because of one sneaky extra quote at the end of a string.

Lesson? Python is picky about quotation marks—and for good reason. Mixing ” and ‘ or doubling up can cause a silent meltdown. Also, watch your syntax coloring. If your code suddenly lights up like a Christmas tree, it’s probably not because you’re a genius. It’s because something’s off.

Also, rule-based bots are loyal but very literal. Misspell one keyword—like typing “wether” instead of “weather”—and it freezes like a deer in headlights:

“Hmm… I’m not sure how to respond to that. Try saying ‘help’.”

Still, there’s something rewarding about building a little machine that answers you. In fact, I’m now dreaming of creating a text-based adventure game where the chatbot acts as the narrator and dungeon master. Primitive? Yes. Promising? Absolutely.

Optional Ideas for Expansion

  • Add real weather data using an API like OpenWeatherMap
  • Allow fuzzy matching so it understands similar words or typos
  • Turn it into a text-based game with branching dialogue

Day 26
Day 28

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

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

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