Forem: Aditya

Mastering Error Handling in Go

Aditya — Thu, 09 Apr 2026 13:54:17 +0000

Error handling is one of the most distinctive aspects of Go. Unlike languages that use exceptions, Go treats errors as values — plain return values that you explicitly check and handle. This design philosophy leads to more robust and predictable code once you understand how to work with it.

As Darth Vader would say: "I find your lack of error handling disturbing." In Go, there is no escaping this responsibility — errors are first-class citizens, and the language makes sure you know it.

In this guide, we will cover everything you need to master error handling in Go.

The Basics: Errors as Values

Like Neo in The Matrix discovering there is no spoon, Go programmers must accept a fundamental truth: there are no exceptions — there are only errors. Once you embrace this, everything clicks.

In Go, the built-in error interface is defined as:

type error interface {
    Error() string
}

Functions that can fail conventionally return an error as the last return value:

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

func main() {
    result, err := divide(10, 0)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("Result:", result)
}

The nil check is the idiomatic Go way of checking whether an operation succeeded.

Creating Custom Errors

While errors.New and fmt.Errorf are convenient, you often need richer error types to convey more context.

Struct-based Custom Errors

type ValidationError struct {
    Field   string
    Message string
}

func (e *ValidationError) Error() string {
    return fmt.Sprintf("validation error on field %q: %s", e.Field, e.Message)
}

func validateAge(age int) error {
    if age < 0 {
        return &ValidationError{Field: "age", Message: "must be non-negative"}
    }
    if age > 150 {
        return &ValidationError{Field: "age", Message: "unrealistically large value"}
    }
    return nil
}

Custom error types let callers inspect the error and make decisions based on its fields.

Sentinel Errors

Think of sentinel errors as Obi-Wan Kenobi calmly waving his hand: "These aren't the errors you're looking for." They are named, predeclared values that let callers identify exactly what went wrong — no guesswork, no string parsing, just a clean identity check.

Sentinel errors are predeclared error values used to signal specific conditions. The standard library uses them extensively:

var (
    ErrNotFound   = errors.New("not found")
    ErrPermission = errors.New("permission denied")
    ErrTimeout    = errors.New("operation timed out")
)

func findUser(id int) (*User, error) {
    user, ok := db[id]
    if !ok {
        return nil, ErrNotFound
    }
    return user, nil
}

// Callers can compare directly:
if errors.Is(err, ErrNotFound) {
    // handle not found case
}

Sentinel errors are best for stable, well-known error conditions that callers need to branch on.

Error Wrapping with `fmt.Errorf` and `%w`

Go 1.13 introduced error wrapping, which lets you add context to an error while preserving the original:

func readConfig(path string) (*Config, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        return nil, fmt.Errorf("readConfig: %w", err)
    }
    // ...
    return config, nil
}

The %w verb wraps the error, making it inspectable by errors.Is and errors.As.

Unwrapping Errors: `errors.Is` and `errors.As`

`errors.Is` — Checking for a Specific Error

errors.Is traverses the entire error chain looking for a matching value:

err := readConfig("missing.yaml")
if errors.Is(err, os.ErrNotExist) {
    fmt.Println("Config file does not exist")
}

This works even when the error has been wrapped multiple layers deep.

`errors.As` — Extracting a Specific Error Type

errors.As traverses the chain looking for an error that can be assigned to the target type:

func processInput(input string) error {
    return fmt.Errorf("processInput: %w", &ValidationError{
        Field:   "input",
        Message: "cannot be empty",
    })
}

func main() {
    err := processInput("")
    var ve *ValidationError
    if errors.As(err, &ve) {
        fmt.Printf("Validation failed on field: %s\n", ve.Field)
    }
}

Implementing the `Unwrap` Method

For custom error types that wrap another error, implement the Unwrap method so that errors.Is and errors.As can traverse the chain:

type QueryError struct {
    Query string
    Err   error
}

func (e *QueryError) Error() string {
    return fmt.Sprintf("query %q failed: %v", e.Query, e.Err)
}

func (e *QueryError) Unwrap() error {
    return e.Err
}

Panic and Recover

If you have ever read The Hitchhiker's Guide to the Galaxy, you know the most important advice printed on its cover in large, friendly letters: DON'T PANIC. Go shares this philosophy entirely.

While errors are the preferred mechanism for expected failure cases, Go provides panic and recover for truly exceptional situations.

func safeDiv(a, b int) (result int, err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("recovered from panic: %v", r)
        }
    }()
    result = a / b
    return
}

Use panic sparingly — typically only for programmer errors (e.g., invalid arguments to a function) or truly unrecoverable situations. Always recover at package boundaries.

Best Practices

1. Always Handle Errors

Remember the Black Knight from Monty Python and the Holy Grail? He kept insisting "It's just a flesh wound!" while losing every limb. Silently discarding errors with _ is the software equivalent — small ignored wounds that quietly become fatal bugs.

Never silently ignore errors. If you genuinely don't need to handle an error, document why with a comment.

// Bad
f, _ := os.Open("file.txt")

// Good
f, err := os.Open("file.txt")
if err != nil {
    return fmt.Errorf("open file: %w", err)
}

2. Add Context When Wrapping

When wrapping errors, add context that describes what was being done — not just what failed.

// Less helpful
return fmt.Errorf("%w", err)

// More helpful
return fmt.Errorf("fetchUserProfile(id=%d): %w", id, err)

3. Prefer `errors.Is` / `errors.As` Over Direct Comparison

Direct == comparison breaks when errors are wrapped. Use the standard library helpers instead.

// Fragile — fails if err is wrapped
if err == ErrNotFound { ... }

// Robust
if errors.Is(err, ErrNotFound) { ... }

4. Return Errors, Don't Log and Return

In Ghostbusters, when something goes wrong, you call the Ghostbusters — you don't also fire the alarm, call the mayor, and call the Ghostbusters. Pick one. The same rule applies here: either log the error or return it, not both.

Avoid logging an error and then returning it — this leads to duplicate log entries. Either log it at the top level or return it for the caller to handle.

// Bad: logs AND returns
log.Printf("error: %v", err)
return err

// Good: just return and let the caller decide
return fmt.Errorf("doSomething: %w", err)

5. Keep Error Messages Lowercase

By convention, Go error strings should be lowercase and not end with punctuation, since they are often composed into larger messages.

// Bad
errors.New("File not found.")

// Good
errors.New("file not found")

Putting It All Together

Here is a practical example combining everything we covered:

package main

import (
    "errors"
    "fmt"
    "strconv"
)

var ErrNegativeNumber = errors.New("negative number")

type ParseError struct {
    Input string
    Err   error
}

func (e *ParseError) Error() string {
    return fmt.Sprintf("parse error for input %q: %v", e.Input, e.Err)
}

func (e *ParseError) Unwrap() error {
    return e.Err
}

func parsePositive(s string) (int, error) {
    n, err := strconv.Atoi(s)
    if err != nil {
        return 0, &ParseError{Input: s, Err: err}
    }
    if n < 0 {
        return 0, &ParseError{Input: s, Err: ErrNegativeNumber}
    }
    return n, nil
}

func main() {
    inputs := []string{"42", "-5", "abc"}

    for _, input := range inputs {
        val, err := parsePositive(input)
        if err != nil {
            var pe *ParseError
            if errors.As(err, &pe) {
                fmt.Printf("Bad input: %s\n", pe.Input)
            }
            if errors.Is(err, ErrNegativeNumber) {
                fmt.Println("Hint: provide a positive number")
            }
            continue
        }
        fmt.Printf("Parsed: %d\n", val)
    }
}

Conclusion

Go error handling requires a bit of a mindset shift if you are coming from exception-based languages, but the explicitness it enforces pays dividends in code clarity and reliability. By treating errors as values, wrapping them with context, and using errors.Is / errors.As for inspection, you can write Go programs that fail gracefully and are easy to debug.

As Samwise Gamgee wisely put it: "It's a dangerous business, going out your door... but I suppose the answer is to keep going." The same goes for error handling — keep wrapping, keep checking, and your code will be as resilient as the Fellowship of the Ring.

Happy coding!

Building Microservices with Go: A Step-by-Step Guide

Aditya — Tue, 20 May 2025 15:49:42 +0000

Microservices have become the de facto standard for building scalable, maintainable, and robust backend systems. Go (Golang), with its simplicity, performance, and strong concurrency support, is an excellent choice for developing microservices. In this guide, we'll walk through building a microservice using a ready-to-use Go microservice template.

Why Go for Microservices?

Performance: Go compiles to native code and offers great runtime efficiency.
Simplicity: The language is easy to learn and encourages clean, readable code.
Concurrency: Goroutines and channels make concurrent programming straightforward.
Strong Standard Library: Go's standard library covers most needs for microservice development.

Project Structure Overview

A well-structured project is crucial for maintainability. Here’s a typical layout:

go-microservice-template/
├── cmd/
│   └── main.go                # Entry point
├── internal/
│   ├── api/
│   │   └── rest/
│   │       ├── rest.go        # REST server setup
│   │       ├── handler/
│   │       │   └── handler.go # HTTP handlers
│   │       └── router/
│   │           └── router.go  # Route definitions
│   ├── app/
│   │   └── app.go             # App lifecycle
│   ├── repository/
│   │   └── repository.go      # Data access
│   └── service/
│       └── service.go         # Business logic
├── pkg/
│   ├── models.go              # Shared models
│   └── response.go            # Response helpers
├── scripts/                   # Utility scripts
├── Makefile                   # Makefile for build automation
├── go.mod
├── go.sum
├── LICENSE
└── README.md

Why This Structure Supports Scalable Microservices

A well-organized project structure is essential for building scalable and maintainable microservices. This template follows Go community best practices and separates concerns clearly, making it easy to extend, test, and manage as your service grows.

Folder-by-Folder Breakdown

cmd/: Contains the entry point(s) for your application. Each executable should have its own subfolder, making it easy to add CLI tools or multiple services in the future.
internal/: Holds all application-specific code. The internal directory restricts import access, ensuring that code here cannot be imported from outside the project, which enforces encapsulation and prevents accidental dependencies.
- api/rest/: Contains REST server setup, handlers, and routers. This keeps your API layer modular and easy to update as endpoints grow.
- app/: Manages application lifecycle and startup logic, centralizing configuration and initialization.
- repository/: Handles data access, making it easy to swap databases or external services without affecting business logic.
- service/: Contains business logic, keeping your core functionality decoupled from transport and storage layers.
pkg/: For code that can be shared across projects or is intended for public use. This is ideal for reusable models, helpers, and utilities.
scripts/: Stores automation and setup scripts, helping with DevOps, CI/CD, and local development tasks.

This separation of concerns allows teams to work independently on different parts of the service, supports testing and code reuse, and makes it straightforward to scale the codebase as requirements evolve. By following this structure, you ensure your microservice remains robust, modular, and ready for future growth.

Libraries Used

This template leverages several key Go libraries from the oss.nandlabs.io/golly suite to streamline development and testing:

oss.nandlabs.io/golly/rest: Provides REST server utilities and interfaces for building HTTP APIs.
oss.nandlabs.io/golly/lifecycle: Manages application lifecycle, including startup and graceful shutdown of components.
oss.nandlabs.io/golly/assertion: Used for expressive assertions in unit tests, making test code more readable and robust.

You can add more libraries as needed for your business logic, database access, or API integrations. All dependencies are managed via Go modules (go.mod).

Step 1: Clone the Template

Start by cloning the template repository:

git clone https://github.com/neo7337/go-microservice-template.git
cd go-microservice-template

Step 2: Update the Module Name

Edit go.mod to use your own module path:

module github.com/yourusername/your-microservice

Then tidy up dependencies:

go mod tidy

Step 3: Define Your Data Models

Add or modify structs in pkg/models.go to represent your domain entities. For example:

type User struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Age   int    `json:"age"`
    Email string `json:"email"`
}

Step 4: Implement Business Logic

Write your core business logic in the internal/service/ package. This keeps your code modular and testable.

Step 5: Set Up Data Access

Implement repository functions in internal/repository/ to interact with databases or external APIs.

Step 6: Create API Handlers and Routes

Add handler functions in internal/api/rest/handler/ for each endpoint.
Register routes in internal/api/rest/router/router.go and link them to handlers.

Example: Adding a Concurrency Endpoint

To demonstrate Go's concurrency, the template includes a /api/concurrency-demo endpoint. This endpoint launches two goroutines in parallel—one fetching users, another simulating an external call—and aggregates their results:

func ConcurrencyDemoHandler(ctx rest.ServerContext) {
    type result struct {
        Source string      `json:"source"`
        Data   interface{} `json:"data"`
    }
    results := make(chan result, 2)

    go func() {
        users, _ := service.GetUsers()
        results <- result{Source: "users", Data: users}
    }()

    go func() {
        info := map[string]string{"message": "Hello from goroutine!"}
        results <- result{Source: "info", Data: info}
    }()

    resp := make(map[string]interface{})
    for i := 0; i < 2; i++ {
        r := <-results
        resp[r.Source] = r.Data
    }

    pkg.ResponseJSON(ctx, 200, resp)
}

Sample response:

{
  "users": [
    {"id":1,"name":"John Doe","age":30,"email":"john.doe@mail.com"},
    {"id":2,"name":"Jane Smith","age":25,"email":"jane.smith@mail.com"}
  ],
  "info": {"message": "Hello from goroutine!"}
}

Step 7: Customize Application Startup

Modify internal/app/app.go to register additional components or change startup behavior as needed.

Step 8: Run Your Microservice

Start your service locally:

go run cmd/main.go

By default, your API will be available at http://localhost:8282/api.

Step 9: Extend and Organize

Add more packages under internal/ as your service grows.
Use the pkg/ directory for shared utilities and types.
Add scripts to the scripts/ directory for automation or setup tasks.

Step 10: Testing

The template includes example test cases for both the repository and response utility layers:

internal/repository/repository_test.go tests the GetUsers function, ensuring correct user data is returned.
pkg/response_test.go tests the ResponseJSON utility, verifying status code, headers, and JSON output.

Add your own tests alongside your code or in a dedicated test/ directory. To run all tests:

go test ./...

Repository

You can find the template repository here: neo7337/go-microservice-template

Conclusion

With this template and step-by-step approach, you can quickly scaffold, develop, and scale robust Go microservices. The clear separation of concerns and modular structure make it easy to maintain and extend your services as your needs evolve.

Ready to build your next microservice? Fork the template and start coding!

Building Microservices with gRPC: A Practical Guide

Aditya — Tue, 06 May 2025 14:45:21 +0000

In today's cloud-native world, microservices architecture has become a standard approach for building scalable, maintainable, and resilient applications. While REST APIs have traditionally been the go-to choice for communication between microservices, gRPC offers compelling advantages that make it an excellent alternative.

This blog post will walk you through setting up a practical microservice architecture using gRPC, with a Go service as the backend and an Express.js service as the frontend. We'll cover everything from defining protocol buffers to containerizing the services with Docker.

What is gRPC?

gRPC (gRPC Remote Procedure Calls) is a high-performance, open-source framework developed by Google. It allows services to communicate efficiently using HTTP/2 as the transport protocol and Protocol Buffers (protobuf) for serializing structured data.

Key advantages of gRPC include:

Strong Typing: Contract-first approach with Protocol Buffers
Bi-directional Streaming: Supports streaming in both directions
Language Agnostic: Works with multiple programming languages
High Performance: Uses HTTP/2 for efficient communication
Code Generation: Automatically generates client and server code

Project Structure

Our demo project has the following structure:

/grpc-demo
├── docker-compose.yml
├── express-service/         # Node.js frontend service
│   ├── Dockerfile
│   ├── package.json
│   └── src/
│       ├── app.js
│       ├── controllers/
│       ├── generated/       # Generated gRPC code
│       └── routes/
├── go-service/              # Go backend service
│   ├── Dockerfile
│   ├── go.mod
│   ├── go.sum
│   ├── main.go
│   ├── api/
│   ├── grpcgoexpress/       # Generated gRPC code
│   └── models/
└── proto/                   # Protocol Buffer definitions
    └── service.proto

Step 1: Define Your Protocol Buffers

The first step in building a gRPC-based microservice is defining your service contract using Protocol Buffers. Create a .proto file:

syntax = "proto3";

package grpcgoexpress;

option go_package = "github.com/go-service/grpcgoexpress;grpcgoexpress";

// The greeting service definition.
service GreetingService {
  // Sends a greeting
  rpc GetData (RequestMessage) returns (ResponseMessage);
}

// The request message containing the user's query.
message RequestMessage {
  string query = 1;
}

// The response message containing the data.
message ResponseMessage {
  string data = 1;
}

This simple definition outlines a service with one method (GetData) that accepts a RequestMessage and returns a ResponseMessage.

Step 2: Generate Code from Protocol Buffers

For Go Service

To generate Go code from your .proto file, install the required tools:

go install google.golang.org/protobuf/cmd/protoc-gen-go@v1.28
go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@v1.2

Then generate the code:

protoc --go_out=. --go-grpc_out=. proto/service.proto

This will create two files in your specified package directory (grpcgoexpress/):

service.pb.go: Contains message type definitions
service_grpc.pb.go: Contains the service interface and client implementation

For Node.js Service

For Node.js, install the required packages:

npm install --save @grpc/grpc-js @grpc/proto-loader

Then generate the JavaScript code:

npx grpc_tools_node_protoc \
  --js_out=import_style=commonjs,binary:./express-service/src/generated \
  --grpc_out=grpc_js:./express-service/src/generated \
  --proto_path=./proto \
  ./proto/service.proto

This will generate:

service_pb.js: Message type definitions
service_grpc_pb.js: Service client and server interfaces

Step 3: Implement the gRPC Server in Go

Now, implement the gRPC server in Go:

package main

import (
    "context"
    "log"
    "net"

    pb "github.com/go-service/grpcgoexpress"
    "google.golang.org/grpc"
)

type server struct {
    pb.UnimplementedGreetingServiceServer
}

func (s *server) GetData(ctx context.Context, req *pb.RequestMessage) (*pb.ResponseMessage, error) {
    log.Printf("Received: %s", req.Query)
    return &pb.ResponseMessage{Data: "Hello from Go server!"}, nil
}

func main() {
    lis, err := net.Listen("tcp", ":50051")
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }

    s := grpc.NewServer()
    pb.RegisterGreetingServiceServer(s, &server{})
    log.Println("Server is running on port :50051")
    if err := s.Serve(lis); err != nil {
        log.Fatalf("failed to serve: %v", err)
    }
}

Step 4: Create a gRPC Client in Node.js/Express

Implement a client in your Express.js application:

const grpc = require('@grpc/grpc-js');
const express = require('express');

// Load the pre-generated gRPC code
const protoServices = require('./generated/service_grpc_pb');
const protoMessages = require('./generated/service_pb');

// Use environment variable for gRPC server address or fallback to localhost
const grpcServerAddress = process.env.GRPC_SERVER || 'localhost:50051';
console.log(`Connecting to gRPC server at: ${grpcServerAddress}`);

// Create a gRPC client
const client = new protoServices.GreetingServiceClient(
    grpcServerAddress,
    grpc.credentials.createInsecure()
);

// Create an Express application
const app = express();

app.get('/data', (req, res) => {
    const query = req.query.query || 'default query';

    // Create a request message using the generated code
    const request = new protoMessages.RequestMessage();
    request.setQuery(query);

    client.getData(request, (err, response) => {
        if (err) {
            console.error('Error:', err);
            return res.status(500).send(err);
        }
        res.send({
            data: response.getData()
        });
    });
});

app.listen(3000, () => {
    console.log('Express server running on http://localhost:3000');
});

Step 5: Containerize Your Services with Docker

Go Service Dockerfile

FROM golang:1.20-alpine AS builder

WORKDIR /app
COPY . .
RUN go mod download
RUN go build -o /app/server .

FROM alpine:latest
WORKDIR /app
COPY --from=builder /app/server /app/server
EXPOSE 50051
CMD ["/app/server"]

Express.js Service Dockerfile

FROM node:18-alpine

WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .

EXPOSE 3000
CMD ["node", "src/app.js"]

Step 6: Orchestrate with Docker Compose

Create a docker-compose.yml file to manage both services:

version: '3.8'

services:
  go-service:
    build:
      context: ./go-service
      dockerfile: Dockerfile
    ports:
      - "50051:50051"
    networks:
      - app-network
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "nc", "-z", "localhost", "50051"]
      interval: 10s
      timeout: 5s
      retries: 5

  express-service:
    build:
      context: ./express-service
      dockerfile: Dockerfile
    ports:
      - "3000:3000"
    networks:
      - app-network
    depends_on:
      - go-service
    restart: unless-stopped
    environment:
      - GRPC_SERVER=go-service:50051

networks:
  app-network:
    driver: bridge

Running the Microservices

Start the services with:

docker-compose up -d

This will build and start both services. The Express.js service will wait for the Go service to be ready before starting, thanks to the depends_on configuration.

Testing the Setup

Once your services are running, you can test the Express.js endpoint:

curl "http://localhost:3000/data?query=hello"

The response should look like:

{
  "data": "Hello from Go server!"
}

Best Practices for gRPC in Microservices

Use TLS in Production: Always secure your gRPC connections with TLS certificates in production environments
Health Checking: Implement health checking to allow clients to verify if the server is operational:

   service Health {
     rpc Check(HealthCheckRequest) returns (HealthCheckResponse);
   }

Error Handling: Use gRPC status codes consistently to communicate errors
Logging and Monitoring: Implement middleware for logging and monitoring gRPC calls
Versioning: Include versioning in your package names or service definitions
Backwards Compatibility: Make changes to your proto files in a backward-compatible way
Contract Testing: Create automated tests to verify service contracts
Timeout Handling: Set appropriate timeouts for all gRPC calls

Advanced gRPC Features

As your microservices grow, consider exploring these advanced gRPC features:

Streaming: Implement server streaming, client streaming, or bidirectional streaming for efficiency
Load Balancing: Configure proper load balancing for gRPC services
Connection Pooling: Reuse gRPC connections instead of creating new ones for each request
Interceptors: Use interceptors (middleware) for cross-cutting concerns like authentication and logging
Reflection: Enable server reflection to help with debugging and testing

Conclusion

gRPC offers a powerful way to connect microservices with strongly typed contracts, efficient communication, and excellent language interoperability. By following this guide, you've set up a basic microservice architecture with a Go backend and Node.js frontend communicating via gRPC.

This setup is just the beginning - as your application grows, gRPC provides the scalability and performance needed for demanding microservice ecosystems.

The complete code for this tutorial is available in the project repository, where you can explore the implementation in more detail.

Happy coding🚀!

Mastering SOLID Principles in Go: Writing Clean and Maintainable Code

Aditya — Fri, 02 May 2025 06:38:12 +0000

In software development, building maintainable, scalable, and robust code is the ultimate goal. The SOLID principles, coined by Robert C. Martin (Uncle Bob), provide a foundation for achieving this in object-oriented programming. But how do these principles apply to Go (Golang), a language known for its simplicity and pragmatism? Let’s explore how Go’s idiomatic style aligns with SOLID principles to produce clean, efficient software.

Single Responsibility Principle (SRP)

"A class should have only one reason to change."

In Go, SRP translates to designing functions, structs, and packages with a single responsibility. This ensures code is easier to understand, test, and maintain.

Example

Violating SRP:

func (us *UserService) RegisterUser(username, password string) error {
  // Save user to database
  // Send confirmation email
  // Log registration event
  return nil
}

This function handles multiple responsibilities: saving a user, sending an email, and logging events. Changes in any of these areas would require modifying this function.

Following SRP:

type UserService struct {
  db Database
  email EmailService
  logger Logger
}

func (us *UserService) RegisterUser(username, password string) error {
  if err := us.db.SaveUser(username, password); err != nil {
    return err
  }
  if err := us.email.SendConfirmation(username); err != nil {
    return err
  }
  us.logger.Log("User registered: " + username)
  return nil
}

Here, each responsibility is delegated to a specific component, making the code modular and testable.

Open/Closed Principle (OCP)

"Software entities should be open for extension but closed for modification."

Go achieves OCP through interfaces and composition, allowing behavior to be extended without altering existing code.

Example

Violating OCP:

func (p *PaymentProcessor) ProcessPayment(method string) {
  if method == "credit_card" {
    fmt.Println("Processing credit card payment")
  } else if method == "paypal" {
    fmt.Println("Processing PayPal payment")
  }
}

Adding a new payment method requires modifying the ProcessPayment function, which violates OCP.

Following OCP:

type PaymentMethod interface {
  Process()
}

type CreditCard struct {}
func (cc CreditCard) Process() { fmt.Println("Processing credit card payment") }

type PayPal struct {}
func (pp PayPal) Process() { fmt.Println("Processing PayPal payment") }

func (p PaymentProcessor) ProcessPayment(method PaymentMethod) {
  method.Process()
}

Now, adding a new payment method only requires implementing the PaymentMethod interface, leaving existing code untouched.

Liskov Substitution Principle (LSP)

"Subtypes must be substitutable for their base types."

In Go, LSP is achieved by designing interfaces that focus on behavior rather than structure.

Example

Violating LSP:

type Rectangle struct {
  Width, Height float64
}

type Square struct {
  Side float64
}

func SetDimensions(shape *Rectangle, width, height float64) {
  shape.Width = width
  shape.Height = height
}

Passing a Square to this function would break its constraints, as a square must have equal width and height.

Following LSP:

type Shape interface {
  Area() float64
}

type Rectangle struct {
  Width, Height float64
}
func (r Rectangle) Area() float64 { return r.Width * r.Height }

type Square struct {
  Side float64
}
func (s Square) Area() float64 { return s.Side * s.Side }

func PrintArea(shape Shape) {
  fmt.Printf("Area: %.2f\n", shape.Area())
}

Both Rectangle and Square can implement Shape without violating their constraints, ensuring substitutability.

Interface Segregation Principle (ISP)

"Clients should not be forced to depend on interfaces they do not use."

Go’s lightweight interfaces naturally align with ISP by encouraging small, focused interfaces.

Example

Violating ISP:

type Worker interface {
  Work()
  Eat()
  Sleep()
}

Robots implementing this interface would have unused methods like Eat and Sleep.

Following ISP:

type Worker interface { Work() }
type Eater interface { Eat() }
type Sleeper interface { Sleep() }

Each type implements only the interfaces it needs, avoiding unnecessary dependencies.

Dependency Inversion Principle (DIP)

"High-level modules should depend on abstractions, not on details."

Go’s interfaces make it easy to decouple high-level logic from low-level implementations.

Example

Violating DIP:

type NotificationService struct {
  emailSender EmailSender
}

func (ns *NotificationService) NotifyUser(message string) {
  ns.emailSender.SendEmail(message)
}

Here, NotificationService is tightly coupled to EmailSender.

Following DIP:

type Notifier interface {
  Notify(message string)
}

type NotificationService struct {
  notifier Notifier
}

func (ns *NotificationService) NotifyUser(message string) {
  ns.notifier.Notify(message)
}

This allows swapping EmailSender with other implementations like SMSSender without modifying NotificationService.

By embracing SOLID principles, Go developers can write clean, maintainable, and scalable code. Start small, refactor often, and let Go’s simplicity guide you toward better software design.

Why I chose 'golly' framework to build my next Golang based REST API?

Aditya — Wed, 23 Oct 2024 14:29:26 +0000

Why Choose Go (Golang) for Server-Side Development?

Choosing Go (Golang) for server-side development is often driven by its key strengths:

Performance: Go's concurrency model, based on goroutines and channels, allows for efficient handling of multiple tasks simultaneously, making it ideal for high-performance server applications.
Simplicity: The language is designed to be simple and easy to read, with minimalistic syntax. This makes it easier to maintain, even for large projects.
Fast Compilation and Execution: Go compiles directly to machine code, resulting in fast execution times compared to interpreted languages like Python or Node.js.
Scalability: Go's built-in concurrency and lightweight nature make it a good choice for building scalable services that can handle a large number of requests.
Strong Standard Library: Go comes with a powerful standard library, particularly for building networked services, handling HTTP, and managing concurrency, reducing the need for external dependencies.

These factors make Go a great fit for modern server-side applications, especially when performance and scalability are important.

How to build a REST API server in Golang?

There are a lot of frameworks present to build your REST API Servers in Golang like Gin, Gorrilla-Mux and many other.

We would be using a new framework golly which gives a comprehensive set of tools to build your Golang applications.

Let's deep dive into the implementation

Desired APIs we want to build

GET /api/v1/users
POST /api/v1/users
PUT /api/v1/users/:id
DELETE /api/v1/users/:id

Once we have defined our needed APIs, we start by initiating out go project. Use the following commands:-

mkdir my-go-server
cd my-go-server
go mod init rest_server

go get oss.nandlabs.io/golly

Once you perform the above action you should be able to see a folder structure like below

Now we can start creating our desired server structure

Create a main.go file which contains the main() i.e. the entry point of your golang application

package main

import "rest_server/server"

func main() {
        // create the instance of your server
    srv := server.NewServer()
        // start your server
    srv.Start()
}

Create a /server/server.go file which contains your server configuration

package server

import (
    "rest_server/handlers"
    "rest_server/store"

    "oss.nandlabs.io/golly/lifecycle"
    "oss.nandlabs.io/golly/rest/server"
)

type Server struct {
    store *store.Store
}

func NewServer() *Server {
    return &Server{
        store: store.NewStore(),
    }
}

func (s *Server) Start() {
    // register the router by creating the server object
    restServer, err := server.Default()
    if err != nil {
        panic(err)
    }

    // Add path prefix if you want
    restServer.Opts().PathPrefix = "/api/v1"

    // register routes
    restServer.Get("/users", handlers.GetUsers)
    restServer.Post("/users", handlers.AddUser)
    restServer.Put("/users/:id", handlers.UpdateUser)
    restServer.Delete("/users/:id", handlers.DeleteUser)

    // create the http.Server object and register the router as Handler
    // provide the necessary configurations such as PORT, ReadTimeout, WriteTimeout...
    manager := lifecycle.NewSimpleComponentManager()

    // Register the server
    manager.Register(restServer)

    // start the server
    manager.StartAndWait()
}

The application structure you would want to achieve is like below

Create a in-memory store under /store/store.go in order to test your CRUD operations.

package store

import "rest_server/models"

type Store struct {
    data map[string]models.Item
}

var initStore *Store

func NewStore() *Store {
    initStore = &Store{data: make(map[string]models.Item)}
    return initStore
}

func GetStore() *Store {
    return initStore
}

func (s *Store) GetAll() []models.Item {
    items := []models.Item{}
    for _, item := range s.data {
        items = append(items, item)
    }
    return items
}

func (s *Store) GetById(id string) (item models.Item, exists bool) {
    item, exists = s.data[id]
    return
}

func (s *Store) Put(id string, item models.Item) {
    s.data[id] = item
}

func (s *Store) Delete(id string) {
    delete(s.data, id)
}

This would refer to the models present under /models/item.go

package models

type Item struct {
    ID    string `json:"id"`
    Value string `json:"value"`
}

The handlers would contain the handler for each endpoint defined under /server/server.go.

One such implementation of a /handlers/AddUser.go is below

package handlers

import (
    "encoding/json"
    "net/http"

    "rest_server/models"
    "rest_server/response"
    "rest_server/store"

    "oss.nandlabs.io/golly/rest/server"
    "oss.nandlabs.io/golly/uuid"
)

func AddUser(ctx server.Context) {
    // create the model type variable
    var item models.Item
    // decode the request body to the item reference
    if err := json.NewDecoder(ctx.GetRequest().Body).Decode(&item); err != nil {
        // in case of error write the error to the response and return
        response.Error(ctx.HttpResWriter(), http.StatusBadRequest, "invalid request payload")
        return
    }

    // get the store object 
    initStore := store.GetStore()

    uuid, err := uuid.V1()
    if err == nil {
        // assign the uuid generated to the item
        item.ID = uuid.String()
        // add the input body item to the store
        initStore.Put(item.ID, item)
        // generate a success response
        response.JSON(ctx.HttpResWriter(), http.StatusCreated, item)
    } else {
        // generate the error response
        response.Error(ctx.HttpResWriter(), http.StatusBadRequest, "error generating uuid")
        return
    }
}

Similarly, you can create other handlers with the desired logic.

Full example can be found on this github repository

Once you have created your server, you can start your server using below command

cd /my-go-server

go run main.go

Output should be like below

You can see the registered endpoints and where the server is started.

Once the Server is started, you can use Postman or Curl command to invoke your APIs.

You can see how quickly we were able to spin-up a REST server using golly framework in golang.

Benefits of using golly as my go-to framework to build go application

All the libraries used be it lifecycle management, UUID generation, logging, rest-server management and many more is provided out of the box by golly.
Large number of inbuilt libraries present, where I don't have to import multiple third party libraries which keeps my go.mod clean and managable.
Simple and quick implementation of the modules, easy learning curve.
Open source library

For more details about golly, visit the repository Golly. You can checkout the code and feel free to contribute!

Thank you for reading this article!!
If you have any questions, please add in your comments.

Deep dive into Golly: Turbo (Part - 3)

Aditya — Thu, 01 Aug 2024 03:30:00 +0000

Turbo Router: Path Params, Query Params, and Middlewares

Welcome to the third and final part of our blog series on Turbo. In the first two parts, we covered the core utilities of Turbo, focusing on client handling, logging, messaging, and other foundational aspects. Now, we’re diving into one of the most crucial components of any web framework—routing.

In this post, we’ll explore Turbo Router, a high-performance routing utility for Golang. We’ll cover how to work with path parameters, query parameters, and how to efficiently manage your application’s flow using middlewares and filters.

By the end of this article, you'll have a strong understanding of how to leverage Turbo Router to build scalable and maintainable web applications.

1. Handling Path Parameters

Path parameters (also called URL parameters) allow us to capture values in the URL directly. For example, in a URL like /users/123, the value 123 is a dynamic path parameter representing a user ID.

With Turbo Router, handling path parameters is simple. You define your routes with placeholders for dynamic segments.

Here’s how to define a route with path parameters:

router := turbo.NewRouter()

router.Get("/users/:id")

In this example:

The :id in the route "/users/:id" captures the path parameter.
To fetch the path param, internal function is provided getIntPathParms(id string, r *http.Request) int {} where you pass in the path param string key and fetch the Int value.
When a request is made to /users/123, the handler receives 123 as the userID.

2. Working with Query Parameters

Query parameters are a powerful way to pass data in a URL without making the path dynamic. They appear after a ? in the URL, like /search?query=golang.

With Turbo Router, accessing query parameters is straightforward:

router.Get("/search", handlerFunc (w http.ResponseWriter, r *http.Request) {
    val, err := GetQueryParams("query", r)
})

In this case:

GetQueryParams("query", r) fetches the value of the query parameter query.

3. Using Middlewares and Filters

Middlewares are functions that run before your route handler. They allow you to perform actions like authentication, logging, or modifying the request/response. With Turbo Router, you can apply middlewares globally or to specific routes.

To define a simple middleware:

func LoggerMiddleware(next http.Handler) http.Handler {
  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
      logger.Info("Filter Added")
      logger.Info(r.RequestURI)
      next.ServeHTTP(w, r)
      logger.Info("Filter Added again")
  })
}

In this example:

LoggerMiddleware logs the Request URL for each request before calling the next handler.

If you want to apply it to a specific route:

turboRouter := turbo.NewRouter()
turboRouter.Get("/api/v1", ResponseHandler).AddFilter(LoggerMiddleware)

Full detailed examples can be found in below repository.

nandlabs / golly-samples

This repository contains the samples for Golly

Golly Samples Repository

Welcome to the Golly Examples Repository! This repository contains a collection of sample code snippets and examples from the individual libraries of the Golly project. Each example is designed to demonstrate the usage and capabilities of different modules within the Golly ecosystem.

Introduction

Golly is an open-source project aimed at providing robust tools and libraries for various applications. This repository showcases practical examples to help developers understand and utilize the different components of Golly effectively.

Getting Started

To get started with the examples, you'll need to have Golly installed. You can follow the instructions on the Golly GitHub page to set it up.

Prerequisites

Golang (version 1.18 or higher)
Golly installed

Installation

Clone this repository to your local machine:

git clone https://github.com/yourusername/golly-examples.git
cd golly-examples

Examples

This repository is organized by individual libraries within Golly. Each directory contains…

View on GitHub

Conclusion

Turbo Router is a powerful yet simple tool for routing in Golang applications. With support for dynamic Path Parameters, easy-to-access Query Parameters, and flexible Middlewares, you can build robust, scalable web applications. By leveraging these features, you can keep your code clean, efficient, and maintainable.

Whether you’re building a small API or a large web application, Turbo Router can streamline your routing and middleware setup, allowing you to focus more on the logic that matters.

Happy coding!

Deep dive into Golly: Turbo (Part - 2)

Aditya — Mon, 29 Jul 2024 03:30:00 +0000

turbo has a wide range of functionalities inbuilt which you can leverage to improve your application development.

Once you have created the object of turbo

router := tubro.NewRouter()

An instance of turbo is created which is used as an handler to the http.Server object below

srv := &http.Server{
    Handler:      router,
    Addr:         ":8080",
    ReadTimeout:  20 * time.Second,
    WriteTimeout: 20 * time.Second,
}

Multiple configurations can be done on the http.Server object above based on the requirements and specifications.
Some of the configurations that you can provide are TLSConfig, IdleTimeout, ReadHeaderTimeout etc.
More information regarding the http.Server object can be found in the documentation.

Now that the server has been configured, API routes need to be registered to the server in order to process those requests.

There are multiple ways with which we can add routes to our server handler.

Adding routes based on different HTTP Methods
Multiple HTTP Methods Registering

Adding routes based on different HTTP Methods

turbo supports all the basic HTTP methods needed to build an application, and you can follow the below ways on how to register a particular route

Any route that gets added using below format, contains 2 parameters

the path of the API

the handler which processes the request

Add a GET route

router.Get("api/v1/users", getUsers)

Add a POST route

router.Post("api/v1/users", addUser)

Add a PUT route

router.Put("api/v1/users/:id", updateUser)

Add a DELETE route

router.Delete("api/v1/users/:id", deleteUser)

Multiple HTTP Methods Registering

Router lets you register same handler with multiple methods such as ("POST", "PUT") for a single endpoint.
With the help of Add function that can be achieved

router.Add("/api/v1/users", handleCustomers, "PUT", "POST")

Contributing

To contribute to samples, please follow the Repository
Any suggestions to improve the library are welcomed, we want this to be a community driven project and help it grow.
If you feel any improvements in the package, feel free to raise the PR - Project
If you find any bugs that we may have missed, feel free to raise the issues - Raise an Issue
Looking forward to your contributions..

Project Details

golly-samples

nandlabs / golly-samples

This repository contains the samples for Golly

Golly Samples Repository

Introduction

Getting Started

To get started with the examples, you'll need to have Golly installed. You can follow the instructions on the Golly GitHub page to set it up.

Prerequisites

Golang (version 1.18 or higher)
Golly installed

Installation

Clone this repository to your local machine:

git clone https://github.com/yourusername/golly-examples.git
cd golly-examples

Examples

This repository is organized by individual libraries within Golly. Each directory contains…

View on GitHub

This was an in-depth description of different ways you can register routes in turbo.
We will be discussing how to read query params, path params and adding filters to the turbo in the next post.

Stay Tuned!!🕵🏻‍♂️

And if you have any questions, I am happy to answer🚀

Deep dive into Golly: Turbo (Part - 1)

Aditya — Thu, 25 Jul 2024 03:30:00 +0000

Hello Developers,

Building servers is the backbone of any application irrespective of its scale. At the heart of any web application is an HTTP Server - a crucial component responsible for consuming requests and generate desired responses over the internet.

Golang is a widely used server programming language and we can build fast, reliable and flexible HTTP Servers to help our web applications at scale. With this idea in mind, we have build turbo, a light weight router that can help you get started with minimal efforts.

Turbo - Readme Link

With the scope of this blog, we would be discussing on how to build a basic server using turbo and how to can provide configurations to the server.

Setup your project

1. Check your go environment

Ensure you have go installed

go version

2. Create a new project

mkdir testProject
cd testProject

3. Initialise Go Module

You can keep the name of the module same as your project or you can select a custom. It will create a go.mod file based on the module defined in the command

go mod init myModule

4. Install golly package

you would be required to install the golly package in order to use the turbo library

go get oss.nandlabs.io/golly

Your go.mod file would like below

module myModule

go 1.22.4

require oss.nandlabs.io/golly v1.0.0

Start building a simple server using turbo

1. Create a Main Go file

touch main.go

2. Write your simple server following the instructions

package main

import (
    "log"
    "net/http"
    "time"

    "oss.nandlabs.io/golly/turbo"
)

func main() {
    // register the router by creating the turbo object
    router := turbo.NewRouter()

    // add a GET endpoint to your server by providing the "endpoint" and handler function
    router.Get("/api/v1/healthz", healthCheck)

    // create the http.Server object and register the router as Handler
    // provide the necessary configurations such as PORT, ReadTimeout, WriteTimeout...
    srv := &http.Server{
        Handler:      router,
        Addr:         ":8080",
        ReadTimeout:  20 * time.Second,
        WriteTimeout: 20 * time.Second,
    }

    // to start the server, invoke the ListenAndServe method
    if err := srv.ListenAndServe(); err != nil {
        log.Fatalln(err)
    }
}

func healthCheck(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("server is up and running"))
    w.WriteHeader(http.StatusOK)
}

A few things to note,

Creating the router object, turbo.NewRouter() creates a new object and returns the object of the router
You use that router object and register your desired routes in your server. Multiple methods have been exposed and detailed explanation can be found in the turbo documentation.

3. Running your server

go run main.go

Running the server will generate the logs like below

[timestamp] INFO Initiating Turbo
[timestamp] INFO Registering New Route: /api/v1/healthz

You can see the list of registered routes on your server

4. Invoking your API

curl http://localhost:8080/api/v1/healthz

generates the following response

server is up and running

Contributing

To contribute to samples, please follow the Repository
Any suggestions to improve the library are welcomed, we want this to be a community driven project and help it grow.
If you feel any improvements in the package, feel free to raise the PR - Project
If you find any bugs that we may have missed, feel free to raise the issues - Raise an Issue
Looking forward to your contributions..

Project Details

golly-samples

nandlabs / golly-samples

This repository contains the samples for Golly

Golly Samples Repository

Introduction

Getting Started

To get started with the examples, you'll need to have Golly installed. You can follow the instructions on the Golly GitHub page to set it up.

Prerequisites

Golang (version 1.18 or higher)
Golly installed

Installation

Clone this repository to your local machine:

git clone https://github.com/yourusername/golly-examples.git
cd golly-examples

Examples

This repository is organized by individual libraries within Golly. Each directory contains…

View on GitHub

This was a basic server registration and a simple GET endpoint implementation using turbo.
There are a lot of customisations and features which we will discuss in the coming parts of turbo in the series.

And if you have any questions, I am happy to answer🚀

Announcing a New Series: Deep Dive into Golly

Aditya — Sun, 21 Jul 2024 15:49:48 +0000

Hello everyone,

I'm excited to announce that I'll be starting a new series dedicated to exploring the Golly open-source project!

nandlabs / golly

golly is a open source library for go

golly

Golly is a collection of reusable common utilities for go programming language.

Goals

Create reusable common collection of utilities targeting enterprise use cases
Ensure the project is self-contained and minimise external dependencies.

Installation

go get oss.nandlabs.io/golly

Core Packages

assertion
- Unified interface for asserting conditions
- Supports various assertion functions for different types of conditions
clients
- A common package for all types of client
- Checkout clients that leverage this package
  - rest
  - messaging
cli
- Easy to use API for building complex command structures
- Argument parsing and validation
codec
- Easy to use interface
- Multiformat support
- Unifed interface for Endcoding and Decoding data from structured format
- Out of the box support for XML JSON & YAML
collections
- A collection of generic data structures
- Stack, Queue, List,LinkedList, Set
- Synchronized versions of the above
genai
- Interact with generative AI models
- Manage sessions, exchanges, and models
- Handle memory and templates
l3
- Lightweight Levelled Logger
- Multiple logging levels…

View on GitHub

In this series, we'll dive deep into the various modules of Golly, sharing snippets and code examples to help you understand and leverage its capabilities. Whether you're a seasoned developer or just getting started, this series aims to provide valuable insights and practical knowledge.

What to Expect

Detailed Walkthroughs: Each post will focus on a specific module or feature of Golly.
Code Snippets: We'll provide code examples to illustrate how to implement and use different parts of the project.
Best Practices: Tips and tricks to make the most out of Golly's features.
Interactive Discussions: I encourage you to engage, ask questions, and share your own experiences and ideas.

Stay tuned for the first post coming soon! I can't wait to share this journey with you all and explore the depths of Golly together.

Happy coding!

Calling All Developers! Contribute to golly: Empower the Go Community Together 🚀

Aditya — Tue, 16 Jul 2024 15:20:09 +0000

Introduction:

Hey there, Dev.to community! Are you passionate about Go programming and looking for a meaningful open-source project to contribute to? Look no further! We're excited to introduce you to golly, an open-source Go library that's making waves in the Go community.

About golly:

It is always a pain to maintain multiple third-party dependencies while building a project. We have come up with a solution where you just import 1 library and it should solve all your requirements to build your project.
golly provides an extensive library from logger to messaging systems. You name it, we have it.
You don't have to install any other dependeny as golly will take care of all your development needs while creating your go projects.

Why Contribute?

Benefits of contributing to golly:

Enhance your Go programming skills.
Collaborate with a diverse and welcoming community.
Build a strong open-source portfolio.
Contribute to the Go ecosystem.

How to Get Started:

Project Link: golly
We welcome any kind of contribution to the project as long as they uplift the project.
Contribution Guidelines: Contribution Guidelines
You can also get to know more about the project here.

Community and Communication:

Please raise an issue with a label "question" if you have any doubts or questions, we are happy to help.
Please follow the Code of Conduct within the community.

Join us in the journey of building and improving golly! Whether you're an experienced Go developer or just getting started, there's a place for you in our vibrant and growing community. Let's make a difference together!

Important Links

Project: https://github.com/nandlabs/golly
Readme: https://github.com/nandlabs/golly/blob/main/README.md
Current Issues List: https://github.com/nandlabs/golly/issues

Hactoberfest 2022

Aditya — Tue, 18 Oct 2022 17:18:42 +0000

This HACKTOBERFEST was a pretty good one.
I was working on my library and got some good contributions.

I worked on Struct Validator built for Golang.

We will continue to improve the library and being an open source project we welcome all the contributions and efforts to make this library better.

Golang Struct Validator

Aditya — Sat, 26 Feb 2022 12:43:57 +0000

We are presenting you a fresh Struct validator for Golang.

Neo's Struct Validator for Go
Repository : https://github.com/neo7337/go-struct-validator

Documentation : https://github.com/neo7337/go-struct-validator/wiki/Documentation

The validator comes with an easy to use implementation and quick to scale. We are continuously improving on the performance of the validator.

Do check out the validator!!

Forem: Aditya

Mastering Error Handling in Go

The Basics: Errors as Values

Creating Custom Errors

Struct-based Custom Errors

Sentinel Errors

Error Wrapping with fmt.Errorf and %w

Unwrapping Errors: errors.Is and errors.As

errors.Is — Checking for a Specific Error

errors.As — Extracting a Specific Error Type

Implementing the Unwrap Method

Panic and Recover

Best Practices

1. Always Handle Errors

2. Add Context When Wrapping

3. Prefer errors.Is / errors.As Over Direct Comparison

4. Return Errors, Don't Log and Return

5. Keep Error Messages Lowercase

Putting It All Together

Conclusion

Building Microservices with Go: A Step-by-Step Guide

Why Go for Microservices?

Project Structure Overview

Why This Structure Supports Scalable Microservices

Folder-by-Folder Breakdown

Libraries Used

Step 1: Clone the Template

Step 2: Update the Module Name

Step 3: Define Your Data Models

Step 4: Implement Business Logic

Step 5: Set Up Data Access

Step 6: Create API Handlers and Routes

Example: Adding a Concurrency Endpoint

Step 7: Customize Application Startup

Step 8: Run Your Microservice

Step 9: Extend and Organize

Step 10: Testing

Repository

Conclusion

Building Microservices with gRPC: A Practical Guide

What is gRPC?

Project Structure

Step 1: Define Your Protocol Buffers

Step 2: Generate Code from Protocol Buffers

For Go Service

For Node.js Service

Step 3: Implement the gRPC Server in Go

Step 4: Create a gRPC Client in Node.js/Express

Step 5: Containerize Your Services with Docker

Go Service Dockerfile

Express.js Service Dockerfile

Step 6: Orchestrate with Docker Compose

Running the Microservices

Testing the Setup

Best Practices for gRPC in Microservices

Advanced gRPC Features

Conclusion

Mastering SOLID Principles in Go: Writing Clean and Maintainable Code

Single Responsibility Principle (SRP)

Example

Open/Closed Principle (OCP)

Example

Liskov Substitution Principle (LSP)

Example

Interface Segregation Principle (ISP)

Example

Dependency Inversion Principle (DIP)

Example

Why I chose 'golly' framework to build my next Golang based REST API?

Why Choose Go (Golang) for Server-Side Development?

How to build a REST API server in Golang?

Deep dive into Golly: Turbo (Part - 3)

Turbo Router: Path Params, Query Params, and Middlewares

1. Handling Path Parameters

2. Working with Query Parameters

3. Using Middlewares and Filters

nandlabs / golly-samples

This repository contains the samples for Golly

Golly Samples Repository

Table of Contents

Error Wrapping with `fmt.Errorf` and `%w`

Unwrapping Errors: `errors.Is` and `errors.As`

`errors.Is` — Checking for a Specific Error

`errors.As` — Extracting a Specific Error Type

Implementing the `Unwrap` Method

3. Prefer `errors.Is` / `errors.As` Over Direct Comparison