This content originally appeared on DEV Community and was authored by Anjali Jha
In this article, I will try my hands on designing and implementing a solution for vending machine using Golang
The requirements
- The vending machine should support multiple products with different prices and quantities.
- The machine should accept coins and notes of different denominations.
- The machine should dispense the selected product and return change if necessary.
- The machine should keep track of the available products and their quantities.
- The machine should handle multiple transactions concurrently and ensure data consistency.
- The machine should provide an interface for restocking products and collecting money.
- The machine should handle exceptional scenarios, such as insufficient funds or out-of-stock products.
Analysis
Upon seeing the question, I can figure that the machine works differently based on its state. These states can be-
- No money inserted (Idle)
- Has money but not yet purchased (HasMoney)
- Currently dispensing (Dispensing)
- Return money/change (ReturnChange)
Instead of huge if/else blocks, we can use the State Pattern which lets each state define valid actions (InsertMoney, SelectProduct, Cancel).
Flow Example
- Machine starts in idleState.
- User inserts coin → IdleState.InsertCoin() is called → moves to readyState.
- User selects product → ReadyState.SelectProduct() checks stock + payment.
- If enough payment → transitions to dispenseState, calls DispenseProduct().
- If change needed → transitions to returnChangeState, calls ReturnChange().
- After transaction → back to idleState.
The approach here will be to first create an interface which defines possible actions. We will then implement the interface using object instance.
We will also need few classes here
- Product: which shows the product of vending machine
- Coin and Note : represent the denominations of coins and notes
- VendingMachine : main class that represents the vending machine
Application
We will first create state interface, assuming we have struct in place for Product(name, price, qty), Coin (penny, quarter), Note(ten,twenty)-
type VendingMachineState interface {
SelectProduct(product *Product)
InsertCoin(coin Coin)
InsertNote(note Note)
DispenseProduct()
ReturnChange()
}
Now we will create VendingMachine context struct. This holds products, cash inventory, balance, and current state and provides methods for state transitions and payment handling.
type VendingMachine struct {
inventory map[*Product]int
//state
idleState VendingMachineState
readyState VendingMachineState
dispenseState VendingMachineState
returnChangeState VendingMachineState
currentState VendingMachineState
// transaction/runtime
selectedProduct *Product
totalPayment float64
}
We initialize a new Vending Machine. This creates a vending machine with an empty inventory and concrete state objects (IdleState, ReadyState, etc.). It follows the Singleton pattern to ensure only one instance of the vending machine exists. The snippet also has delegation methods.This means the behavior changes depending on the current state.-
func NewVendingMachine() *VendingMachine {
vm := &VendingMachine{
inventory: NewInventory(),
}
vm.idleState = &IdleState{vm}
vm.readyState = &ReadyState{vm}
vm.dispenseState = &DispenseState{vm}
vm.returnChangeState = &ReturnChangeState{vm}
vm.currentState = vm.idleState
return vm
}
func (vm *VendingMachine) SelectProduct(product *Product) {
vm.currentState.SelectProduct(product)
}
func (vm *VendingMachine) InsertCoin(coin Coin) {
vm.currentState.InsertCoin(coin)
}
func (vm *VendingMachine) InsertNote(note Note) {
vm.currentState.InsertNote(note)
}
func (vm *VendingMachine) DispenseProduct() {
vm.currentState.DispenseProduct()
}
func (vm *VendingMachine) ReturnChange() {
vm.currentState.ReturnChange()
}
We can also create few utility methods to set state, resetPayment.
Now to the main part -
The magic happens in concrete state implementations. Each state (IdleState, ReadyState, etc.) implements the VendingMachineState methods. They decide when to call SetState to move to another state. For example -
// IdleState struct
type IdleState struct {
vendingMachine *VendingMachine
}
func (s *IdleState) SelectProduct(product *Product) {
if s.vendingMachine.inventory.IsAvailable(product) {
s.vendingMachine.selectedProduct = product
s.vendingMachine.SetState(s.vendingMachine.readyState)
fmt.Println("Product selected:", product.name)
} else {
fmt.Println("Product not available:", product.name)
}
}
func (s *IdleState) InsertCoin(coin Coin) { fmt.Println("Please select a product first.") }
func (s *IdleState) InsertNote(note Note) { fmt.Println("Please select a product first.") }
func (s *IdleState) DispenseProduct() { fmt.Println("Please select a product and make payment.") }
func (s *IdleState) ReturnChange() { fmt.Println("No change to return.") }
Similarly other states can be implemented. You can add a demo file to demonstrate the entire functionality by adding products to the inventory, selecting products, inserting coins and notes, dispensing products, and returning change.
Hope this helps! Always open to suggestions for improvement.
This content originally appeared on DEV Community and was authored by Anjali Jha
Anjali Jha | Sciencx (2025-08-19T19:17:27+00:00) Machine Coding – Vending Machine. Retrieved from https://www.scien.cx/2025/08/19/machine-coding-vending-machine/
Please log in to upload a file.
There are no updates yet.
Click the Upload button above to add an update.