DEV Community: luthfisauqi17

Visualize Data in 5 Lines of Code with Golang and Asciigraph

luthfisauqi17 — Sun, 05 Apr 2026 03:12:35 +0000

Data visualization doesn't always have to happen in a complex web dashboard or a heavy GUI application. Sometimes, when you are building CLI tools or monitoring system metrics, you want a quick and lightweight way to see trends directly in your terminal.

In this post, we will explore a very interesting Go library called Asciigraph. This library allows you to create beautiful ASCII line graphs with minimal effort.

Why Asciigraph?

Asciigraph is perfect for developers who want to:

Visualize data without leaving the terminal.
Add graphical monitoring to CLI applications.
Keep their tools lightweight and dependency-free from heavy plotting libraries.

Prerequisites

Before we dive in, make sure you have Go installed on your machine. We will start by setting up a new project directory.

mkdir golang-asciigraph
cd golang-asciigraph
go mod init golang-graph

Installation

To get started, you need to install the library by running the following command:

go get github.com/guptarohit/asciigraph

Creating Your First Graph

Let’s write a simple program to plot a basic set of data. Create a file named main.go and add the following code:

package main

import (
    "fmt"
    "github.com/guptarohit/asciigraph"
)

func main() {
    // Define your data series
    data := []float64{3, 4, 9, 6, 2, 4, 5, 8, 5, 10, 2, 7, 2, 5, 6}

    // Generate the graph
    graph := asciigraph.Plot(data)

    // Print the output to the terminal
    fmt.Println(graph)
}

Running the Code

Execute the program using the command:

go run main.go

You will see a clean line graph rendered entirely in ASCII characters, following the peaks and valleys of your data points.

Use Case Ideas

The possibilities with this library are endless. Here are a few ideas on how you could implement it:

Network Monitoring: Visualize ping response times in real-time.
System Metrics: Monitor CPU or RAM usage directly from a terminal dashboard.
Crypto/Stock Tracker: Build a small CLI tool to watch price fluctuations.

Conclusion

This is just the beginning. Asciigraph also supports advanced configurations like setting the graph height, width, and adding captions. In the next part of this series, I will show you more advanced techniques to make your terminal graphs even more dynamic.

If you have any interesting ideas on how to use this library, feel free to share them!

Special thanks to Rohit Gupta for the incredible asciigraph library. You can find the source code here: https://github.com/guptarohit/asciigraph

Customizing 404 and 405 Error Responses in Golang Chi

luthfisauqi17 — Mon, 23 Mar 2026 17:00:00 +0000

When building a robust REST API with Golang, providing clear and consistent error responses is crucial for a good developer experience. By default, the Chi router provides standard text responses for missing routes or incorrect HTTP methods. However, you might want to return custom JSON or specific messages that align with your application's design.

In this guide, we will explore how to implement custom handlers for 404 Not Found and 405 Method Not Allowed using the Chi router.

1. Handling "404 Not Found"

A 404 error occurs when a user or client tries to access a route that hasn't been defined in your router.

To create a custom 404 handler, you need to define a standard http.HandlerFunc and then register it using r.NotFound.
The Handler:

func handleNotFound(w http.ResponseWriter, r *http.Request) {
    w.WriteHeader(http.StatusNotFound)
    w.Write([]byte("This route does not exist"))
}

Registration:
Place this right after your router initialization:

r := chi.NewRouter()
r.NotFound(handleNotFound)

Now, instead of the default browser or Chi message, the client will receive your custom string whenever they hit an undefined endpoint.

2. Handling "405 Method Not Allowed"

A 405 error happens when the endpoint exists, but the HTTP method used (e.g., POST instead of GET) is not supported by that specific route.

Similar to the 404 handler, you create a function and register it using r.MethodNotAllowed.

The Handler:

func handleMethodNotAllowed(w http.ResponseWriter, r *http.Request) {
    w.WriteHeader(http.StatusMethodNotAllowed)
    w.Write([]byte("Yo, this method is not allowed for this endpoint"))
}

Registration:

r.MethodNotAllowed(handleMethodNotAllowed)

Why Use Custom Handlers?

Consistency: Ensure all your error responses follow the same format (e.g., always returning JSON).
Branding/UX: You can provide more helpful messages or even redirect users to a documentation page.
Debugging: You can log these specific errors more effectively within your custom handler logic.

Conclusion

The Chi router makes it incredibly simple to override default behaviors. By using r.NotFound() and r.MethodNotAllowed(), you gain full control over how your API communicates failures to the outside world.

Happy coding!

Handling URL Parameters in Golang with Chi Router

luthfisauqi17 — Sun, 22 Mar 2026 17:00:00 +0000

In web development, one of the most common tasks is retrieving dynamic data from a URL, such as a specific ID for a book, user, or product. If you are using the Chi router in Golang, this process is incredibly straightforward and idiomatic.

In this article, we’ll walk through how to capture and process URL parameters in your Go handlers.

1. Defining the Route with a Parameter

To start, you need to define a route that includes a placeholder for your parameter. In Chi, this is done using the {} syntax. For example, if you want to create an endpoint to fetch a book by its ID, your route would look like this:

r.Get("/books/{bookID}", handleGetBookByID)

In this case, {bookID} acts as a dynamic identifier that can be replaced by any value (like 7, 10, or abc) when a user visits the URL.

2. Creating the Handler Function

Next, create the handler function to process the request. The signature remains the same as a standard HTTP handler:

func handleGetBookByID(w http.ResponseWriter, r *http.Request) {
    // Logic goes here
}

3. Extracting the Parameter Value

This is where Chi makes things easy. To retrieve the value of {bookID} from the URL, you use the chi.URLParam function. This function takes the current request context and the name of the parameter you defined in your route.

func handleGetBookByID(w http.ResponseWriter, r *http.Request) {
    // Get the value of 'bookID' from the URL
    bookID := chi.URLParam(r, "bookID")

    // For demonstration, we'll just print it to the response
    fmt.Fprintf(w, "The Book ID is: %s", bookID)
}

4. Testing the Endpoint

Once you run your application (using go run main.go), you can test it in your browser or via a tool like Postman:

URL: http://localhost:8080/books/10 Output: The Book ID is: 10
URL: http://localhost:8080/books/7 Output: The Book ID is: 7

The output will dynamically change based on whatever value you provide in the URL parameter spot.

Conclusion

Using chi.URLParam is an efficient and clean way to handle dynamic routing in your Golang backend. It allows you to build RESTful APIs that can easily identify and serve specific resources based on user input.

Happy coding!

Mastering Routing in Golang with Chi: A Beginner’s Guide

luthfisauqi17 — Sun, 22 Mar 2026 14:08:56 +0000

In modern web development, understanding how to manage your application's endpoints is crucial. If you are building HTTP services in Go, you need a router that is both lightweight and powerful. That’s where Chi comes in.

In this post, we will explore the fundamentals of routing using the Chi library, building upon our previous basic implementation.

What is Routing?

At its core, routing refers to how an application’s endpoints respond to specific client requests. Think of a router as a traffic controller: it takes an incoming request (like a URL) and directs it to the appropriate function to handle it.

Getting Started with Chi Router

If you followed the previous tutorial, you might have noticed we already initialized a router. In Chi, creating a new router is as simple as:

r := chi.NewRouter()

This r object is now responsible for managing all the endpoints in your application.

1. Defining Endpoints

An endpoint is a specific path that users can hit to get a response. For example, a simple "Hello World" endpoint looks like this:

r.Get("/", func(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello World"))
})

This code tells the server: "If someone hits the root (/) path using a GET request, return the string 'Hello World'."

2. Refactoring for Cleaner Code

While using anonymous (inline) functions is quick, it can make your main function look cluttered as your app grows. A better practice is to separate your logic into dedicated handler functions.

Before (Inline):

r.Get("/", func(w http.ResponseWriter, r *http.Request) { ... })

After (Clean):

func handleHelloWorld(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello World"))
}

// Inside your main function:
r.Get("/", handleHelloWorld)

This approach makes your code much more readable and easier to maintain.

3. Adding Multiple Endpoints

A single router can store and manage multiple endpoints. You can easily add more routes to handle different parts of your application. For instance, let’s add a /test endpoint:

func handleTest(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("This is a test response"))
}

// Registering the new route
r.Get("/test", handleTest)

Now, if you navigate to localhost:8080/ you get "Hello World", and if you go to localhost:8080/test, you receive the test handling response.

Conclusion

Routing is the backbone of any web API. By using Chi, you get a clean, idiomatic way to handle complex paths without the overhead of heavy frameworks.

Key Takeaways:

A Router manages your application's endpoints.
Endpoints define how the server responds to specific paths.
Separating handlers into their own functions keeps your codebase professional and clean.

Stay tuned for the next topic where we will dive deeper into more advanced Chi features!

Helpful Resources:

Chi Documentation
Check out the full video tutorial here: Golang Chi #2 Router

Getting Started with Golang Chi: A Guide to Building a Simple API

luthfisauqi17 — Sat, 21 Mar 2026 11:04:43 +0000

Are you looking for a lightweight and efficient router to build HTTP services in Go? If so, Chi is the answer. In this guide, we will walk through the basics of using Chi to build a simple yet powerful Golang application.

What is Chi?

According to its official documentation, Chi is a lightweight, idiomatic, and composable router for building HTTP services in Go. Its key advantages include:

Lightweight: Extremely fast and minimal.
Robust: Built for production-grade reliability.
No External Dependencies: Keeps your project clean and manageable.

Before diving in, it is highly recommended to read the official Chi documentation to understand its core features.

Setting Up Your Project

1. Initialize the Project

The first step is to create your workspace and initialize a Go module. Open your terminal and run:

go mod init example.com/golang-simple

2. Install the Chi Library

Next, add the Chi dependency to your project. Ensure you are using the latest version (v5) to access the best features:

go get -u github.com/go-chi/chi/v5

Writing the Core Code

Open your code editor (such as Visual Studio Code) and create a file named main.go. Here is the basic structure to get your server up and running:

package main

import (
    "net/http"
    "github.com/go-chi/chi/v5"
    "github.com/go-chi/chi/v5/middleware"
)

func main() {
    // 1. Initialize the Chi router
    r := chi.NewRouter()

    // 2. Add Middleware (optional but recommended)
    r.Use(middleware.Logger)

    // 3. Create a Dummy API (GET Endpoint)
    r.Get("/", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("Hello World"))
    })

    // 4. Run the Server on Port 3000
    http.ListenAndServe(":3000", r)
}

Code Breakdown:

chi.NewRouter(): Creates a new instance of the Chi router.
middleware.Logger: A built-in Chi middleware that logs every incoming request to your terminal.
r.Get: Defines an HTTP GET route on the root path (/).
http.ListenAndServe: Opens port 3000 to listen for incoming requests.

Running the Application

To see your API in action, run the following command in your terminal:

go run main.go

Once the server is running, open your browser and go to localhost:3000. You should see the message "Hello World" on the screen. Additionally, check your terminal to see the logs generated by the logger middleware.

Conclusion

Building an API with Golang Chi is quick and straightforward. Its simple structure allows developers to create clean web services without the overhead of heavy libraries. This is just the beginning—you can explore more complex routing and custom middleware as you grow!

Want to see the visual tutorial? Watch the full video on the luthfisauqi17 YouTube channel.

Managing Configurations in Golang with Viper

luthfisauqi17 — Sun, 16 Mar 2025 15:19:22 +0000

Managing configurations in a Golang application can be tricky, especially when dealing with different environments, file formats, and environment variables.

This is where Viper comes in!

Viper is a powerful Go library that simplifies configuration management by supporting:

✅ Multiple file formats (YAML, JSON, TOML, etc.)
✅ Environment variables for dynamic settings
✅ Command-line flags
✅ Default values for missing configs

In this guide, we’ll explore how to use Viper to handle configurations efficiently in your Go applications.

Installing Viper in Golang

Before using Viper, install it in your Go project by running:

go get github.com/spf13/viper

Then, create a main.go file and import the package:

package main

import (
    "fmt"
    "github.com/spf13/viper"
)

Now, let’s see how to load configurations from a file!

Loading Configuration from a File

Viper can read configuration from multiple file formats like YAML, JSON, and TOML.

Let’s create a config.yaml file:

app_name: "Sample Go Application"
port: 8080
debug: true

Now, in main.go, load this configuration:

func main() {
    viper.SetConfigName("config") // Name of the config file (without extension)
    viper.SetConfigType("yaml")   // File format
    viper.AddConfigPath(".")      // Look for config in the current directory

    // Read the config file
    if err := viper.ReadInConfig(); err != nil {
        fmt.Printf("Error reading config file: %v\n", err)
        return
    }

    // Access config values
    fmt.Println("App Name:", viper.GetString("app_name"))
    fmt.Println("Port:", viper.GetInt("port"))
    fmt.Println("Debug Mode:", viper.GetBool("debug"))
}

Run the Program

go run main.go

You should see the following output:

App Name: Sample Go Application
Port: 8080
Debug Mode: true

Setting Default Values

What if a configuration value is missing? Viper allows setting default values to avoid errors.

viper.SetDefault("port", 8080)

If a config file or environment variable is missing, Viper will fall back to the default value.

Using JSON Instead of YAML

Viper supports various file formats. If you prefer JSON, just update the config type:

viper.SetConfigType("json")

And create a config.json file:

{
  "app_name": "Sample Go Application",
  "port": 8080,
  "debug": true
}

Viper will handle it seamlessly!

There you go, that is how you can use Viper to manage configuration in Golang. Thank you for reading, and have a nice day!

Using Logger Middleware in Go Fiber

luthfisauqi17 — Tue, 11 Mar 2025 04:45:14 +0000

Middleware in Go Fiber allows you to process requests before they reach your route handlers. In this tutorial, we'll focus on using the Logger middleware to log request details such as method, path, status, and response time.

Step 1: Install Logger Middleware

To use the Logger middleware, install the necessary package:

go get github.com/gofiber/fiber/v2/middleware/logger

This command installs the Logger middleware, which logs HTTP requests.

Step 2: Using Logger Middleware

The Logger middleware provides structured logging for incoming requests, helping with debugging and monitoring.
Create a new file main.go and add the following code:

package main

import (
    "log"
    "github.com/gofiber/fiber/v2"
    "github.com/gofiber/fiber/v2/middleware/logger"
)

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

    // Apply Logger middleware
    app.Use(logger.New())

    app.Get("/", func(c *fiber.Ctx) error {
        return c.SendString("Hello, Fiber with Logger!")
    })

    log.Fatal(app.Listen(":3000"))
}

Step 3: Run the Application

Start the server by running:

go run main.go

Now, when you access http://localhost:3000/, the terminal will log the request details:

10:17:25 | 200 |       12.49µs | 127.0.0.1 | GET | / | -

This helps track incoming requests and debug issues easily.

Step 4: Customizing Logger Middleware

You can customize the Logger middleware to change the log format and output. Here’s an example with custom configurations:

app.Use(logger.New(logger.Config{
    Format: "${time} | ${status} | ${method} | ${path} | ${latency}\n",
}))

This will log requests in the format:

10:18:10 | 200 | GET | / |       4.069µs

The ${latency} field captures the request processing time, helping you identify performance bottlenecks.

There you go, that is how you can use logger middleware in Go Fiber. Thank you for reading, and have a nice day!

Setting Up a Simple Go Fiber Project

luthfisauqi17 — Mon, 10 Mar 2025 04:25:29 +0000

In this tutorial, we will go step by step to set up a basic web server using Go Fiber. By the end of this guide, you will have a running Go Fiber application that responds with "Hello, World!" when accessed.

Step 1: Install Go

Before we start, ensure that Go is installed on your system. You can verify this by running:

go version

If you don’t have Go installed, download and install it from golang.org.

Step 2: Create a New Go Project

Navigate to your desired directory and create a new project folder:

mkdir go-fiber-app && cd go-fiber-app

Initialize a Go module:

go mod init go-fiber-app

This will create a go.mod file, which manages dependencies for your project.

Step 3: Install Fiber

Run the following command to install Fiber:

go get github.com/gofiber/fiber/v2

This fetches the Fiber package and adds it to your go.mod file.

Step 4: Create a Simple Fiber Server

Create a new file named main.go and add the following code:

package main

import (
    "log"
    "github.com/gofiber/fiber/v2"
)

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

    // Define a simple route
    app.Get("/", func(c *fiber.Ctx) error {
        return c.SendString("Hello, World!")
    })

    // Start the server
    log.Fatal(app.Listen(":3000"))
}

Step 5: Run the Fiber App

Now, let's run our Go Fiber application:

go run main.go

Open your browser and visit http://localhost:3000. You should see:

Hello, World!

There you go, that is how you setting up a simple golang Fiber project. Thank you for reading, and have a nice day!

How To Build a Machine Learning Model For Heart Failure Prediction From Scratch

luthfisauqi17 — Thu, 20 Feb 2025 13:58:57 +0000

Hi everyone! Today I will show you how to build a Machine Learning model for heart failure prediction from scratch. For this tutorial, we will use a dataset from kaggle.com called Heart Failure Prediction Dataset.

You can learn more about this dataset from the following link:
https://www.kaggle.com/datasets/fedesoriano/heart-failure-prediction

You can download the dataset to follow along with this tutorial.

Alright, open your Jupyter Notebook and let's get started!

Step 1: Data Loading

First of all, let's load the data using pandas from the file heart.csv, and check the data using df.head() function

import pandas as pd

df = pd.read_csv('heart.csv')
df.head()

If you successfully load the data, the first five rows of data will be shown in your notebook.

Step 2: Data Inspection

Next, let's dig deeper into the data information using the function df.info().

df.info()

Run this code, and you will get more important insight about the dataset. The following is the result of this code

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 918 entries, 0 to 917
Data columns (total 12 columns):
 #   Column          Non-Null Count  Dtype  
---  ------          --------------  -----  
 0   Age             918 non-null    int64  
 1   Sex             918 non-null    object 
 2   ChestPainType   918 non-null    object 
 3   RestingBP       918 non-null    int64  
 4   Cholesterol     918 non-null    int64  
 5   FastingBS       918 non-null    int64  
 6   RestingECG      918 non-null    object 
 7   MaxHR           918 non-null    int64  
 8   ExerciseAngina  918 non-null    object 
 9   Oldpeak         918 non-null    float64
 10  ST_Slope        918 non-null    object 
 11  HeartDisease    918 non-null    int64  
dtypes: float64(1), int64(6), object(5)
memory usage: 86.2+ KB

From this, the information we can see that the columns such as Sex, ChestPainType, RestingECG, ExerciseAngina, and ST_Slope has the datatype of object and we have to handle that such as all columns will have a numerical datatype.

Step 3: Data Cleaning

At this step, we will handle the column with the object datatype. Keep in mind that the term object here is usually a Python string. To validate that, let's take the ChestPainType column and see all its unique value

df['ChestPainType'].value_counts()

And you will get this result

count
ChestPainType   
ASY 496
NAP 203
ATA 173
TA  46

dtype: int64

Based on that result, yes indeed all the values are in the form of string.

"Binary" column processor

Let's start processing from the column that has the binary amount of unique value, in this case, the column Sex and ExerciseAngina.

To process this, we can use pandas map function

# Binary: Sex, ExerciseAngina
df['Sex'] = df['Sex'].map({'F': 0, 'M': 1})
df['ExerciseAngina'] = df['ExerciseAngina'].map({'N': 0, 'Y': 1})

One-hot encoding

For the column ChestPainType, RestingECG, and ST_Slope, a technique will be required called One-hot encoding. This technique is used to transform categorical variables into a binary format to enhance the performance of machine learning model training.

To process this, we can use pandas function called get_dummies() to generate new additional columns, join the columns into the existing dataframe and drop the original column

# One-hot encoding: ChestPainType, RestingECG, ST_Slope
df = df.join(pd.get_dummies(df['ChestPainType'], prefix='ChestPainType', dtype=int)).drop(['ChestPainType'], axis=1)
df = df.join(pd.get_dummies(df['RestingECG'], prefix='RestingECG', dtype=int)).drop(['RestingECG'], axis=1)
df = df.join(pd.get_dummies(df['ST_Slope'], prefix='ST_Slope', dtype=int)).drop(['ST_Slope'], axis=1)

After that, let's see our "cleaned" dataset

df.info()

And see that all columns will have numerical datatype, and you also see that some new additional columns are added.

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 918 entries, 0 to 917
Data columns (total 19 columns):
 #   Column             Non-Null Count  Dtype  
---  ------             --------------  -----  
 0   Age                918 non-null    int64  
 1   Sex                918 non-null    int64  
 2   RestingBP          918 non-null    int64  
 3   Cholesterol        918 non-null    int64  
 4   FastingBS          918 non-null    int64  
 5   MaxHR              918 non-null    int64  
 6   ExerciseAngina     918 non-null    int64  
 7   Oldpeak            918 non-null    float64
 8   HeartDisease       918 non-null    int64  
 9   ChestPainType_ASY  918 non-null    int64  
 10  ChestPainType_ATA  918 non-null    int64  
 11  ChestPainType_NAP  918 non-null    int64  
 12  ChestPainType_TA   918 non-null    int64  
 13  RestingECG_LVH     918 non-null    int64  
 14  RestingECG_Normal  918 non-null    int64  
 15  RestingECG_ST      918 non-null    int64  
 16  ST_Slope_Down      918 non-null    int64  
 17  ST_Slope_Flat      918 non-null    int64  
 18  ST_Slope_Up        918 non-null    int64  
dtypes: float64(1), int64(18)
memory usage: 136.4 KB

By the way, you can inspect the dataset visually using the following code

df.hist(figsize=(20, 15))

Step 4: Train Machine Learning Model

Finally, let's create the machine learning model!

Define Feature & Target Data

First of all, we have to separate the "feature data" and the "target data"

X, y = df.drop(['HeartDisease'], axis=1), df['HeartDisease']

Train Test Split

Then, each feature & target data needs to be split into a "train" dataset and a "test" dataset. The training dataset will be used to train the model, and the test dataset will be used to evaluate the performance of the trained model.

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

Train Model

Next step, we will train the machine learning model using the train data that we have. Since the objective of this model is to classify whether the patient has heart failure or not, this can be called a classification problem. For a classification problem, there are some machine learning model algorithms and two of them are "Logistic Linear" and "Random Forrest Classifier". We will implement those two model algorithms and see the performance of each algorithm!

Logistic Regression

Let's start from logistic regression. To train this model you can use LogisticRegression from the sklearn.linear_model

from sklearn.linear_model import LogisticRegression

log_model = LogisticRegression()
log_model.fit(X_train, y_train)

Random Forrest Classifier

Next, let's see how random forest classifier implementation. We will use RandomForestClassifier from sklearn.ensemble

from sklearn.ensemble import RandomForestClassifier

rfc_model = RandomForestClassifier()
rfc_model.fit(X_train, y_train)

Models Comparison

Finally, let's see how those models perform

print(f"Logistic Regression Score: {log_model.score(X_test, y_test)}")
print(f"Random Forest Classifier Score: {rfc_model.score(X_test, y_test)}")

After I run the code above, I get the following output:

Logistic Regression Score: 0.8369565217391305
Random Forest Classifier Score: 0.8532608695652174

From the result, it can be seen that the Random Forrest Classifier scored better, around 85%.

Full code: https://github.com/luthfisauqi17/machine-learning-predictions/blob/main/heart_failure_prediction.ipynb

There you go, that is how you can make a machine-learning model to predict heart failure. You can tweak the code around, and let me know if you found a better solution to make a model with a better score!

Thanks for reading this article, and have a nice day!

🚀 Build a Simple To-Do List App with React Native & Expo – TaskMate 📝

luthfisauqi17 — Mon, 17 Feb 2025 22:20:44 +0000

Hey Devs! 👋

I recently built TaskMate, a simple To-Do List App using React Native and Expo. If you’re interested in building mobile apps, feel free to check it out! 🚀

✨ Features

✅ Add new tasks
✅ Delete tasks
✅ Toggle task completion (mark as done/undone)
✅ Persistent storage (tasks remain after closing the app)

📦 Tech Stack

React Native (UI Framework)
Expo (Development & Testing)
AsyncStorage (Persistent Data Storage)

🛠️ Getting Started

1️⃣ Clone the Repo

git clone https://github.com/luthfisauqi17/TaskMate.git
cd TaskMate

2️⃣ Install Dependencies

npm install

3️⃣ Run the App

expo start

🎯 Want to Contribute?

This is just a fun side project, but if you're interested, feel free to contribute! Some ideas for improvements:

🚀 Filters (All, Completed, Incomplete)
🚀 Task Categories (Work, Personal, etc.)
🚀 Priority Levels (Low, Medium, High)
🚀 Better UI with React Native Paper

If you find this project helpful, please consider giving it a ⭐️ on GitHub! It really helps and motivates me to build more awesome projects. 😊
🔗 GitHub Repository: https://github.com/luthfisauqi17/TaskMate

🚀 Follow Me for More Projects!

I’m working on more cool projects like TaskMate! If you’re interested in tech projects, mobile development, or AI, feel free to follow me:
👉 GitHub: https://github.com/luthfisauqi17

💬 Let’s Connect!

Let me know your thoughts! Any feedback or suggestions are welcome. 🚀✨

Building a URL Shortener in Go

luthfisauqi17 — Sun, 16 Feb 2025 12:43:21 +0000

⚠️ Important Note: There have been several revisions to this article, which I have listed at the end. Please make sure to read them before following this tutorial. Thanks!

Have you ever wondered how Bit.ly or TinyURL work? Today, we're building our URL shortener in Golang!

By the end of this tutorial, you'll have a fully working URL shortener that generates short links and redirects users. Let’s get started!

Before we dive into coding, let's understand how a URL shortener works:

The user enters a long URL
We generate a short code
Save it in a memory or database
When someone visits the short link, we redirect them

Step 1: Project Setup

First, create a new project and initialize Go modules.

mkdir go-url-shortener && cd go-url-shortener
go mod init github.com/yourusername/go-url-shortener
go get github.com/gin-gonic/gin

Now, open main.go and set up a simple Gin server.

package main

import (
    "crypto/rand"
    "encoding/base64"
    "github.com/gin-gonic/gin"
    "net/http"
)

// Map to store short URLs -> original URLs
var urlStore = make(map[string]string)

func main() {
    r := gin.Default()
    r.POST("/shorten", shortenURL)
    r.GET("/:short", redirectURL)

    r.Run(":8080") // Run on port 8080
}

This creates a basic Gin server. Now let’s add URL shortening!

Step 2: Generate Short URLs

Now, we need a function to generate a short random URL.

func generateShortURL() string {
    b := make([]byte, 6)
    rand.Read(b)
    return base64.URLEncoding.EncodeToString(b)[:6]
}

Step 3: Shorten URL API

Next, let’s create the /shorten endpoint that takes a long URL and returns a short one.

func shortenURL(c *gin.Context) {
    var req struct {
        OriginalURL string `json:"original_url"`
    }
    if err := c.BindJSON(&req); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid request"})
        return
    }

    shortCode := generateShortURL()

    urlStore[shortCode] = req.OriginalURL

    c.JSON(http.StatusOK, gin.H{
        "short_url": "http://localhost:8080/" + shortCode,
    })
}

This stores the original URL in a map and returns a short URL.
Now, let’s handle redirection!

Step 4: Redirect Short URLs

We need an endpoint that looks up the short URL and redirects users.

func redirectURL(c *gin.Context) {
    shortCode := c.Param("short")

    originalURL, exists := urlStore[shortCode]

    if !exists {
        c.JSON(http.StatusNotFound, gin.H{"error": "URL not found"})
        return
    }

    c.Redirect(http.StatusFound, originalURL)
}

Step 5: Testing the API

Let’s test this API using cURL!
Run the application by typing.

go run .

Shorten a URL

Request:

curl -X POST http://localhost:8080/shorten -H "Content-Type: application/json" -d '{"original_url": "https://google.com"}'

Response:

{
    "short_url": "http://localhost:8080/abc123"
}

Redirect (Visit the short URL)

curl -v http://localhost:8080/abc123

Full code: https://github.com/luthfisauqi17/go-url-shortner

There you go, that is how you build a URL Shortener using Golang. Thank you for reading, and have a nice day!

⚠️ Revision

I just realized that sync.Mutex is needed to safeguard golang's map during concurrent writes. The final code including this revision is already added to the GitHub code.
Standard Base64 encoding can produce characters like +, /, and =, which aren't always URL-safe. I’ve updated the code to use base64.RawURLEncoding, which replaces those characters and removes padding. The final code including this revision is already added to the GitHub code.

Exploring Popular Go Frameworks and Libraries

luthfisauqi17 — Thu, 04 Jan 2024 16:41:36 +0000

As the popularity of the Go programming language continues to rise, developers are constantly on the lookout for efficient tools and resources that can enhance their productivity. In this blog post, we will dive into some of the most popular frameworks and libraries in the Go ecosystem, highlighting their key features and benefits. Whether you are a seasoned Go developer or just getting started, these tools can greatly simplify your workflow and help you build robust applications.

Gorilla Web Toolkit

One of the most widely used frameworks in the Go community is the Gorilla Web Toolkit. It provides a collection of packages that help developers build web applications quickly and easily. Gorilla offers a range of functionalities, including routing, sessions, authentication, and handling of WebSockets. With its clean and intuitive API, Gorilla allows developers to focus on writing business logic rather than dealing with the complexities of web development. Whether you are building a simple REST API or a complex web application, Gorilla can significantly speed up your development process. You can check https://gorilla.github.io/ for more information about this framework.

Gin

If you are looking for a lightweight yet powerful web framework, Gin is an excellent choice. It boasts a minimalistic design and a blazing-fast performance, making it a popular option for building high-performance APIs and web applications. With Gin, you can easily define routes, handle middleware, and validate input parameters. It also provides support for rendering HTML templates and handling JSON requests and responses. Despite its simplicity, Gin offers a robust set of features that can handle the demands of modern web development. If you are interested, check out https://gin-gonic.com/ for more information.

GORM

When it comes to interacting with databases in Go, GORM is a highly regarded library. GORM is an Object-Relational Mapping (ORM) tool that allows developers to work with databases using Go structs. It supports various database systems, including MySQL, PostgreSQL, SQLite, and more. GORM simplifies the process of database operations by providing a rich set of functions for querying, inserting, updating, and deleting records. It also supports advanced features like eager loading, transactions, and migrations. With GORM, you can build database-driven applications with ease and maintainability. Check out https://gorm.io/index.html if you want to read more about GORM.

There you go, there are three of the most popular Go frameworks and libraries. Thank you for reading, and have a nice day!

Don't forget to follow my X account at https://twitter.com/luthfisauqi17 for exclusive content, insightful updates, and a community dedicated to this type of content. Don't miss out on the exciting discussions and valuable insights waiting for you!

Source:

Cover image:

https://fastly.picsum.photos/id/248/1920/1080.jpg?hmac=iQjHqQHNy8FFroDiOBwzxY7es9VCdxpXaSPYHaR2PH8