Understanding Functions vs Methods in Go (Golang) 🚀

Victor Chiaka — Sat, 14 Jun 2025 00:44:36 +0000

Introduction

Go (or Golang) is a statically typed compiled programming language, known for its simplicity and performance. One of its elegant features is how it handles functions and methods. While they may look similar at first glance, there are key differences.

In this post we'll explore the following:

What functions and methods are
The differences between functions and methods
When to use one over the other
Real world code examples

Let's dive in baby 🪂

What is a Function in Golang?

A function in Golang is a standalone piece of code that given an input returns a result. It isn't tied to a specific type.

func Deposit(account BankAccount, amount float64) float64 {
    return account.Balance + amount
}

This is a simple function that takes a BankAccount and a deposit amount and returns the new balance, but it does not modify the original account.

What is a Method in Golang?

A method is a function attached to a specific type via a receiver.

Methods can also be called Reciever functions, cuz it's tied to a specific type known as the Reciever type.

func (a *BankAccount) Deposit(amount float64) {
    a.Balance += amount
}

Now Deposit() is a method that modifies the original BankAccount.

💡 Example Code

Here’s a full Go program demonstrating functions vs methods in a banking context, Feel free to Ctrl+c, Ctrl+v into your IDE and play around:

package main

import (
    "fmt"
)

type BankAccount struct {
    Owner   string
    Balance float64
}

type User struct {
    FirstName string
    LastName  string
}

// Function: stand-alone logic
func GetFullName(user User) string {
    return user.FirstName + " " + user.LastName
}

// Method: tied to User type
func (u User) FullName() string {
    return u.FirstName + " " + u.LastName
}

// Function: calculates future balance (does not change the account)
func Deposit(account BankAccount, amount float64) float64 {
    return account.Balance + amount
}

// Method: modifies the account (pointer receiver)
func (a *BankAccount) Deposit(amount float64) {
    a.Balance += amount
}

// Method: withdraws money
func (a *BankAccount) Withdraw(amount float64) bool {
    if amount > a.Balance {
        return false
    }
    a.Balance -= amount
    return true
}

func main() {
    // User example
    user := User{"John", "Doe"}
    fmt.Println("Function:", GetFullName(user))
    fmt.Println("Method:", user.FullName())

    // BankAccount example
    account := BankAccount{Owner: user.FullName(), Balance: 1000}
    fmt.Printf("Initial Balance: $%.2f\n", account.Balance)

    // Function: simulate deposit (no change to actual account)
    newBalance := Deposit(account, 500)
    fmt.Printf("Simulated deposit (function): $%.2f\n", newBalance)
    fmt.Printf("Actual balance after function: $%.2f\n", account.Balance)

    // Method: actual deposit
    account.Deposit(500)
    fmt.Printf("Balance after method deposit: $%.2f\n", account.Balance)

    // Withdraw using method
    success := account.Withdraw(200)
    fmt.Printf("Withdraw $200 successful? %v. Balance: $%.2f\n", success, account.Balance)
}

Use Functions When ✅:

You want pure operations that don't mutate objects
You’re writing helper utilities or logic that works across many types

Use Methods When ✅:

You want to modify the internal state of an object (e.g., account balance)
You want cleaner, object-oriented-style calls: account.Withdraw(100)

🏁 Final Thoughts

Understanding the difference between functions and methods in Go is essential for writing clean, idiomatic code.

With these banking examples, you can now decide when to use each — and why it matters!

Port Forwarding with Ngrok 🚀: Quick Guide

Victor Chiaka — Sun, 23 Feb 2025 10:23:17 +0000

Scenario:

You're building a mobile app solo. The backend is ready, and now you're working on the UI. You run your server locally and try making requests from the app—nothing works.

Why? Your base URL (http://localhost:<port> or http://127.0.0.1:<port>) points to your local machine, but your mobile device has its own localhost.

Realizing this, you deploy your backend to a free online service, but then:

The server shuts down after minutes of inactivity.
Network requests are painfully slow.

Ngrok to the rescue 🚀,

What is Ngrok?: Ngrok, is a tool that allows you expose your local server to the internet securely.

Getting Started

Head on to Ngrok - Signup

Signup, and...
Get your auth_token from the dashboard

MacOS:

brew install ngrok/ngrok/ngrok

ngrok config add-authtoken <your_auth_token>

Arch Linux

yay -S ngrok

ngrok config add-authtoken <your_auth_token>

Debian

wget https://bin.equinox.io/c/bNyj1mQVY4c/ngrok-stable-linux-amd64.deb

sudo dpkg -i ngrok-stable-linux-amd64.deb

ngrok config add-authtoken <your_auth_token>

What's Next

ngrok http http://127.0.0.1:<your-port>

Now ngrok will do it's thing 😁 and give you the following results.

ngrok                                                        (Ctrl+C to quit)

Session Status                online
Account                       your-email@example.com (Plan: Free)
Version                       3.x.x
Region                        United States (us)
Latency                       15ms
Web Interface                 http://127.0.0.1:4040
Forwarding                    https://random-subdomain.ngrok-free.app -> http://127.0.0.1:8000
Forwarding                    http://random-subdomain.ngrok-free.app  -> http://127.0.0.1:8000

Connections                   ttl     opn     rt1     rt5     p50     p90
                              0       0       0.00    0.00    0.00    0.00

Add the following to your apps build configuration.

https://random-subdomain.ngrok-free.app

And you're set to go 😁🚀

My Setup:

My running Server:

Ngrok Command:

Ngrok in action:

Conclusion

Ngrok is a game-changer when it comes to local development and testing. It eliminates the hassle of exposing your local server to the internet, making it easy to test APIs, webhooks, and mobile applications without deployment delays. With just a few commands, you get a secure, public URL that seamlessly tunnels traffic to your local machine.

Now, instead of struggling with localhost limitations or slow, unreliable free hosting, you can integrate Ngrok into your workflow and focus on building your app. 🚀

Give it a try, and happy coding! 💻🔥

DEV Community: Victor Chiaka