System design: Building a Vending Machine in Go

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: