DEV Community: CodeWizardX1

Building a Simple CPU Simulator in Python

CodeWizardX1 — Fri, 14 Feb 2025 05:09:59 +0000

Introduction

I created this project for my CS104 course on Codecademy. As part of learning computer architecture, I wanted to understand, on a hands‐on level, how a CPU fetches, decodes, and executes instructions. This simulator demonstrates the fundamentals of CPU registers, memory, and arithmetic instructions in a neat little package—all in Python.

About the Python Code

In this simulator, each instruction (like ADD, SUB, MUL, DIV) is stored in a simple text‐based format ("ADD,R1,R2,R3") inside a memory list. The CPU class then performs the core operations:

Store Values in Registers: It can store integer data in registers before running an instruction.
Fetch: It reads the next instruction from memory, incrementing a program_counter as it goes.
Decode: It splits the instruction string into an opcode (e.g., ADD) and operand registers (like R1, R2, R3) to understand which registers to reference.
Execute: It carries out the arithmetic or logical instruction, modifying the registers as needed.

For example, if the code sees ADD,R5,R1,R2, it takes the values in registers R1 and R2, sums them, and stores the result in R5. It’s a streamlined way to get a feel for how real CPUs handle instructions step by step.

Check out my GitHub repo for the full code and examples: GitHub: CodeWizardX1/cpu_simulator

Conclusion

Building this Python CPU simulator gave me a much better appreciation for how processors orchestrate memory, registers, and instructions. It’s a toy example, but the main concepts—fetch, decode, execute—are the same building blocks used by real hardware. Feel free to explore the repository, try adding new instructions, or extend its capabilities.

Building MooVeeMatch: A Mood-Based Movie Recommendation Program 🎥✨

CodeWizardX1 — Sat, 21 Dec 2024 21:56:49 +0000

Building MooVeeMatch: A Mood-Based Movie Recommendation Program 🎥✨

Introduction

As part of the Codecademy Computer Science curriculum, I recently completed a portfolio project: MooVeeMatch. This program is a mood-based movie recommendation tool that allows users to discover films tailored to how they feel. Whether you're in the mood for something uplifting, adventurous, or mysterious, MooVeeMatch has you covered!

In this blog post, I'll walk you through the inspiration behind the project, the technical details of its implementation, and key lessons I learned during development. If you're learning Python or working through Codecademy's curriculum, this might inspire you to build your own mood-based app!

About MooVeeMatch

MooVeeMatch is a command-line application that takes user input (e.g., their mood) and returns a curated list of movies matching their vibe. The program is powered by a Python dictionary (essentially a hash map) that stores moods as keys and lists of movies as values.

Key Features:

Mood-Based Recommendations: Search for movies by mood (e.g., uplifting, dark, funny, etc.).
Interactive CLI: A clean and user-friendly interface for browsing movie recommendations.
Refactored Codebase: Includes both the original implementation and a cleaner, more modular refactored version.
Expandable Database: Easily add more moods and movies to the database.

Technical Overview

Data Structure

The core of MooVeeMatch is a dictionary that maps moods to movie lists. This is an example of a hash map in Python, providing efficient O(1) lookups for moods.

Example:

movies_by_mood = {
    "uplifting": [
        ("The Pursuit of Happyness", 2006, "A touching story about perseverance"),
        ("Soul", 2020, "An inspiring animated story about life's purpose")
    ],
    "dark": [
        ("Se7en", 1995, "A gritty thriller about a serial killer"),
        ("The Dark Knight", 2008, "A darker take on the Batman legend")
    ],
    # More moods...
}

Algorithms

Search Algorithm:
- The program uses the startswith() method to find moods that match the user’s input.
- Example: If a user types "upl", the program matches it to "uplifting".
Sorting Algorithm:
- Movie lists are sorted alphabetically before being displayed using Python’s built-in sorted() function.

Program Workflow

Welcome Message: Users are greeted with a decorative ASCII banner.
Mood Input: The program prompts users to enter the first few letters of their mood.
Mood Matching: The program finds matching moods from the database using startswith() and returns a list of matching options.
Recommendations: Users confirm their mood and receive a list of recommended movies with titles, release years, and loglines.
Repeat or Exit: Users can explore other moods or exit the program.

Key Challenges and Refactoring

Challenge: Nested Logic

The original implementation had deeply nested loops and conditionals, making the code harder to read and maintain.

Solution: Refactoring

I refactored the code to improve modularity by breaking it into smaller, single-responsibility functions. For example:

Before: Mood matching and movie display were handled within the main loop.
After: Separate functions like find_matching_moods() and display_movies_for_mood() streamlined the code.

Here’s an example of a refactored function:

def find_matching_moods(input_mood_letters):
    """Search for moods matching the input letters."""
    return [
        mood for mood in movies_by_mood.keys()
        if mood.startswith(input_mood_letters)
    ]

This refactoring made the codebase more readable and easier to debug, especially as I expanded the movie database.

Lessons Learned

The Importance of Refactoring:

Writing modular, clean code saves time in the long run. The refactored version of MooVeeMatch was not only easier to debug but also simpler to extend.
Using Hash Maps Effectively:

Python dictionaries are powerful for storing and retrieving data efficiently. This project reinforced how to leverage hash maps in real-world scenarios.
Small Iterative Improvements:

Working in small increments—writing a feature, testing it, and improving it—helped me maintain focus and avoid overwhelm.
CLI Design Matters:

Even in a terminal-based program, user experience is key. Simple touches like a clean banner and well-structured output make a big difference.

Conclusion

MooVeeMatch was a rewarding project that allowed me to apply what I’ve learned in Codecademy’s Computer Science curriculum to a real-world scenario. From handling user input to managing data efficiently, this project helped solidify my Python skills and taught me the value of clean, modular code.

Check Out MooVeeMatch on GitHub!

You can find the full codebase here: [GitHub Repository Link](#)

Feel free to clone it, try it out, and contribute if you’d like!

Building a Classic Hangman Game in Python with Category Selection

CodeWizardX1 — Wed, 25 Sep 2024 01:51:28 +0000

As part of Codecademy's Computer Science Career Path, I was assigned to create a Python terminal-based game for my first portfolio project. I wanted to build something fun and engaging, so I decided to recreate the classic Hangman Game, but with a twist: category selection.

Instead of guessing a randomly selected word, the player can choose a category (such as Animals, Countries, or Movies) to help guide their guesses. This makes the game more strategic and enjoyable, while also allowing me to showcase my understanding of Python fundamentals. Below is a breakdown of my approach and a walk-through of the code.

Here’s a sneak peek of what the Hangman game looks like when running in the terminal:

The player is welcomed with an introductory screen, selects a category, and begins guessing letters to uncover the hidden word. The game even prints out fun ASCII art to show the progress of the poor stickman with each wrong guess!

I designed my Python Hangman game with simplicity and user engagement in mind. The game logic revolves around guessing a hidden word, and the player must try to figure it out one letter at a time. Here are some key parts of the code:

Category Selection: The game starts by letting the player choose from a list of categories. I used a Python dictionary to organize words into categories like "Animals," "Movies," and "Cities." This adds a fun twist because players can focus their guesses based on the category.

Random Word Selection: After a category is selected, the game randomly picks a word from that category. This is handled using Python’s random module, ensuring a different experience every time the game is played.

Handling Guesses: The player can guess one letter at a time. Correct guesses reveal the positions of the letter in the word, while incorrect guesses add to the hangman’s figure. The game ends either when the word is fully guessed or when the hangman is fully drawn (after 6 incorrect guesses).

ASCII Art: I used fun ASCII art to display the progress of the hangman, adding a visual element that players are familiar with from traditional Hangman games.

Check out the Code:
You can find the full source code for this project on my GitHub repository.

Developing this Hangman game as part of Codecademy’s portfolio project was a great way to practice core Python concepts like dictionaries, loops, and conditionals while also creating something that’s both fun and nostalgic. I may add further enhancements at a later date.