DEV Community: Coding With Patrik

How to Code Hangman in Go

Coding With Patrik — Thu, 15 May 2025 21:30:25 +0000

Hangman is a classic word-guessing game. In this tutorial we will create it in Go.

How to play

In case you don't know how to play hangman, here is how it works:

The computer picks a random word.
The word is hidden as underscores.
Guess one letter at a time.
Correct guesses reveal letters.
Incorrect guesses draw the hangman.
Win by guessing the word before the hangman is fully drawn.

Building the game

Initialize the Project

Start by creating a new Go project:

go mod init hangman

Create a main.go file:

package main
func main() {}

Set Up the Game

Add the following code to the main.go file.

package main

import (
    "fmt"
)

func main() {
    word := "golang"
    attempts := 6
    currentWordState := initializeCurrentWordState(word)

    fmt.Println("Welcome to Hangman!")
    displayCurrentState(currentWordState, attempts)
}

Here we have the word we will be guessing for now it's hardcoded to "golang". Later we will read this from a file. Other variables we have is the number of attempts, the current state of the word. We also display a welcome message and a function to display the current state of the word with remaining attempts.

Next we will create a function to initialize the current word state.

func initializeCurrentWordState(word string) []string {
    currentWordState := make([]string, len(word))
    for i := range currentWordState {
        currentWordState[i] = "_"
    }
    return currentWordState
}

This function creates a slice of the same length as the word and fills it with underscores.

After that we will create a function to display the current state of the word and the number of attempts left.

func displayCurrentState(currentWordState []string, attempts int) {
    fmt.Println("Current word state:", strings.Join(currentWordState, " "))
    fmt.Println("Attempts left:", attempts)
}

Dont forget to import the strings and fmt packages at the top of the file.

Our code should now look like this.

import (
    "fmt"
    "strings"
)
package main

func main() {
    word := "golang"
    attempts := 6
    currentWordState := initializeCurrentWordState(word)


    fmt.Println("Welcome to Hangman!")
    displayCurrentState(currentWordState, attempts)
}

func displayCurrentState(currentWordState []string, attempts int) {
    fmt.Println("Current word state:", strings.Join(currentWordState, " "))
    fmt.Println("Attempts left:", attempts)
}

func initializeCurrentWordState(word string) []string {
    currentWordState := make([]string, len(word))
    for i := range currentWordState {
        currentWordState[i] = "_"
    }
    return currentWordState
}

if we run this.

go run ./

we will get the following output.

Welcome to Hangman!
Current word state: _ _ _ _ _ _
Attempts left: 6

Read User Input & Game Loop

Add bufio and os to the import at the top of the file.

import (
    "bufio"
    "fmt"
    "os"
    "strings"
)

Declare a new scanner variable under the other variables.

word := "golang"
attempts := 6
currentWordState := initializeCurrentWordState(word)
scanner := bufio.NewScanner(os.Stdin)

Next we will create a function to get user input.

func getUserInput(scanner *bufio.Scanner) string {
    scanner.Scan()
    return scanner.Text()
}

This function will read the user input from the scanner and return it.

After that lets create our game loop and function to validate user input. Add it to the main function.

for attempts > 0 {
    displayCurrentState(currentWordState, attempts)
    userInput := getUserInput(scanner)
    if !isValidInput(userInput) {
        fmt.Println("Invalid input. Please enter a single letter.")
        continue
    }
}

It will continue until the user either wins or loses.

Lets create the isValidInput function and import unicode/utf8 at the top of the file.

import (
    "bufio"
    "fmt"
    "os"
    "strings"
    "unicode/utf8"
)

func isValidInput(input string) bool {
    return utf8.RuneCountInString(input) == 1
}

this function will check if the input is a single letter.

Check User Input

Create a new variable called guessedLetters and initialize it.

word := "golang"
attempts := 6
currentWordState := initializeCurrentWordState(word)
scanner := bufio.NewScanner(os.Stdin)
guessedLetters := make(map[string]bool)

This will be a map to store the guessed letters.

Next we will check if the user has already guessed the letter. If it's already guessed we continue the loop. Else we add it to the guessed letters.

if guessedLetters[userInput] {
    fmt.Println("You've already guessed that letter.")
    continue
}

guessedLetters[userInput] = true

After that we will check if the guess is correct and update the current word state.

correctGuess := updateGuessed(word, currentWordState, userInput)

Lets create the updateGuessed function.

func updateGuessed(word string, guessed []string, letter string) bool {
    correctGuess := false
    for i, char := range word {
        if string(char) == letter {
            guessed[i] = letter
            correctGuess = true
        }
    }
    return correctGuess
}

The updateGuessed function checks if a guessed letter is in the word, replaces underscores with the letter at the correct positions if found, and returns true or false based on whether the letter is found.

If the guess is incorrect we will decrement the attempts. Add this to the end of the game loop.

if !correctGuess {
    attempts--
}

Display Hangman State

Next we will display the hangman state. After the if statement that checks if the guess is correct add the following code.

displayHangman(6 - attempts)

Create a new file called hangman_states.go and add the following code.

package main

var hangmanStates = []string{
    `
  +---+
  |   |
      |
      |
      |
      |
=========
`,
    `
  +---+
  |   |
  O   |
      |
      |
      |
=========
`,
    `
  +---+
  |   |
  O   |
  |   |
      |
      |
=========
`,
    `
  +---+
  |   |
  O   |
 /|   |
      |
      |
=========
`,
    `
  +---+
  |   |
  O   |
 /|\  |
      |
      |
=========
`,
    `
  +---+
  |   |
  O   |
 /|\  |
 /    |
      |
=========
`,
    `
  +---+
  |   |
  O   |
 /|\  |
 / \  |
      |
=========
`}

This file containt a slice of strings representing the hangman states.

Next create the displayHangman function. It will be a simple function that prints the hangman state.

func displayHangman(incorrectGuesses int) {
    if incorrectGuesses >= 0 && incorrectGuesses < len(hangmanStates) {
        fmt.Println(hangmanStates[incorrectGuesses])
    }
}

We check if the incorrect guesses is within the range of the hangman states and print the corresponding state.

Or code in main.go should now look like this.

package main

func main() {
    word := "golang"
    currentWordState := initializeCurrentWordState(word)
    attempts := 6
    guessedLetters := make(map[string]bool)
    scanner := bufio.NewScanner(os.Stdin)

    fmt.Println("Welcome to Hangman!")

    for attempts > 0 {
        displayCurrentState(currentWordState, attempts)
        userInput := getUserInput(scanner)

        if !isValidInput(userInput) {
            fmt.Println("Invalid input. Please enter a single letter.")
            continue
        }

        if guessedLetters[userInput] {
            fmt.Println("You've already guessed that letter.")
            continue
        }

        guessedLetters[userInput] = true

        correctGuess := updateGuessed(word, currentWordState, userInput)

        if !correctGuess {
            attempts--
        }

        displayHangman(6 - attempts)
    }
}

Lets run the code and see what happens. We can now see the current state of the word and the hangman state is updated after each guess. We also get a message if we don't enter a valid input and if we have guessed a letter before.

Check if the word is guessed and if the user has lost

Now we need to check if the word is guessed or if the user has lost.

if isWordGuessed(currentWordState, word) {
    fmt.Println("Congratulations! You've guessed the word:", word)
    return
}

if attempts == 0 {
    fmt.Println("Game over! The word was:", word)
    return
}

Add this to the end of the game loop.

Lets create the isWordGuessed function.

func isWordGuessed(guessed []string, word string) bool {
    return strings.Join(guessed, "") == word
}

This function will check if the word is guessed by joining the guessed letters and comparing it to the word.

Generate a random word

The only thing left do is generate a random word from a file.

Download this file words.txt and add it to your project.

Replace word := "golang" with this.

word, err := getRandomWord("words.txt")
if err != nil {
    fmt.Println("Error reading word file:", err)
    return
}

In case we get an error we will print it else we will use the random word.

import math/rand at the top of the file.

import (
    "bufio"
    "fmt"
    "math/rand"
    "os"
    "strings"
    "unicode/utf8"
)

Lets create the getRandomWord function.

func getRandomWord(filename string) (string, error) {
    data, err := os.ReadFile(filename)
    if err != nil {
        return "", err
    }
    words := strings.Split(string(data), "\n")
    return words[rand.Intn(len(words))], nil
}

This function will read the file and split each line into words in a slice. Then it will return a random word from the slice.

We now have a complete hangman game. Feel free to play it and try to guess the word.

Conclusion

You've built a complete Hangman game in Go! This project taught you file handling, randomization, and user interaction. Feel free to expand and enhance the game further. I hope you enjoyed this tutorial and learned something from it.

Originally published on Coding With Patrik

Full source code can be found here Github

Complete REST API in Go – Build an Event App (Gin, JWT, SQL, Swagger)

Coding With Patrik — Thu, 15 May 2025 17:47:21 +0000

In this tutorial, we will build a REST API in Go using the Gin framework. We will create a simple event app where users can sign up, log in, create events, delete events, edit events and attend events. We will use JWT authentication, authorization to protect routes, middleware, SQL, migrations, and Swagger documentation.

The full article can be found at
Coding With Patrik

How to Use SQL in Go

Coding With Patrik — Wed, 14 May 2025 12:16:24 +0000

Learn how to use SQL in Go (Golang) using SQLite! This tutorial covers connecting to a database, writing queries, creating tables, CRUD operations, and handling context and timeouts. You will be using exec, query, and queryrow, scan methods.

Setting up the project

Start by opening a terminal.

Initialize a new project:
```
go mod init sql-in-go
```
Install the dependencies:

Install SQLite:
```
go get -u github.com/mattn/go-sqlite3
```

Connecting to the database

To connect to the database create a new file called main.go and add the following code:

package main

import (
    "database/sql"
    "log"

    _ "github.com/mattn/go-sqlite3"
)

func main() {
    db, err := sql.Open("sqlite3", "./shop.db")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()
}

We use the sql.Open function to open a connection to the database. The first argument is the driver name and the second argument is the database file path or the database connection string depending on the database.

We check if there is an error in opening the database connection. If there is an error, we log the error and exit the program.

The defer db.Close() ensures the database connection is closed when we are done.

Common database operations

Here is a list of the queries we will use:

Operation	Description	Example
Create	Create a new table if it does not exist	`CREATE TABLE IF NOT EXISTS orders (id INTEGER PRIMARY KEY, product TEXT, amount INTEGER);`
Insert	Insert new data into a table	`INSERT INTO orders (product, amount) VALUES ('Laptop', 1000);`
Query all	Retrieve all data from a table	`SELECT * FROM orders;`
Query with condition	Retrieve rows matching a condition from a table	`SELECT * FROM orders WHERE id = 1;`
Update	Modify existing data in a table	`UPDATE orders SET amount = 1500 WHERE id = 1;`
Delete	Remove data from a table	`DELETE FROM orders WHERE id = 1;`

Working with Orders & Database

Creating the OrderRepository struct

Create new folder called database and inside create a file called orders.go.

package database

import "database/sql"

type OrderRepository struct {
    Db *sql.DB
}

type Order struct {
    Id      int
    Product string
    Amount  int
}

We created a OrderRepository struct that holds the Db connection. This allows us to use it in the methods we will create. We also created an Order struct that will hold the order data.

Creating the order table

Let's add a method to create the order table.

func (r *OrderRepository) CreateTable() error {
    _, err := r.Db.Exec(`CREATE TABLE IF NOT EXISTS orders (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        product TEXT,
        amount INTEGER
    )`)

    return err
}

We use the Exec method to execute the query. The Exec method is used for queries that don't return any data.

CREATE TABLE IF NOT EXISTS: Creates a table only if it doesn't already exist.
INTEGER PRIMARY KEY AUTOINCREMENT: Sets up a unique identifier for each row that automatically increases.
TEXT: Represents a column for text data.
INTEGER: Represents a column for numeric data.

Viewing the orders table in a GUI

You can use a GUI tool like TablePlus to view the orders table.

Download it from here.

You should now be able to see the orders table in the GUI.

Inserting an order

Add a method to insert order data into the database.

func (r *OrderRepository) Insert(order Order) error {
    _, err := r.Db.Exec("INSERT INTO orders (product, amount) VALUES (?, ?)", order.Product, order.Amount)
    return err
}

INSERT INTO orders (product, amount) VALUES (?, ?): Inserts a new row into the orders table with the product and amount values.

The question marks are placeholders for the values we want to insert.

Always use placeholders instead of concatenating strings to avoid SQL injection.

Get all orders

func (r *OrderRepository) GetAll() ([]Order, error) {
    rows, err := r.Db.Query("SELECT * FROM orders")
    if err != nil {
        return nil, err
    }
    defer rows.Close()

    var orders []Order
    for rows.Next() {
        var order Order
        err := rows.Scan(&order.Id, &order.Product, &order.Amount)
        if err != nil {
            return nil, err
        }
        orders = append(orders, order)
    }
    return orders, nil
}

First we query the rows from the database using the Query method. The query method is used for queries that return data. The * is a wildcard it means that we want to select all columns.

We use defer rows.Close() to close the rows after we are done with them. This is to avoid memory leaks.

Then we iterate over the rows and scan the data into the Order struct. We check if there is an error in scanning the data and return it if there is one.

We append each order to the orders slice.

Finally we return the orders.

Retrieve a single order by id

func (r *OrderRepository) GetById(id int) (Order, error) {
    var order Order
    err := r.Db.QueryRow("SELECT * FROM orders WHERE id = ?", id).Scan(&order.Id, &order.Product, &order.Amount)
    if err != nil {
        return Order{}, err
    }
    return order, nil
}

Here we use the QueryRow method. Difference between the Query method and the QueryRow method is that the Query method returns multiple rows and the QueryRow method returns a single row. Then we pass the id as a placeholder to the where clause and scan the data into the Order struct.

If there is an error we return an empty Order and the error otherwise we return the order.

Update an order

func (r *OrderRepository) Update(order Order) error {
    _, err := r.Db.Exec("UPDATE orders SET product = ?, amount = ? WHERE id = ?", order.Product, order.Amount, order.Id)
    return err
}

UPDATE orders SET product = ?, amount = ? WHERE id = ?: Updates the product and amount columns for the row with the given id.

Delete an order

func (r *OrderRepository) Delete(id int) error {
    _, err := r.Db.Exec("DELETE FROM orders WHERE id = ?", id)
    return err
}

DELETE FROM orders WHERE id = ?: Deletes the row with the given id.

Testing create tables

Let's try it out. Add the following code to the main.go file:

package main

import (
    "database/sql"
    "log"
    "sql-in-go/database"

    _ "github.com/mattn/go-sqlite3"
)

func main() {
    dbConnection, err := sql.Open("sqlite3", "./shop.db")
    if err != nil {
        log.Fatal("Error opening database:", err)
    }
    defer dbConnection.Close()

    orderRepository := &database.OrderRepository{Db: dbConnection}

    err = orderRepository.CreateTable()
    if err != nil {
        log.Fatal("Error creating orders table:", err)
    }
}

We create the OrderRepository struct and passed the database connection to it.

After that we call the CreateTable method for the repository to create the table and check if there are any errors.

Open a terminal and run the following command:

go run main.go

It should create the shop.db file and the orders table inside it.

Inserting and retrieving data

Update the main.go file to insert data into the database.

package main

import (
    "database/sql"
    "log"
    "sql-in-go/database"

    _ "github.com/mattn/go-sqlite3"
)

func main() {
    dbConnection, err := sql.Open("sqlite3", "./shop.db")
    if err != nil {
        log.Fatal("Error opening database:", err)
    }
    defer dbConnection.Close()

    orderRepository := &database.OrderRepository{Db: dbConnection}

    err = orderRepository.CreateTable()
    if err != nil {
        log.Fatal("Error creating orders table:", err)
    }

    err = orderRepository.Insert(database.Order{Product: "Laptop", Amount: 10})
    if err != nil {
        log.Fatal("Error inserting order:", err)
    }

    err = orderRepository.Insert(database.Order{Product: "Keyboard", Amount: 50})
    if err != nil {
        log.Fatal("Error inserting order:", err)
    }

    orders, err := orderRepository.GetAll()
    if err != nil {
        log.Fatal("Error getting orders:", err)
    }

    log.Println(orders)
}

Updating & Deleting data

The only thing left to do is to update and delete data.

Update the main.go file to update and delete data.

package main

import (
    "database/sql"
    "log"
    "sql-in-go/database"

    _ "github.com/mattn/go-sqlite3"
)

func main() {
    dbConnection, err := sql.Open("sqlite3", "./shop.db")
    if err != nil {
        log.Fatal("Error opening database:", err)
    }
    defer dbConnection.Close()

    orderRepository := &database.OrderRepository{Db: dbConnection}

    err = orderRepository.CreateTable()
    if err != nil {
        log.Fatal("Error creating orders table:", err)
    }

    err = orderRepository.Insert(database.Order{Product: "Laptop", Amount: 10})
    if err != nil {
        log.Fatal("Error inserting order:", err)
    }

    err = orderRepository.Insert(database.Order{Product: "Keyboard", Amount: 50})
    if err != nil {
        log.Fatal("Error inserting order:", err)
    }

    orders, err := orderRepository.GetAll()
    if err != nil {
        log.Fatal("Error getting orders:", err)
    }

    log.Println(orders)

    order, err := orderRepository.GetById(orders[0].Id)
    if err != nil {
        log.Fatal("Error getting order:", err)
    }

    order.Amount = 1500
    err = orderRepository.Update(order)
    if err != nil {
        log.Fatal("Error updating order:", err)
    }

    orders, err = orderRepository.GetAll()
    if err != nil {
        log.Fatal("Error getting orders:", err)
    }

    log.Println(orders)

    err = orderRepository.Delete(order.Id)
    if err != nil {
        log.Fatal("Error deleting order:", err)
    }

    orders, err = orderRepository.GetAll()
    if err != nil {
        log.Fatal("Error getting orders:", err)
    }

    log.Println(orders)
}

Context & Timeout

You can use context and timeout to set a deadline for the query execution.

The Exec, Query, and QueryRow methods also have a context version that takes a context as an argument.

ExecContext, QueryContext, and QueryRowContext.

The reason why we use context and timeout is to avoid blocking the database connection for too long.

ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

err := r.Db.QueryContext(ctx, "SELECT * FROM orders")

Here we get the context from the context.Background() function and set a timeout of 5 seconds for the query execution. If the query execution takes longer than 5 seconds, it will be canceled.

Conclusion

In this tutorial, you learned how to use SQL in Go (Golang) with SQLite. You learned how to create, insert, retrieve, update, and delete data from the database.

Full source code can be found here Github

I hope you enjoyed this tutorial and learned something new.

Originally published on Coding With Patrik

PocketBase: Backend Made Simple

Coding With Patrik — Wed, 14 May 2025 10:36:04 +0000

If you're a solo developer or part of a small team, let me introduce you to one of the best-kept secrets in backend development: PocketBase.

PocketBase is an open-source backend server built in Go (Golang). It rolls database, authentication, real-time updates (through WebSocket connections), and file storage into a single, tiny executable file.

But don't let the small size fool you. PocketBase can also flex like a full framework thanks to built-in support for extending it with JavaScript or Go.

Why I Love PocketBase

One of my favorite things about PocketBase is how many built-in features it ships with. For every new app I build, I don't have to reinvent the wheel.

Built-in Dashboard

PocketBase comes with a slick built-in dashboard.

Here's what you can do inside it:

Manage your backend easily without touching a line of backend code.
View all your tables (or collections, as PocketBase calls them).
Create new collections set up fields with specific types (text, number, boolean, date, etc.).
Edit & delete records super intuitive and incredibly fast.
Set API rules: control whether collections are publicly available or restricted to authenticated users.
Backup your database to S3.
Run cron jobs to automate tasks.
View server logs to keep track of everything.

And much more.

Authentication Done Right

Out of the box, PocketBase supports email and password authentication. But it gets better: You can also add OAuth providers like Google, Facebook, GitHub, and more. Just plug in the provider's token, and you're ready to roll.

REST API

Every collections comes with CRUD REST API endpoints.

Full CRUD support for each collection.
Pagination, sorting, filtering, field selection — all baked right into the API.
Instant preview of what your responses will look like.
Set API rules: Control authentication and permissions for each collection.

Server Logs, cron jobs, email, backups and storage

All Built In.

Settings

A settings tab where you can configure general server settings.

Server Logs

A full server log viewer to keep track of everything.

Email

A email settings tab where you can configure SMTP settings, send test emails.

File Storage

A file storage settings tab where you can setup your s3 bucket to store files.

Backups

The backup settings tab allows you to configure database backups, create new ones, delete existing backups, restore from a backup, and more.

Cron Jobs

Cron jobs tab where you can schedule cron jobs to automate tasks. Comes with Pocketbase default cron jobs, but you can also add your own if you extend PocketBase as a framework.

Import/Export Like a Pro

Export all your collections as JSON with a click, or import them just as easily.

Final Thoughts

This was just a quick overview, but honestly, PocketBase is a game-changer for anyone looking to spin up powerful backends fast.

Whether you're building a SaaS app, a personal project, or anything in between, PocketBase should absolutely be on your radar. 🚀

FAQ About PocketBase

Is PocketBase suitable for mobile app backends?

Yes! PocketBase is lightweight and fast, making it a great choice for powering mobile app backends — especially for MVPs, internal tools, and indie apps.

Can I host PocketBase on my own server?

Absolutely. You can self-host PocketBase on your own VPS, server, or even locally during development.

Is PocketBase free to use?

Yes, PocketBase is completely open-source and free to use. You can even extend it and customize it to fit your specific project needs without licensing costs.

How does PocketBase compare to Firebase?

PocketBase and Firebase both offer backend services, but they target different needs.

Database Type

Firebase uses a NoSQL database (Firestore), which is flexible but less structured.
PocketBase, on the other hand, uses an embedded SQL database (SQLite), giving you strong relational data support with clear structure and constraints.

Hosting

Firebase is a managed service hosted on Google's servers — you don't have to manage infrastructure, but you're tied to Google's platform and pricing.
PocketBase is a self-hosted solution — you run it on your own server, VPS, or cloud provider, giving you full control over data, backups, and server configurations.

Pricing

Firebase has a generous free tier, but costs can quickly rise as your app scales, especially with real-time database reads/writes and storage.
PocketBase itself is free and open-source, you only pay for whatever hosting you choose, often making it cheaper in the long run.

Flexibility

PocketBase allows you to extend the backend with custom Go code, adding APIs, events, and business logic exactly how you want.
With Firebase, you're mostly limited to what Google offers, unless you add Cloud Functions (which have their own costs and limits).

Best for

Use Firebase if you want a fast launch with minimal server management and don't mind vendor lock-in.
Use PocketBase if you want full control, relational data, and a backend you can completely customize without relying on a third party.

In short

Firebase is easy but centralized.
PocketBase is lightweight, powerful, and yours to own.

Can I integrate PocketBase with other services?

Yes. You can easily integrate PocketBase with third-party APIs, frontend frameworks, and cloud storage providers like AWS S3, thanks to its flexible API and extensibility with JavaScript or Go.

How do I extend PocketBase with Go?

To extend PocketBase with Go.

Create a new folder with the name of your project and create a main.go file with the following content:

package main

import (
    "log"
    "os"

    "github.com/pocketbase/pocketbase"
    "github.com/pocketbase/pocketbase/apis"
    "github.com/pocketbase/pocketbase/core"
)

func main() {
    app := pocketbase.New()

    app.OnServe().BindFunc(func(se *core.ServeEvent) error {
        // serves static files from the provided public dir (if exists)
        se.Router.GET("/{path...}", apis.Static(os.DirFS("./pb_public"), false))

        return se.Next()
    })

    if err := app.Start(); err != nil {
        log.Fatal(err)
    }
}

Init dependencies:
```
go mod init myapp && go mod tidy
```
Start the PocketBase server:
```
go run . serve
```

By doing this, you can fully customize how PocketBase behaves for your project.

Originally published on Coding With Patrik

Is Go Worth Learning in 2025?

Coding With Patrik — Wed, 14 May 2025 07:46:35 +0000

The tech world in 2025 is moving faster than ever, with cloud computing, microservices, and scalable infrastructure leading the way.

Go (Golang) was built for exactly this environment, simple, fast, and designed to tackle real-world engineering challenges at scale.

If you're wondering whether it's still a good idea to learn, the short answer is yes and in this article, we'll break down why.

The Job Market Speaks: Go Developers Are in Demand

If you're looking for a language that opens doors, Go is a great pick.

High Salaries: According to Glassdoor and Golang Cafe, Go developers in the U.S. earn an average salary of around $132,651/year, with entry-level roles starting around $116,000 and senior engineers easily making $170,000+.
Global Demand: Go isn't just popular in the U.S. — it's gaining traction in Europe, India, Australia, and across Southeast Asia.
Top Companies Use It: Companies like Google, Uber, Dropbox, and Cloudflare rely on Go for building fast, scalable backend systems.

In short: learning Go can open up some seriously good opportunities.

Go Is Built for What Comes Next

Go was designed to solve modern challenges — and it still shines today.

Concurrency Built-In: Go's goroutines and channels make it easier to write code that handles many tasks at once, without a headache.
Cloud-Native Friendly: Lightweight and fast, Go apps fit perfectly into containerized environments like Docker and Kubernetes.
A Sweet Spot: While Python can be slow and Rust can feel complicated, Go hits a balance between speed, simplicity, and reliability.

Beginner Friendly

One of the best things about Go? It's easy to get started and satisfying to stick with.

Simple, Readable Syntax: Go keeps things clean and straightforward. You don't need to memorize mountains of rules to write solid code.
Helpful Standard Library: Need to build a web server or work with files? Go's built-in tools make it easy, no need for huge third-party frameworks.
Automatic Garbage Collection: Go handles memory management behind the scenes, so you can focus more on building features and less on debugging memory leaks.

Ecosystem Momentum: It's More Than Just a Language

A language is only as strong as its ecosystem and Go's is thriving.

Huge Open-Source Community: Check out projects on Awesome Go — you'll find everything from web frameworks, CLI tools, machine learning, and more.
Powering the Cloud: Tools like Docker, Kubernetes, and Terraform are all built in Go.
Stable and Evolving: Go is actively maintained with regular releases, keeping it modern without losing its simple, stable foundation. Latest release notes of Go can be found here.

Where Go Really Shines

Go's sweet spot is building real-world, scalable systems. Here's where it truly excels:

🛠 Backend APIs & Microservices

Go's simplicity and performance make it a top choice for building clean, modular APIs. Its concurrency model makes it easy to scale microservices without drowning in complexity.

☁️ Cloud-Native App

Go was practically designed for the cloud. With fast startup times, tiny memory footprints. Go applications are lightweight and highly portable. It's the language of choice for developers building on AWS, GCP, or Azure.

⚙️ DevOps & Infrastructure Tools

Look under the hood of tools like Docker, Kubernetes, and Terraform and you'll find Go. It's become the de facto language for DevOps tooling, thanks to its speed, concurrency support, and ease of cross-compilation.

🚀 High-Traffic Scalable Systems

When your app needs to handle millions of requests per second, Go can build web services and distributed systems that are both blazing fast and resource efficient.

The Learning Curve: Surprisingly Smooth

Learning Go feels refreshingly straightforward.

Designed to Be Easy: The A Tour of Go tutorial walks you through the basics interactively.
Amazing Docs: The official Go documentation is one of the most readable and helpful you'll find.
Community Help: Places like r/golang, Stack Overflow are full of friendly developers happy to help.

Challenges and Misconceptions

No language is perfect, and Go has its limitations:

Not Great for GUI Apps: While possible, building desktop apps is smoother with other tools.
Not Focused on Data Science: Python still dominates in ML and data-heavy work.
Common Myth - "Go is only for Google-scale problems": Totally not true! Go fits perfectly for solo projects, startups, and mid-sized apps too.

Final Verdict: Should You Learn Go in 2025?

✅ Yes!

If you want a language that's simple to learn, powerful to use, and highly in demand, Go is a smart bet for 2025 and beyond.

It's especially great for:

Backend developers
Cloud engineers
DevOps professionals
Career changers looking for a high-paying, future-proof skill

Learn it, build with it, and watch your career grow.

Originally published on Coding With Patrik

How to Build A CLI Todo App in Go

Coding With Patrik — Tue, 13 May 2025 21:41:49 +0000

In this tutorial, I'm going to show you how to create a CLI To-Do app using Go (Golang).

We'll build this application from the ground up, and by the end, you’ll have a working command-line tool where you can manage your todos.

You’ll gain practical experience in working with flag arguments to parse command-line inputs and handling JSON data for storing and reading your todos directly from a JSON file.

Setup

Main File Setup

Create a main.go file with package main & a main function. For now we can just print out something we will come back to it later.

package main

import "fmt"

func main() {
    fmt.Println("Inside main in todo app")
}

Todo Structure

Create a todo.go here we will define the todo structure & functionality.

type Todo struct {
    Title       string
    Completed   bool
    CreatedAt   time.Time
    CompletedAt *time.Time
}

These are all the fields we will need for a todo. We also need a slice that will hold all our todos.

type Todos []Todo

Todo Functionality

We are now gonna implement all the methods lets start by creating the add method.

func (todos *Todos) add(title string) {
    todo := Todo{
        Title:       title,
        Completed:   false,
        CompletedAt: nil,
        CreatedAt:   time.Now(),
    }

    *todos = append(*todos, todo)
}

In this method, we create a new to-do item by setting it's title and marking it as not completed, with the creation date set to the current time. We then add this new todo directly to the existing list of to-dos using a pointer (*todos). This pointer allows us to access and modify the original list stored in memory.

After that we gonna add a helper method that checks if the provided index for operations like remove, edit, or toggle is valid

func (todos *Todos) validateIndex(index int) error {
    if index < 0 || index >= len(*todos) {
        err := errors.New("invalid index")
        fmt.Println(err.Error())
        return err
    }
    return nil
}

If the index is out of bounds, it prints an 'invalid index' error and returns it. Otherwise, it returns nil, indicating the index is valid.

The next method we will implement is the delete method

func (todos *Todos) delete(index int) error {
    t := *todos
    if err := t.validateIndex(index); err != nil {
        return err
    }

    *todos = append(t[:index], t[index+1:]...)

    return nil
}

In the delete method, we first verify the provided index using our helper method to ensure it is within the valid range. If the index is valid, we remove the to-do item by splitting the list at the specified index. We then join the two sections before and after the index, which removes the item from the list.

Running the App

To see our to-do application in action, let's open the main.go file and run a quick test.

package main

import "fmt"

func main() {
    todos := Todos{}
    todos.add("Buy Milk")
    todos.add("Buy Bread")
    fmt.Printf("%+v\n\n", todos)
    todos.delete(0)
    fmt.Printf("%+v", todos)
}

This allows us to add items to our to-do list and remove them as needed. Next, we'll enhance the functionality by adding the ability to toggle a to-do's completion status.

func (todos *Todos) toggle(index int) error {
    t := (*todos)
    if err := t.validateIndex(index); err != nil {
        return err
    }

    isCompleted := t[index].Completed

    if !isCompleted {
        completionTime := time.Now()
        t[index].CompletedAt = &completionTime
    }

    t[index].Completed = !isCompleted

    return nil
}

In the toggle method, we start by dereferencing the todos pointer and validating the provided index to ensure it is within the correct range. If the item at this index is not already completed, we mark the current time as its completion time. We then flip the Completed status. If it was false (not completed), it becomes true (completed), and vice versa.

Next we have the edit metod.

func (todos *Todos) edit(index int, title string) error {
t := *todos

if err := t.validateIndex(index); err != nil {
    return err
}

t[index].Title = title

return nil
}

Same as the other methods we validate the index if it's valed get the todo from the todos slice and update the tile.

The final method we need for our to-do list is a way to display it neatly. We'll use a third-party package to create a visually appealing table. First, install the package by running the following command in the terminal.

Go get github.com/aquasecurity/table

Next, we'll create a method called print.

func (todos *Todos) print() {
    table := table.New(os.Stdout)
    table.SetRowLines(false)
    table.SetHeaders("#", "Title", "Completed", "Created At", "Completed At")

    for index, t := range *todos {
        completed := "❌"
        completedAt := ""
       
        if t.Completed {
            completed = "✅"
            if t.CompletedAt != nil {
                completedAt = t.CompletedAt.Format(time.RFC1123)

            }

        }

        table.AddRow(strconv.Itoa(index), t.Title, completed, t.CreatedAt.Format(time.RFC1123), completedAt)

    }

    table.Render()
}

In this method, we set up a new table directed to output in the console. We configure the table by turning off row lines and setting column headers.

Then, we loop through each to-do item. If an item is completed, we mark it with a checkmark and include the completion date. Otherwise, we use a cross mark and leave the completion date blank. Each to-do item is added as a row in the table with its details.

Finally, we render the table to the console.

Here is the full code for the todo.go

package main

import (
    "errors"
    "fmt"
    "os"
    "strconv"
    "time"

    "github.com/aquasecurity/table"
)

type Todo struct {
    Title       string
    Completed   bool
    CreatedAt   time.Time
    CompletedAt *time.Time
}

type Todos []Todo

func (todos *Todos) add(title string) {
    todo := Todo{
        Title:       title,
        Completed:   false,
        CompletedAt: nil,
        CreatedAt:   time.Now(),
    }

    *todos = append(*todos, todo)
}

func (todos *Todos) validateIndex(index int) error {
    if index < 0 || index >= len(*todos) {
        err := errors.New("invalid index")
        fmt.Println(err)
        return err
    }

    return nil
}

func (todos *Todos) delete(index int) error {
    t := *todos

    if err := t.validateIndex(index); err != nil {
        return err
    }

    *todos = append(t[:index], t[index+1:]...)

    return nil
}

func (todos *Todos) toggle(index int) error {
    t := *todos

    if err := t.validateIndex(index); err != nil {
        return err
    }

    isCompleted := t[index].Completed

    if !isCompleted {
        completionTime := time.Now()
        t[index].CompletedAt = &completionTime
    }

    t[index].Completed = !isCompleted

    return nil
}

func (todos *Todos) edit(index int, title string) error {
    t := *todos

    if err := t.validateIndex(index); err != nil {
        return err
    }

    t[index].Title = title

    return nil
}

func (todos *Todos) print() {
    table := table.New(os.Stdout)
    table.SetRowLines(false)
    table.SetHeaders("#", "Title", "Completed", "Created At", "Completed At")
    for index, t := range *todos {
        completed := "❌"
        completedAt := ""

        if t.Completed {
            completed = "✅"
            if t.CompletedAt != nil {
                completedAt = t.CompletedAt.Format(time.RFC1123)
            }
        }

        table.AddRow(strconv.Itoa(index), t.Title, completed, t.CreatedAt.Format(time.RFC1123), completedAt)
    }

    table.Render()
}

Lets’ try it out.

package main

func main() {
    todos := Todos{}
    todos.add("Buy Milk")
    todos.add("Buy Bread")
    todos.toggle(0)
    todos.print()
}

We start by adding a couple of tasks: 'Buy Milk' and 'Buy Bread'. Next, we toggle the completion status of the first item to mark it as complete. Then, we use the print method to display our tasks in a structured table.

It would be nice to have functionality to save our to-do list to a file and read it back from there, keeping our data persistent between sessions. Let’s implement that next.

Create a file called storage.go

import (
    "encoding/json"
    "os"
)

type Storage[T any] struct {
    FileName string
}

func NewStorage[T any](fileName string) *Storage[T] {
    return &Storage[T]{FileName: fileName}
}

func (s *Storage[T]) Save(data T) error {
    fileData, err := json.MarshalIndent(data, "", "")
   
    if err != nil {
        return err
    }
   
    return os.WriteFile(s.FileName, fileData, 0644)
}

func (s *Storage[T]) Load(data *T) error {
    fileData, err := os.ReadFile(s.FileName)
   
    if err != nil {
        return err
    }

    return json.Unmarshal(fileData, data)
}

This code defines a Storage structure to manage file operations generically, which means it can handle any type, such as our to-do list or other data types in the future.

In the NewStorage We initiate a Storage instance with a specified file name.

The save function takes any data of type T and saves it into a file in JSON format. It neatly formats the JSON for better readability and sets appropriate file permissions.

The load function retrieves data from the specified file and converts the JSON back into our data structure of type T.

Lets try it out

package main

func main() {
    todos := Todos{}
    storage := NewStorage[Todos]("todos.json")
    storage.Load(&todos)
    todos.add("Buy Milk")
    todos.add("Buy Bread")
    todos.toggle(0)
    todos.print()
    storage.Save(todos)
}

We start by creating a new storage with the Todos type & the file name todos.json. This file doesn’t exist, so the Load function won’t find any data to load. We then add some todos to our list and save them. This process creates the todos.json file with our new data. If we run the program again, it will load the todos from this file back into the program.

The last part that is missing is to be able to run the program with different commands. Create a new file called command.go

package main

import (
    "flag"
    "fmt"
    "os"
    "strconv"
    "strings"
)

type CmdFlags struct {
    Add    string
    Del    int
    Edit   string
    Toggle int
    List   bool
}

func NewCmdFlags() *CmdFlags {
    cf := CmdFlags{}
   
    flag.StringVar(&cf.Add, "add", "", "Add a new todo specify title")
    flag.StringVar(&cf.Edit, "edit", "", "Edit a todo by index & specify a new title. id:new_title")
    flag.IntVar(&cf.Del, "del", -1, "Specify todo by index to delete")
    flag.IntVar(&cf.Toggle, "toggle", -1, "Specify todo by index to toggle complete true/false")
    flag.BoolVar(&cf.List, "list", false, "List all todos")
   
    flag.Parse()
   
    return &cf
}

This block of code sets up the structure with all available commands and initializes the command-line flags. Each flag is defined with a specific type, a pointer to the data, a default value, and a description. We then parse these flags to populate the CmdFlags structure.

Next, we implement an Execute function that evaluates the values in CmdFlags and invokes the corresponding method from the Todos structure


func (cf *CmdFlags) Execute(todos *Todos) {
    switch {
    case cf.List:
        todos.print()
    case cf.Add != "":
        todos.add(cf.Add)
    case cf.Edit != "":
        parts := strings.SplitN(cf.Edit, ":", 2)
        if len(parts) != 2 {
            fmt.Println("Error: Invalid format for edit. Please use index:new_title")
            os.Exit(1)
        }
        index, err := strconv.Atoi(parts[0])
        if err != nil {
            fmt.Println("Error: Invalid index for edit.")
            os.Exit(1)

        }
        todos.edit(index, parts[1])
    case cf.Toggle != -1:
        todos.toggle(cf.Toggle)

    case cf.Del != -1:
        todos.delete(cf.Del)

    default:
        fmt.Println("Invalid command")
    }
}

This function checks each flag in the CmdFlags to see which action should be performed,

Here is the full code for the command.go

package main

import (
    "flag"
    "fmt"
    "os"
    "strconv"
    "strings"
)

type CmdFlags struct {
    Add    string
    Del    int
    Edit   string
    Toggle int
    List   bool
}

func NewCmdFlags() *CmdFlags {
    cf := CmdFlags{}

    flag.StringVar(&cf.Add, "add", "", "Add a new todo specify title")
    flag.StringVar(&cf.Edit, "edit", "", "Edit a todo by index & specify a new title. id:new_title")
    flag.IntVar(&cf.Del, "del", -1, "Specify a todo by index to delete")
    flag.IntVar(&cf.Toggle, "toggle", -1, "Specify a todo by index to toggle")
    flag.BoolVar(&cf.List, "list", false, "List all todos")

    flag.Parse()

    return &cf
}

func (cf *CmdFlags) Execute(todos *Todos) {
    switch {
    case cf.List:
        todos.print()
    case cf.Add != "":
        todos.add(cf.Add)
    case cf.Edit != "":
        parts := strings.SplitN(cf.Edit, ":", 2)
        if len(parts) != 2 {
            fmt.Println("Error, invalid format for edit. Please use id:new_title")
            os.Exit(1)
        }

        index, err := strconv.Atoi(parts[0])

        if err != nil {
            fmt.Println("Error: invalid index for edit")
            os.Exit(1)
        }

        todos.edit(index, parts[1])

    case cf.Toggle != -1:
        todos.toggle(cf.Toggle)

    case cf.Del != -1:
        todos.delete(cf.Del)

    default:
        fmt.Println("Invalid command")
    }
}

Finally, we update the main.go file to integrate these changes

package main

func main() {
todos := Todos{}

storage := NewStorage[Todos]("todos.json")
storage.Load(&todos)

cmdFlags := NewCmdFlags()
cmdFlags.Execute(&todos)

storage.Save(todos)
}

In the main function, we initialize the Todos and Storage, load any existing todos from a file, process commands based on user input, and then save any changes back to the file.

Full source code can be found here Github

Conclusion

We've reached the end of our tutorial on how to build a CLI to-do application using Go. Feel free to expand on what we've covered by adding new features or enhancing existing ones to make the app even more robust. Thank you for joining me today. See you in the next video!

Originally published on Coding With Patrik

What Is the Best Web Framework for Go?

Coding With Patrik — Tue, 13 May 2025 21:21:19 +0000

Go's ecosystem has exploded with web frameworks over the past few years. Whether you're building a REST API or a full-stack solution, there's likely a framework tailored to your needs.

What this article covers:

We'll walk through the top Go frameworks, compare their features, performance, community support, and use cases. This will help you determine which one best suits your project.

How to Choose the Right Go Framework

Before diving into individual frameworks, here are some key factors to consider:

Project Type

Are you building a REST API, microservice, monolithic app, or a full-stack enterprise solution?

Performance Needs

Do you need to handle millions of requests per second, or is development speed more important?

Development Speed vs. Flexibility

Some frameworks are opinionated and offer rapid development. Others give you more control but require more setup.

Community & Ecosystem

A vibrant community means better documentation, more plugins, and faster bug fixes.

Learning Curve

Consider your team's experience and familiarity with Go and similar web frameworks.

Top Go Frameworks

Gin: The Fast, Popular Workhorse

Brief description:

Gin is the most widely adopted web framework in the Go ecosystem. It's designed for speed and simplicity, and it's particularly well-suited for building high-performance REST APIs.

Key features:

Fast HTTP router
Middleware support
Built-in JSON rendering and validation
Error handling and logging out of the box
Extensive documentation and active community

Pros & Cons:

✅ Blazing fast performance
✅ Minimalist, low-overhead design
✅ Large community and mature ecosystem

❌ Less opinionated, you'll assemble more by hand
❌ Lacks full-stack utilities like ORM or template engines

Ideal use cases:

High-performance REST APIs
Microservices
Applications needing minimal latency

GitHub stats + resources:

⭐ Gin on GitHub (80k+ stars)
📘 Gin Examples and Docs
📝 Complete REST API in Go – Build an Event App (Coding with Patrik)

Echo: Clean, Lightweight, and Scalable

Brief description:

Echo is a high-performance, extensible framework with a minimal footprint. It excels in building scalable RESTful APIs and microservices with clean code and structured organization.

Key features:

Lightweight, fast router
Built-in middleware for logging, CORS, etc.
Automatic binding for JSON/XML/Form data
Centralized error handling
Intuitive API design

Pros & Cons:

✅ Clean, structured codebase
✅ Easy to extend and customize
✅ Active ecosystem with good documentation

❌ Smaller ecosystem compared to Gin
❌ Less full-featured out-of-the-box for large apps

Ideal use cases:

Lightweight APIs
Scalable microservices
Projects where structure and clarity are priorities

GitHub stats + resources:

⭐ Echo on GitHub (30k+ stars)
📘 Echo Documentation

Beego: All-in-One MVC for Enterprises

Brief description:

Beego is a full-featured MVC framework inspired by Django and Rails. It offers built-in ORM, routing, sessions, and a CLI. It's ideal for enterprise-grade, full-stack Go applications.

Key features:

MVC architecture with strong separation of concerns
Built-in ORM and web server
Code generation and CLI tools
Integrated logging and session management

Pros & Cons:

✅ Enterprise-ready toolchain
✅ Built-in scaffolding for rapid development
✅ Good documentation and legacy use

❌ Heavier learning curve
❌ Less active than Gin or Echo in recent years

Ideal use cases:

Enterprise apps
Admin dashboards
Full-stack monoliths

GitHub stats + resources:

⭐ Beego on GitHub (30k+ stars)
📘 Beego Documentation

Fiber: Lightning Fast and Express-Inspired

Brief description:

Fiber is a modern web framework built on top of FastHTTP, Go's fastest HTTP engine. Inspired by Express.js, it offers an intuitive API and top performance.

Key features:

Express-style API for fast onboarding
Low memory footprint
Static file handling
Built-in middleware system
Built on FastHTTP for speed

Pros & Cons:

✅ Top performance
✅ Great for Express.js developers transitioning to Go
✅ Active community and rapid development

❌ Not compatible with net/http standard
❌ Smaller ecosystem and fewer integrations

Ideal use cases:

Real-time services
High-throughput microservices
Developers familiar with Express.js

GitHub stats + resources:

⭐ Fiber on GitHub (35k+ stars)
📘 Fiber Docs

Honorable Mentions

net/http ServeMux (Standard Library):

Go's built-in http.ServeMux is minimal, fast, and rock-solid. It supports basic routing via path matching and allows handling different HTTP methods. it's a great starting point and perfectly suitable for small services, internal tools, or projects that value zero dependencies.

Gorilla Mux:

A robust HTTP router with powerful matching rules. Not a full framework, but widely used in custom Go setups.

Revel:

A full-stack framework with hot reload and code generation. Great for rapid prototyping.

Go Kit:

A toolkit for building reliable, maintainable microservices. Focused more on architecture than web-specific needs.

Buffalo:

A "Rails for Go" framework, includes everything from front-end tools to database migrations. Excellent for rapid development. (Sadly, it's not maintained anymore.)

Feature Breakdown

💡 Overview

Framework	Performance	Features	Community	Onboarding	Best Use Case
Gin	⭐⭐⭐⭐⭐	⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐ Easy	REST APIs, microservices
Echo	⭐⭐⭐⭐⭐	⭐⭐⭐	⭐⭐⭐	⭐⭐ Easy	Scalable APIs, clean architecture
Fiber	⭐⭐⭐⭐⭐	⭐⭐⭐	⭐⭐⭐	⭐⭐ Easy	Real-time apps, Express.js style
Beego	⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐	⭐⭐⭐ Medium	Enterprise-grade full-stack apps
Buffalo	⭐⭐	⭐⭐⭐⭐	⭐⭐	⭐⭐ Medium	Full-stack apps with front-end
Go Kit	⭐⭐⭐	⭐⭐	⭐	⭐⭐⭐ Hard	Large-scale microservices
ServeMux	⭐⭐⭐	⭐	⭐⭐⭐	⭐ Easy	Internal tools, zero-dependency

🚀 Features

Framework	Advanced Routing	Middleware	ORM	CLI Tools	Template Engine
Gin	✅	✅	❌	❌	❌
Echo	✅	✅	❌	❌	❌
Fiber	✅	✅	❌	❌	❌
Beego	✅	✅	✅	✅	✅
Buffalo	Moderate	✅	✅	✅	✅
Go Kit	✅	⚠️ Manual	❌	❌	❌
ServeMux	Basic	⚠️ Manual	❌	❌	❌

Conclusion: What's the Best Framework for You?

Choosing the best framework depends on what you're building:

🏆 Best All-Rounder: Gin
Fast, battle-tested, and minimal. Perfect for REST APIs and microservices.

✨ Most Elegant: Echo
Clean structure, great for scalable APIs with modern code practices.

⚡ Fastest & Express-like: Fiber
Wins on raw speed and familiar syntax if you're coming from Express.js.

🏢 Enterprise-Ready: Beego
Is your go to if you want everything baked in: MVC, ORM, and tooling.

🔧 Barebones Simplicity: ServeMux
Great for tiny services or when you want zero dependencies.

💡 Final take:
The best framework is the one that fits your needs.

Here's a list of Go web frameworks ranked by GitHub stars: Go Web Framework Stars – mingrammer

Originally published on Coding With Patrik