DEV Community: DaoistRose

Breaking Out of Tutorial Hell

DaoistRose — Fri, 15 Aug 2025 19:02:24 +0000

My First Off-Script Project

Since July 17th, 2025, I’ve been fully immersed in structured coding courses. Codecademy, Boot.dev, Python, JavaScript, you name it, I’ve been working through it. And honestly? I’ve loved every minute.

But lately, I’ve hit what I’ve learned is called “Tutorial Hell.” That moment when you’ve gotten really good at following step-by-step lessons… yet when faced with a blank VS Code screen and no instructions, you freeze.

It’s not that I don’t know how to code. I’ve learned the basic syntax. I’ve built loops, functions, and even a few small projects inside course environments. But when I step outside those guardrails, it’s like someone hit “delete” on my brain.

Why This Feels So Strange

By most beginner measures, I can confidently say I’m doing well. I can comfortably navigate Python, and I’ve been deep into JavaScript lately while moving through Codecademy’s Backend Engineer path. But Python still feels like home—the ease, the predictability, the way it just… clicks.

So why does “just build something” feel so intimidating?
Because structured learning and creative building are two different muscles, and I’ve been overtraining one while ignoring the other.

My Way Forward

I’ve decided it’s time to go completely off script. No instructions. No checkpoints. Just me, a blank editor, and an idea.

My goal: build a functional, real-world app from scratch.
Is it ambitious for my current skill level? Absolutely.
Will I finish it? Yes.
Will I break it? Absolutely, Yes.

I’ll break the process into small, clear steps and document every stage here on the blog. Partly to stay accountable, partly because writing helps me process what I’m learning, and maybe it’ll help someone else avoid getting stuck in the same place.

The Project: An I-Ching App

I wanted something that’s both simple enough for a beginner and meaningful enough to me to keep me engaged. Enter: the I Ching.

The concept is straightforward:
• Ask a question
• Flip coins
• Generate a hexagram
• Look up its meaning
• Display the result in an easy-to-read format

But even a simple app has multiple moving parts… perfect for practicing problem decomposition and planning.

The Plan

Here’s how I’ll tackle it:

1. Mind Mapping & Planning
Define the app’s core purpose and main features (coin flipping, symbol generation, lookup table, reading display).
Sketch user flows and core screens

2. Research & Requirements
Translate the I Ching logic behind coin flips and hexagrams.
List technical needs (Android compatibility, offline use, etc.).
Choose a tech stack (I am thinking React Native or Flutter, if you have a better suggestion please leave them in the comments).

3. Design
Wireframe each screen.
Pick colors, fonts, and layouts.
Plan navigation and accessibility features.

4. Project Setup
Configure my development environment, version control, and project structure.

5. Development
Build features step-by-step: account creation, question process and validation, coin flip logic, animations, lookup tables, result display, navigation, and error handling.

6. Testing
Unit test each feature, then run full integration testing. Gather feedback. (This is one area I could really use some insight on, are there platforms for beta tests?)

7. Polishing
Optimize performance, fix bugs, refine UI/UX, add finishing touches.

8. Deployment
Prepare for release, test on real devices, and publish to the Google Play Store.

Why This Matters to Me

In the military, I learned that a 70% solution executed early and iterated on beats a 100% solution delivered too late. This project is my 70% solution for breaking into the tech career field. It won’t be perfect. It will break. I’ll have to backtrack, refactor, and rethink.

But it will be mine.

And when it’s done, I’ll have something tangible, a piece of software that started as a blank screen and became a working tool because I made it happen (… and a nice first project for my professional portfolio).

Final Thoughts

Tutorials are great for learning fundamentals, but at some point, you have to step outside the safe zone and start building your own roadmap. This is my first real attempt at doing that.

If you’re also in tutorial hell, maybe it’s time to pick an idea (any idea) and just start. The only way to learn how to build, is to build.
Here’s to getting unstuck: one function, one screen, one deploy at a time.

From Beginner Python to Backend Engineer: My Next Step

DaoistRose — Sat, 09 Aug 2025 12:29:53 +0000

After completing Codecademy’s Beginner Python 3 course, I took a couple of weeks to explore a different platform, introduce some variety into my learning, and continue building my skills. That short break gave me a fresh perspective, and now I am ready to dive back in with renewed energy.

This time, I am taking on something much bigger: Codecademy’s Backend Engineer Career Path.

Over the course of my Python journey so far, I have realized something important. This will be no surprise if you have read any of my other posts, but I am far more drawn to backend development than frontend. I love the logic, the structure, and the problem-solving that happens behind the scenes. This next step feels like the natural direction for me.

I want to be transparent throughout this process, sharing my wins, my challenges, and the lessons I pick up along the way. I would love for you to join me on this journey (this is a way to hold myself accountable and keep me on track). Whether you are learning alongside me, a step ahead, or a seasoned mentor, your insights, encouragement, and feedback will be invaluable.

If you are on a similar path, let’s connect. I am always excited to build relationships with others who share the same passion, whether we are at the starting line together or you have been running the race for years.

Here is to the next chapter and to building something meaningful, one line of code at a time.

Transitioning into Web Development – Seeking Advice, Communities & Mentorship

DaoistRose — Wed, 06 Aug 2025 04:53:33 +0000

I'm currently in the process of transitioning into a career in web development and could really use some guidance from those who’ve been down this path.

So far, I’ve been studying on my own and am working through Codecademy and Boot.Dev and I'm focused on back-end development. The more I learn, the more excited I get about creating things for the web — but I also realize how much more there is to learn beyond tutorials.

I’d really appreciate any suggestions on:

Great communities (online or local) where beginners can connect and learn
How to find a mentor (or be “mentor-ready”)
Ways to get real-world experience or contribute to open-source
Anything you wish you'd known earlier in your journey

If you’ve made a similar transition, I’d love to hear about your path. And if you’re open to chatting or sharing resources, I’d be extremely grateful.
Thanks so much in advance — looking forward to connecting

From Red Errors to Real Confidence

DaoistRose — Thu, 31 Jul 2025 15:09:42 +0000

Wrapping Up My Codecademy Beginner Python 3 Journey

On July 17, 2025, I made a decision: to stop browsing articles about programming and actually become a programmer. After years in the military leading teams, managing operations, and solving high-pressure problems, I wanted to see if I could bring that same focus to a completely new domain: software development.

On July 30, 2025, after weeks of consistent study, hands-on practice, and mental workouts, I’ve completed the Beginner Python 3 course on Codecademy. It feels less like a conclusion and more like stepping through the door into something I’ve been looking for all along.

Why I Started

As an Officer in the United States Army, I’ve spent years making decisions in complex environments, balancing data, risk, and systems thinking. That mindset maps surprisingly well to programming.

I’ve always been drawn to problem-solving, logic, and the quiet satisfaction that comes from building something out of nothing but thought and syntax. But it wasn’t until I started writing actual code that I realized:

This is the work I want to, and was meant to, do.

This beginner Python path was my structured launchpad. And it worked.

What I Learned

This course gave me more than just syntax—it gave me habits, problem-solving strategies, and a growing comfort with failure. Here are some of the core concepts I tackled:

• Data Types & Structures: I practiced working with strings, lists, dictionaries, tuples, and explored how to move, filter, and combine data efficiently.
• Control Flow: If/else statements, logical operators, and loops became tools I now rely on daily. These formed the backbone of all my early projects.
• Functions: I learned to build reusable code modules with clean inputs and outputs, and now naturally think in terms of breaking logic into discrete, testable pieces.
• Debugging: I no longer fear red error messages. In fact, I look forward to what they teach me. I now approach bugs like puzzles—frustrating, but solvable with patience and logic.
• User Input & Validation: Creating experiences that respond clearly (and kindly) to the user has become a focus in many of my projects. Adding validation and thoughtful prompts helped elevate my scripts from “it works” to “it’s usable.”
• Object-Oriented Programming: Towards the end, I explored classes and objects. It was a big mental leap, but it’s helping me think more modularly and structurally about my code.

The Codecademy platform itself was incredibly effective. It offered a smooth, supportive entry point with just enough friction to grow. I would have loved more opportunities for free-form, critical-thinking challenges, but even so—it laid a powerful foundation.
Would I recommend this course? Absolutely. Especially if you’re new, self-paced, and ready to put in focused effort.

Finding Focus in Backend Development

Throughout this course, I realized how much I enjoy backend architecture. I’m drawn to the quiet logic, the way systems communicate behind the scenes, and the problem solving that powers scalable, secure applications.

After exploring blogs, videos, and backend engineering communities, I stumbled on a site called Boot.dev. It's a gamified backend developer path—and I’m already hooked. In just a day and a half, I’ve hit Level 17 Apprentice and am currently ranked #1 in my league for the month.

It’s fun. It’s engaging. It’s practical. And because the first course is Python-focused, I’ve been able to jump right in with confidence. What makes Boot.dev stand out is the way it connects concepts to real-world backend logic—I'm literally writing the backend functions for a fantasy video game, which makes learning both immersive and memorable.

Career Transition in Progress

By February 2026, I will be transitioning out of the military. My goal is to land a full-time backend developer role, ideally remote or hybrid, on a team that values mentorship, collaboration, and growth. While it’s unlikely I’ll become a fully polished backend engineer overnight, I’m committed to getting as close as I possibly can.

While I may not have years of experience in tech, I bring something else:
• A mindset for continuous learning shaped through military leadership and training
• A proven ability to work under pressure while managing complex systems
• A deep motivation to build software that solves meaningful, real-world problems

This isn’t just about landing a job—it’s about building a new identity. I’m not just learning to code. I’m preparing to shift careers, mindsets, and life paths. I’m fueled by curiosity, discipline, and a stubborn belief that it’s never too late to reinvent yourself.

What’s Next

Over the next few months, I’ll be:
• Advancing through Boot.dev’s backend curriculum
• Completing Codecademy’s Backend Engineer Path
• Publishing new portfolio projects
• Reaching out to mentors and peers in the tech industry
• Continuing to document everything I learn, publicly

Final Thoughts

Completing this course doesn’t mean I’m “done.” It means I’ve built a base strong enough to start climbing higher.

Most days I find myself struggling with logic bugs or feel like I’m piecing things together slowly. But those moments no longer feel like setbacks. They feel like part of the process. They motivate me.

If you’re starting your own coding journey or changing careers later in life, I hope this post encourages you – even when the learning curve feels steep. It’s never too late to shift paths. You just have to keep learning, keep iterating, and keep showing up.

Let’s keep building — one loop, one function, one breakthrough at a time.

Thanks for reading. If you’re also transitioning into tech, learning Python, or working toward your first developer role, I’d love to connect and share ideas.

Caesar Cipher: Shifting Letters and Mindsets

DaoistRose — Sun, 27 Jul 2025 12:36:35 +0000

My Beginner’s Journey (Part 5)

For this project, I dove into something a little more mysterious: encoding and decoding secret messages with the Caesar Cipher. The idea sounded fun (and ancient!) but it also pushed me to level up my understanding of conditionals, loops, user input, and error handling. Even better, this was my first real brush with turning a logic concept into an actual usable program.

Let’s just say… the puzzle solving vibes were strong.

Getting Started

I’m now at Day 9 of my Codecademy Python 3 journey, and I can feel the difference in how I approach each new project. This one in particular gave me space to combine creativity with structure—a powerful mix for a beginner coder.

Project Overview

The Caesar Cipher is one of the oldest (and simplest) forms of encryption: each letter in a message is shifted a fixed number of spaces down the alphabet. My assignment was to build a program that could:

Encrypt a message with a shift of 1 to 10

Decrypt a message if the shift was known

Crack a message if the shift was unknown by trying all possible combinations

Simple in theory. But in practice it became a lesson in structure, error proofing, and translating ancient logic into clean, readable Python.

Starting Points

Use a list of alphabet letter pairs to represent characters and their numeric values

Validate user input carefully (shift values, message characters, etc.)

Create functions to handle each major operation: encryption, decryption, cracking

Rebuild the message by shifting numbers then converting them back to letters

Enhancing the Experience

Adding Input Validation That Talks Back

This was my second time writing a series of input prompts that actually talk back to the user when something goes wrong. Instead of just crashing or skipping ahead my script now:

Asks for a valid shift value (1 to 10)

Limits message length (2 to 200 characters)

Accepts only valid characters (letters, spaces, commas, etc.)

Re prompts with helpful error messages

This combined with some dramatic pauses enhances the user experience. It’s a small touch but it really made the flow feel more polished and human.

Encrypt Decrypt or Crack Let the User Decide

Rather than write one single function I built out three modes:

encrypt: adds the shift value to each letter

decrypt: subtracts the shift value

crack: runs decryption with all possible shift values and prints each result

Cracking open a message without knowing the shift felt like creating a mini puzzle solver. And because I wrote it modularly it was easy to reuse functions for both encryption and decryption.

Working with Lists Instead of Dictionaries (For Now)

I realized partway through that using a dictionary would have made some steps easier especially when mapping letters to numbers and back. But I haven’t quite gotten to dictionaries in my Codecademy lessons yet so I stuck with a list of [letter, number] pairs. Was it a little more verbose Sure. But it worked and it helped me reinforce nested loop logic.

Modular Thinking

This project encouraged me to start thinking in functions not just steps. Instead of one giant block of logic I broke things up:

convert_to_number()

apply_encrypt_shift()

apply_decrypt_shift()

convert_to_letter()

auto_crack_shift()

Each function does exactly one thing and takes clear inputs and outputs. It was like giving each piece of the cipher its own job description and for the first time my code felt structured.

Lessons Learned

User input validation is worth the effort. It makes your program kinder and smarter.

Functions are starting to feel more natural. I can see how breaking logic into chunks creates cleaner reusable code.

I’m still wrapping my head around more advanced data types like dictionaries but even without them I can build working solutions.

Shifting letters may be simple but doing it right taught me a lot about loops flow and planning ahead.

Final Thoughts

The Caesar Cipher was a different kind of project more interactive more playful and more structured than anything I’ve built so far. I had fun seeing the output change based on different shift values and it made the idea of code as a tool (not just a task) really click for me.

Up next I’d love to revisit this project once I learn dictionaries and maybe even add a GUI or allow file encryption. But for now I’m proud of the experience I built one that feels like it could actually be useful in the real world.

If you’re just starting out like I am I hope this project shows you that simple logic can be incredibly empowering. Let’s keep shifting forward one letter one line one breakthrough at a time.

The Code

You can check out the full Caesar Cipher script on GitHub here: (https://github.com/DaoistRose/Caesar_Cipher)

Thanks for reading and if you're learning Python too I’d love to see how you approached this project. Let’s keep decoding the mystery of code together.

Request For Assistance

DaoistRose — Thu, 24 Jul 2025 14:26:06 +0000

Good morning, everyone!

I'm reaching out to the community for some advice and inspiration.

I'm nearing the end of the Beginner’s Python 3 course on Codecademy and am looking to challenge myself with a personal project to wrap things up. While I've enjoyed the guided projects throughout the course, I’ve realized I’ve become a bit too reliant on the provided prompts.

I’d love to build something more independent—ideally a project that solves a real problem or provides tangible value, and one that could serve as a strong first portfolio piece for my professional site.

If you have any suggestions, ideas, or resources that might help spark some inspiration, I would truly appreciate it!

Thank you in advance!

Carly's Cuts: Simplicity and Struggle

DaoistRose — Wed, 23 Jul 2025 09:20:03 +0000

My Beginner’s Journey (Part 4)

When I first opened up the Carly’s Clippers project, it felt refreshingly manageable: simple lists, basic math, and just a few loops. But, as I’ve learned on this Python path, simplicity can still hold plenty of struggle. This project gave me a great chance to practice core concepts like list iteration, list comprehensions, and working with indexes—and reminded me that even when the path is straightforward, it’s okay to walk it slowly.

Getting Started

I’m currently at Day 8 of my Beginner Python 3 Codecademy journey. For this assignment, I stepped into the role of data analyst for the fictional hair salon Carly’s Clippers. My job? Use three basic lists to calculate average prices, revenue, and potential marketing insights.

Project Overview

The project gave me three parallel lists:

hairstyles: the haircut names
prices: the price of each haircut
last_week: how many times each haircut was sold last week

Each index in the lists matched up across the three—so I could track price, name, and sales quantity together. The tasks were clear:

Find the average haircut price
Adjust the inflated pricing
Calculate total revenue and average daily revenue
Highlight haircuts that will be under $30 next week

Starting Points

Loop through a list and add each item to get a total
Use len() to calculate averages
Apply list comprehensions to modify and filter data
Use range(len(list)) to iterate by index

Enhancing the Experience

Discovering `sum()`

One of my favorite moments during this project came when I caught myself thinking, *There has to be a simpler way to sum these prices. * I was looping manually through the list like this:

…and then I found the beautiful little shortcut sum()! total_price = sum(prices). It felt like leveling up and not just solving the problem.

Cutting Prices with Comprehension

Carly wanted to reduce prices across the board by $5. That was my cue to use list comprehension:

Here’s where things got tricky. Even though list comprehension looks concise, I still find myself having to slow down and mentally unpack what’s going on. I know it’ll get easier with practice, but for now, I still need to break the logic down piece by piece.

Tracking Revenue

To calculate revenue, I needed to multiply each haircut price by the number of times it was sold—then add all those up. Here’s where I leaned into the range() function:

This was a satisfying little loop that showed me the power of working with index values when your lists are aligned.

Filtering by Price

Finally, I used a list comprehension again to find all haircuts that would be under $30 after the price cut:

This one was a bit of a brain-bender. I really had to slow down and ask myself: What am I pulling? From where? And under what condition? It took a few tries to get right—and I’m okay with that. These are exactly the reps I need.

Lessons Learned

sum() is a fantastic built-in shortcut for adding lists—and worth using whenever possible
List comprehensions are powerful, but still feel abstract to me. I'm learning to slow down and break them apart
Parallel lists are easier to work with using index-based loops (range(len(...)))
Even “simple” logic can reveal gaps in understanding—and that’s where the best growth happens

Final Thoughts

This project was short, clear, and incredibly valuable. The logic wasn’t complex, but it forced me to apply multiple list operations together—and more importantly, to slow down and understand what each piece of code was actually doing.

I still find myself second-guessing list comprehensions and occasionally getting stuck in the weeds with loops. But every time I solve one of these problems, it sticks a little more.

Next, I’d love to take this project and modularize it—maybe write a function to print a report summary or allow Carly to update styles dynamically. That’s a challenge for another day, though.

For now, I’m celebrating a working script, a few “aha!” moments, and another piece of my beginner puzzle falling into place.

If you’re also learning Python or exploring Codecademy’s path, I’d love to hear how you’d approach a project like this. Let’s keep growing—one cut, one loop, one list at a time.

The Code

You can check out my full script here: https://github.com/DaoistRose/Carly-s-Cuts

Slices, Prices & Python

DaoistRose — Mon, 21 Jul 2025 10:42:20 +0000

My Beginner’s Journey (Part 3)

Len’s Slices 4 Mices is a small but mighty pizza shop serving up slices for every craving. My latest Codecademy Python 3 project brought me into the world of menu management. The task? Take a simple list of toppings and prices, and transform them into a sortable, structured menu that could be updated, sliced, and displayed to customers.

This project gave me a chance to go deeper into lists, tuples, sorting, and data validation. While the initial instructions were straightforward, I found plenty of room to play, polish, and reflect along the way.

Getting Started

I’m continuing my beginner Python journey (Day 6), and with each new project, I’m starting to notice a shift in how I approach code. This time, Codecademy asked me to build a pizza menu manager—a program that stores prices and toppings, sorts them by cost, and identifies the cheapest and priciest slices.

While this wasn’t as logic-heavy as shipping calculations or input validation, it gave me hands-on practice with organizing and pairing data in a meaningful way. There was a clear path laid out, but I also saw many little places to add safety checks and flavor (pun intended).

Project Overview

The core of this project was to create and manage a pizza menu. I started by creating two lists: one for toppings and one for their corresponding prices. Then, I combined them into a two-dimensional list where each item had the price first and the topping second.

Once the menu was created, I sorted it by price to identify the cheapest and most expensive slices. I then removed the last slice of anchovies from the list and added a new item: peppers at $2.50 per slice. Finally, I grabbed the three cheapest slices to create a little deal for our imaginary customers.

Starting Points

Create a list of toppings and a corresponding list of prices
Count the number of $2 slices using .count()
Calculate the total number of pizza types with len()
Pair each price with its topping using zip() and convert it to a list
Sort the list by price
Remove the priciest item, add a new one, and ensure the list remains sorted
Slice the list to get the three cheapest pizzas

Once I had all of this working, I started asking myself what could go wrong, and how to make the experience more complete.

Enhancing the Experience

Data Integrity Checks

I began by checking if the original toppings or prices lists were empty. It wasn’t required by the assignment, but it felt important to build in a simple fail-safe. I also made sure each topping had a price after combining the data, which helped prevent formatting errors later.

Discovering zip()

One of my favorite discoveries in this project was using zip() to pair prices with their corresponding toppings. I initially considered matching them manually, but zip() made it both faster and cleaner. Once zipped, I converted the result into a list using list() so I could sort, modify, and work with the data more flexibly. It felt like unlocking a new Python shortcut that I’ll definitely reuse in future projects.

Replacing Anchovies

When the anchovies sold out, I removed them from the list and added peppers instead. I learned that inserting a new item into a sorted list requires a fresh sort to maintain order. That small realization made me appreciate the need for clean, consistent data flow.

Formatted Output

I printed the menu line by line using formatted strings, which was a good exercise in handling nested data. I didn’t use a loop this time because I wanted to keep my focus on tuple structure and formatting logic. It was a bit repetitive, but seeing it play out helped me understand how each element fits together.

Daily Special

I had some fun with the “Three Blind Mice” idea—bundling our three cheapest pizzas into a special deal. This approach didn’t change the core logic of the program but made the output feel more polished and personal, giving customers a unique, catchy offer to look forward to.

One important detail was adding a safety check to ensure the special only appears when we actually have enough pizzas available. Since the special requires three different pizza options, I implemented a condition to simulate inventory availability and prevent errors that would occur if there are fewer than three pizzas to choose from.

Lessons Learned

This project helped me solidify a few key concepts:

Pairing data using zip() is simple and powerful
Sorting a list of tuples is surprisingly effective and easy to use
Removing and adding data requires thoughtful restructuring if you care about order
Sometimes it’s okay to avoid loops if you’re focusing on learning another concept
Even a static menu can be a great place to practice validation and formatting

Final Thoughts

This was a smaller project compared to my previous two, but it introduced important ideas that build the foundation for more advanced data handling. It made me think more about how to structure and present information, and it reminded me that even basic logic needs guardrails to work reliably.

Next, I’d love to refactor the print statements into a loop, then begin wrapping things into functions. Eventually, I want to build a version where users can “order” pizzas or update the menu on the fly.

For now, I’m happy that the menu works, the logic holds up, and I got to practice making my code both functional and a little bit fun.

The Code

If you'd like to see the full script for this project, you can check it out on GitHub here:

https://github.com/DaoistRose/Slices-Prices-Python

Thanks for reading! If you’re also working through Codecademy’s Python curriculum, feel free to share your version or your take on this project. Let's keep learning together!

Sal’s Shipping Struggles

DaoistRose — Sat, 19 Jul 2025 11:19:01 +0000

Expanding the User Experience — My Beginner’s Journey

Sal’s Shippers is the busiest logistics outfit in the tri-county area. With a growing customer base and a variety of services, Sal needed a solution that would help users quickly determine the most affordable way to ship their packages. That’s where my next Codecademy Python project came in: build a simple, functional, and friendly tool to compare shipping options based on weight.

It started as a basic calculator. But just like last time, I saw opportunities to explore more: adding polish, improving the flow, and thinking about the user first.

Getting Started

I’m still early in my coding journey (Day 4), but each new project is an invitation to go beyond the requirements. Codecademy asked me to write a Python script that takes a package’s weight and calculates shipping costs for three different options: Ground Shipping, Premium Ground, and the high-flying new Drone Shipping.

This felt like the perfect next step from my Magic 8-Ball project. The logic was a bit more involved, and there were plenty of places to make things friendlier, clearer, and more reusable. I started simple, then looked for rabbit holes to follow and lessons to uncover.

Project Overview

Write a program that asks the user for the weight of their package and then tells them which method of shipping is cheapest—and how much it will cost.

Starting Points

Prompt the user to enter the package weight.
Calculate the cost for:
- Ground Shipping (tiered rate + flat fee)
- Premium Ground Shipping (flat rate only)
- Drone Shipping (tiered rate, no flat fee)
Compare the three and return the cheapest option.
Test with example weights like 4.8 lbs and 41.5 lbs.

Enhancing the Experience

User Input Validation

Caught invalid or negative weight entries with try/except and a while loop.
Helped users recover from errors without crashing the program.

A More Conversational Flow

Added a warm intro and a thank-you message.
Used time.sleep() to add short pauses, just enough to simulate a helpful assistant thinking things through.
Wrapped everything in a loop so users could price multiple packages without restarting.

Getting the Output Just Right

Since the program calculates dollar amounts, I wanted all cost values to show exactly two decimal places—no more, no less. At first, I tried using round() for this. While it worked in theory, I ran into a visual problem: Python would display values like $45.20 as $45.2, which felt sloppy for something involving money.

To fix that, I switched to using the .format() method with a format specifier. Specifically:

{:.2f}

Here’s what that does:

: starts the format specification
.2 ensures exactly two decimal places
f means it’s a floating-point number

    # define which is the cheapest way to ship an item
    if ground_shipping_price < ground_shipping_premium and ground_shipping_price < drone_shipping_price:
        cheapest_option = 'Your cheapest option to ship this item is with ground shipping. Total cost: ${:.2f} \n'.format(ground_shipping_price)
    elif ground_shipping_premium < ground_shipping_price and ground_shipping_premium < drone_shipping_price:
        cheapest_option = 'Your cheapest option to ship this item is with premium ground shipping. Total cost: ${:.2f} \n'.format(ground_shipping_premium)
    elif drone_shipping_price <= ground_shipping_price and drone_shipping_price <= ground_shipping_premium:
        cheapest_option = 'Your cheapest option to ship this item is via drone shipping. Total cost: ${:.2f} \n'.format(drone_shipping_price)
    else:
        cheapest_option = '\nPlease enter a valid weight '

So, for example, a package that weighs 6.3 pounds and costs $45.20 to ship will now show up properly—decimal and all. Small fix, big improvement.

Readable, Reusable Code (Almost)

While I haven’t modularized things into functions yet, duplicating logic for repeat packages showed me how useful reusable code will be in the long run.

Lessons Learned

Validating user input is essential and feels empowering to get right.
while loops + try/except = smooth UX.
Small touches (like a pause or a prompt) go a long way.
Writing slightly messy code first is okay, it teaches you what to clean up later.

What I’d Add Next

As I keep learning, I already have a few ideas I’d love to implement when I understand Python a bit more:

Create items based on input: Let users name their packages and keep a record of each one, including weight and shipping method.
Show a full breakdown: Display the price for all shipping options—not just the cheapest so the user can see the full picture.
Use functions: Right now my code repeats a lot. Once I better understand how to write and call functions properly, I’d love to restructure this project into clean, reusable blocks.

These aren’t “musts” for a basic program, but they’re the kinds of improvements that turn something simple into something polished.

Final Thoughts

This project pushed me to think about more than just math and logic. It encouraged me to consider how real people would interact with the code—and how to make that interaction as clear and enjoyable as possible.

Here’s to Sal, shipping, and the small wins that feel big when you’re learning to code.

If you’re also learning Python or working through Codecademy’s curriculum, I’d love to hear how you’d improve this one! Would you have done anything differently? What would you refactor first?

Let’s connect and learn together—every project brings something new.

The Code


python
# Sal's Shipping - Codecademy Project
import time

# greeting the user
print("\nWelcome to Sal's Shipping! Let's find the best way to ship your package.")
time.sleep(2)
print("We offer three shipping options: Ground Shipping, Premium Ground Shipping, and Drone Shipping. \n")
time.sleep(2)

# define the package weight
weight = input('Enter the weight of the package in pounds: ')

# validate user input for weight
while True:
    try:
        weight = float(weight)
        if weight < 0:
            weight = input('\nPlease enter a valid weight (must be positive): ')
        else:
            break
    except ValueError:
        weight = input('\nPlease enter a valid number for weight: ')

# define ground shipping price
if weight <= 2:
    ground_shipping_price = 1.5 * weight + 20
elif weight <= 6:
    ground_shipping_price = 3 * weight + 20
elif weight <= 10:
    ground_shipping_price = 4 * weight + 20
else:
    ground_shipping_price = 4.75 * weight + 20

# define premium ground shipping (flat rate)
ground_shipping_premium = 125

# define drone shipping price
if weight <= 2:
    drone_shipping_price = 4.5 * weight
elif weight <= 6:
    drone_shipping_price = 9 * weight
elif weight <= 10:
    drone_shipping_price = 12 * weight
else:
    drone_shipping_price = 14.25 * weight

# determine cheapest option
if ground_shipping_price < ground_shipping_premium and ground_shipping_price < drone_shipping_price:
    cheapest_option = 'Your cheapest option to ship this item is with ground shipping. Total cost: ${:.2f} \n'.format(ground_shipping_price)
elif ground_shipping_premium < ground_shipping_price and ground_shipping_premium < drone_shipping_price:
    cheapest_option = 'Your cheapest option to ship this item is with premium ground shipping. Total cost: ${:.2f} \n'.format(ground_shipping_premium)
else:
    cheapest_option = 'Your cheapest option to ship this item is via drone shipping. Total cost: ${:.2f} \n'.format(drone_shipping_price)

print(cheapest_option)
time.sleep(2)

# allow multiple items
more_items = input("Thank you for using Sal's Shipping! Do you have another package to ship? (yes/no) \n").strip().lower()
while more_items not in ['yes', 'no']:
    print('Please answer with "yes" or "no". \n')
    more_items = input("Do you have another package to ship? (yes/no)  ").strip().lower()

while more_items == 'yes':
    weight = input('Enter the weight of the package in pounds: ')

    while True:
        try:
            weight = float(weight)
            if weight < 0:
                weight = input('\nPlease enter a valid weight (must be positive): ')
            else:
                break
        except ValueError:
            weight = input('\nPlease enter a valid number for weight: ')

    if weight <= 2:
        ground_shipping_price = 1.5 * weight + 20
    elif weight <= 6:
        ground_shipping_price = 3 * weight + 20
    elif weight <= 10:
        ground_shipping_price = 4 * weight + 20
    else:
        ground_shipping_price = 4.75 * weight + 20

    ground_shipping_premium = 125

    if weight <= 2:
        drone_shipping_price = 4.5 * weight
    elif weight <= 6:
        drone_shipping_price = 9 * weight
    elif weight <= 10:
        drone_shipping_price = 12 * weight
    else:
        drone_shipping_price = 14.25 * weight

    if ground_shipping_price < ground_shipping_premium and ground_shipping_price < drone_shipping_price:
        cheapest_option = 'Your cheapest option to ship this item is with ground shipping. Total cost: ${:.2f} \n'.format(ground_shipping_price)
    elif ground_shipping_premium < ground_shipping_price and ground_shipping_premium < drone_shipping_price:
        cheapest_option = 'Your cheapest option to ship this item is with premium ground shipping. Total cost: ${:.2f} \n'.format(ground_shipping_premium)
    else:
        cheapest_option = 'Your cheapest option to ship this item is via drone shipping. Total cost: ${:.2f} \n'.format(drone_shipping_price)

    print(cheapest_option)
    time.sleep(2)

    more_items = input("Do you have another package to ship? (yes/no)  ").strip().lower()
    while more_items not in ['yes', 'no']:
        print('Please answer with "yes" or "no".')
        more_items = input("Do you have another package to ship? (yes/no) ").strip().lower()

print("\nThank you for using Sal's

Predicting the Future with Python: My Magic 8-Ball Project

DaoistRose — Thu, 17 Jul 2025 18:54:09 +0000

Turning Nostalgia into Code — My Beginner's Journey

Have you ever shaken a Magic 8-Ball, hoping for a sign from the universe? For my Codecademy Python project, I was tasked with reimagining that classic toy in code—while adding a few creative touches along the way.

Getting Started

I’m at the very beginning of my coding journey. When Codecademy presented this project, it felt approachable yet full of potential: build a Python program that answers users’ questions with random “Yes” or “No” style fortunes.

The challenge was clear and built on fundamentals I’d learned over the past two days. But I wanted to see how far I could go, how many rabbit holes I’d find, and how I could stretch this assignment to learn more in the process.

Project Overview

Write a Python script that returns a random fortune when a user asks a question. Simple, right?

But good code isn’t just about functionality—it’s about making the experience enjoyable, accessible, and user-friendly.

Starting Points

A list of 9 possible Magic 8-Ball answers
Code to randomly select a fortune
User input for name and question
Clear print statements to display results

After implementing the basics, I started thinking: How could I make this even more engaging?

Enhancing the Experience

Input Validation

To create a smoother user experience, I added validation for both names and questions:

Names must be 2–15 characters and contain only letters, hyphens, spaces, or apostrophes (because everyone from Mary-Jane to O’Connell deserves inclusion).

Questions must be 10–50 characters and end with a ? (because it’s not a question without one!).

No numbers or odd symbols allowed — to prevent unexpected behavior or potential code injection.

Invalid input gives friendly, clear feedback to help the user try again.

A Touch of Dramatic Flair

To make the experience more immersive, I used time.sleep() to insert short pauses before revealing each answer. It’s a small trick, but it makes it feel like the universe is pondering your question.

Replay Value

Using a while loop, users can keep asking questions until they decide to stop. Each question brings a new, suspenseful fortune—just like the original toy.

Final Polish

To finish the project, I added some fun touches:

ASCII art for a welcoming intro
Friendly goodbye message at the end
A bonus answer for extra variety
Thoughtful handling of edge cases like skipped input

Lessons Learned

This project was about more than just getting the code to work. Along the way, I learned:

The importance of user experience and clear input validation
How to use loops and conditionals effectively
How to write code that’s clean, maintainable, and readable

Final Thoughts

Building the Magic 8-Ball project was a fun, practical way to boost my Python skills—and a great reminder of why people love software that surprises and delights.

Whether it’s predicting your future or sparking a smile, a little bit of code can feel like magic.

Feedback?

How would you improve this project? I’m new to programming, and every day is a new opportunity to learn. Looking forward to hearing from you all!

Thanks for reading! You can check out the code on GitHub here: https://github.com/DaoistRose/Magic-8-Ball.py/blob/main/Magic%208-Ball.py

DEV Community: DaoistRose

Breaking Out of Tutorial Hell

My First Off-Script Project

Why This Feels So Strange

My Way Forward

The Project: An I-Ching App

The Plan

Why This Matters to Me

Final Thoughts

From Beginner Python to Backend Engineer: My Next Step

Transitioning into Web Development – Seeking Advice, Communities & Mentorship

From Red Errors to Real Confidence

Wrapping Up My Codecademy Beginner Python 3 Journey

Why I Started

What I Learned

Finding Focus in Backend Development

Career Transition in Progress

What’s Next

Final Thoughts

Caesar Cipher: Shifting Letters and Mindsets

My Beginner’s Journey (Part 5)

Getting Started

Project Overview

Starting Points

Enhancing the Experience

Adding Input Validation That Talks Back

Encrypt Decrypt or Crack Let the User Decide

Working with Lists Instead of Dictionaries (For Now)

Modular Thinking

Lessons Learned

Final Thoughts

The Code

Request For Assistance

Good morning, everyone!

Carly's Cuts: Simplicity and Struggle

My Beginner’s Journey (Part 4)

Getting Started

Project Overview

Starting Points

Enhancing the Experience

Discovering sum()

Cutting Prices with Comprehension

Tracking Revenue

Filtering by Price

Lessons Learned

Final Thoughts

The Code

Slices, Prices & Python

Getting Started

Project Overview

Starting Points

Enhancing the Experience

Data Integrity Checks

Discovering zip()

Replacing Anchovies

Formatted Output

Daily Special

Lessons Learned

Final Thoughts

The Code

Sal’s Shipping Struggles

Expanding the User Experience — My Beginner’s Journey

Getting Started

Project Overview

Starting Points

Enhancing the Experience

User Input Validation

A More Conversational Flow

Getting the Output Just Right

Readable, Reusable Code (Almost)

Lessons Learned

What I’d Add Next

Final Thoughts

The Code

Predicting the Future with Python: My Magic 8-Ball Project

Getting Started

Project Overview

Starting Points

Enhancing the Experience

Input Validation

Discovering `sum()`