Living in Tokyo, Japan, I’m surrounded by vending machines offering everything from hot coffee to cold drinks and snacks.Inspired by these iconic machines, I trued to build a vending machine system design in Go. It's a cool example of using the State pattern, and I'll break down why it's super useful for this kind of project.

Why a Vending Machine?

Think about a real vending machine - it's actually pretty complex! It needs to:

• Keep track of products and their quantities
• Handle money
• Make sure you've put in enough cash
• Give you your snack
• Return your change

Plus, it needs to do all this without getting confused about what state it's in.

The Basic Building Blocks

First up, I needed some basic structures to work with:

Products and Inventory
Each product has an ID, name, price, and quantity. Pretty straightforward stuff:

type Product struct {
    ID       int
    Name     string
    Price    float64
    Quantity int
}

The inventory keeps track of all products using a map. It can:

• Add new products
• Remove products
• Handle transactions (like when someone buys something)
• Check if products are available

The State Pattern: Why It's Awesome Here

Here's where it gets interesting. A vending machine can be in different states:

• Waiting for money
• Money inserted
• Product selected
• Dispensing product

Each state needs to handle user actions differently. Like, you can't select a product before putting in money, right?
I used three main states:

1. MoneyInsertedState
2. ProductSelectedState
3. ProductDispensedState

Each state implements this interface:

type State interface {
    InsertMoney(amount float64)
    SelectProduct(product *Product)
    ReturnChange()
    DispenseProduct()
}

How It All Works Together

Let's say you want to buy a Coke:

First, you insert $2.00

• The machine is in MoneyInsertedState
• It records your money
• Switches to ProductSelectedState

You select Coke ($1.50)

• Machine checks if it has Coke in stock
• Verifies you put in enough money
• Moves to ProductDispensedState

Machine dispenses your Coke

• Updates inventory
• Returns your $0.50 change
• Goes back to MoneyInsertedState

Cool Features I Added

• Stock Management: Each product starts with 3 units. When something's sold out, it's automatically removed from available options.
• Smart Change Handling: The machine always calculates and returns the correct change after a purchase.
• Error Prevention: The state pattern helps prevent weird situations like, trying to buy stuff without enough money, selecting products that are out of stock, inserting money while something's being dispensed.

What I Learned

Building this taught me a few things:

• The State pattern is perfect for machines with clear, distinct states
• Go's interfaces make implementing state patterns really clean
• Proper error handling is super important for real-world applications

What's Next?

There's always room for improvement! Some ideas:

• Add support for card payments
• Implement a display system
• Add temperature monitoring for drinks
• Create an admin interface for restocking

The full code is more detailed than what I showed here, but these are the main pieces that make it work. Feel free to check the full implementation in the following repo: