Forem: Sandilya Karavadi

Processing File concurrently using Goroutines

Sandilya Karavadi — Wed, 25 Jun 2025 12:33:45 +0000

Problem

How to Read File
How to Process File (i.e Channel) Concurrently with Goroutines

Solution

Reading a File

Spin up a goroutine to read data from file in chunks using

scanner.Scan()

Processing `Channel`

Spin Up N goroutine
Each one will take a Chunk from the Channel
Extract data from the Chunk and execute processFn

func ProcessFile(file io.Reader, numWorkers int, chunkSize int, processFn func(data []byte))

Github Repo for code

Sandy10247 / go-process-file

A Sample Repo, to demonstrate File Processing concurrently

go-process-file

A Sample Repo, to demonstrate File Processing concurrently

Execution

Dev to Article

Processing File concurrently with using Goroutines

View on GitHub

Github Repo

Inspired by

Circuit Breaker 🎛️ pattern with GO

Sandilya Karavadi — Tue, 10 Dec 2024 16:17:30 +0000

Problem

As Einstein said "perpetual motion machines are impossible".

Server ⚙️ can

Go down i.e Go Offline
Constantly give 500 i.e DBs they are hitting can go down
N number of natural causes that can make a remote server useless.

Since Client won't have any information of the Server state, it will keep on trying and all the requests are gonna be failing.

Solution

Circuit Breaker proxy for Client

Microsoft's proposed solution is a Simple State Machine which can exist in one of three states

Closed 🟢

-- No issues, operations can go as is.

Open 🔴

-- Machine (i.e Server) is not in a good state, block everything.

Half Open 🟡

-- Testing fire, let one or more requestes to go through to check Machine state.
-- if success flip the machine state to "closed" 🟢
-- else move it to "open 🔴"

Implementation

we can go through a well thought out implementation for this in Sony Circuit Breaker
Below is an example for it.

Server

// server.go
package main

import (
    "log"
    "net/http"
    "os"
)

// ExampleServer is a test server to check the "CircuitBreaker" pattern
type ExampleServer struct {
    addr      string
    logger    *log.Logger
    isEnabled bool
}

// NewExampleServer creates the instance of our server
func NewExampleServer(addr string) *ExampleServer {
    return &ExampleServer{
        addr:      addr,
        logger:    log.New(os.Stdout, "Server\t", log.LstdFlags),
        isEnabled: true,
    }
}

// ListenAndServe starts listening on the address provided
// on creating the instance.
func (s *ExampleServer) ListenAndServe() error {
    // The main endpoint we will request to
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        if s.isEnabled {
            s.logger.Println("responded with OK")
            w.WriteHeader(http.StatusOK)
        } else {
            s.logger.Println("responded with Error")
            w.WriteHeader(http.StatusInternalServerError)
        }
    })

    // Toggle endpoint to switch on and off responses from the main one
    http.HandleFunc("/toggle", func(w http.ResponseWriter, r *http.Request) {
        s.isEnabled = !s.isEnabled
        s.logger.Println("toggled. Is enabled:", s.isEnabled)
        w.WriteHeader(http.StatusOK)
    })

    return http.ListenAndServe(s.addr, nil)
}

Server.go

struct "ExampleServer"

type ExampleServer struct {
    addr      string
    logger    *log.Logger
    isEnabled bool
}

here "isEnabled" is the server's way of saying I am online / offline.
when false don't send me anything at all, cause I am gonna fail them regardless.

ExampleServer servers two routes

/ -- responds with 200
/toggle -- responds with 200 -- toggles "isEnabled" struct state.

client.go

// client.go
package main

import (
    "errors"
    "net/http"
)

type NotificationClient interface {
    Send() error // We ignore all the arguments to simplify the demo
}

type SmsClient struct {
    baseUrl string
}

func NewSmsClient(baseUrl string) *SmsClient {
    return &SmsClient{
        baseUrl: baseUrl,
    }
}

func (s *SmsClient) Send() error {
    url := s.baseUrl + "/"
    resp, err := http.Get(url)
    if err != nil {
        return err
    }
    defer resp.Body.Close()
    if resp.StatusCode < 200 || resp.StatusCode >= 300 {
        return errors.New("bad response")
    }

    return nil
}

SmsClient struct has a method Send just makes an Api hit to server, return error when Api hit is not successfull.

func (s *SmsClient) Send() error {
    url := s.baseUrl + "/"
    resp, err := http.Get(url)
    if err != nil {
        return err
    }
    defer resp.Body.Close()
    if resp.StatusCode < 200 || resp.StatusCode >= 300 {
        return errors.New("bad response")
    }

    return nil
}

circuit_breaker.go

// circuit_breaker.go
package main

import (
    "log"
    "os"
    "time"

    "github.com/sony/gobreaker/v2"
)

type ClientCircuitBreakerProxy struct {
    client NotificationClient
    logger *log.Logger
    gb     *gobreaker.CircuitBreaker[any] // downloaded lib structure
}

// shouldBeSwitchedToOpen checks if the circuit breaker should
// switch to the Open state
func shouldBeSwitchedToOpen(counts gobreaker.Counts) bool {
    failureRatio := float64(counts.TotalFailures) / float64(counts.Requests)
    return counts.Requests >= 3 && failureRatio >= 0.6
}

func NewClientCircuitBreakerProxy(client NotificationClient) *ClientCircuitBreakerProxy {
    logger := log.New(os.Stdout, "CB\t", log.LstdFlags)

    // We need circuit breaker configuration
    cfg := gobreaker.Settings{
        // When to flush counters int the Closed state
        Interval: 5 * time.Second,
        // Time to switch from Open to Half-open
        Timeout: 7 * time.Second,
        // Function with check when to switch from Closed to Open
        ReadyToTrip: shouldBeSwitchedToOpen,
        // set Max Request in Half Open state to 5
        MaxRequests: 5,
        // On State change Handler Fn
        OnStateChange: func(_ string, from gobreaker.State, to gobreaker.State) {
            // Handler for every state change. We'll use for debugging purpose
            logger.Println("state changed from", from.String(), "to", to.String())
        },
    }

    return &ClientCircuitBreakerProxy{
        client: client,
        logger: logger,
        gb:     gobreaker.NewCircuitBreaker[any](cfg),
    }
}

func (c *ClientCircuitBreakerProxy) Send() error {
    // We call the Execute method and wrap our client's call
    _, err := c.gb.Execute(func() (any, error) {
        err := c.client.Send()
        return nil, err
    })
    return err
}

struct ClientCircuitBreakerProxy

holds client which can house SmsClient which we declared above.
holds an instance for CircuitBreaker the state machine which hold the implementation for "Circuit Breaker" pattern.

type ClientCircuitBreakerProxy struct {
    client NotificationClient
    logger *log.Logger
    gb     *gobreaker.CircuitBreaker[any] // downloaded lib structure
}

In the implementation NewClientCircuitBreakerProxy fn takes a SmsClient as parameter and provides the inital values for CircuitBreaker

    // We need circuit breaker configuration
    cfg := gobreaker.Settings{
        // When to flush counters int the Closed state
        Interval: 5 * time.Second,
        // Time to switch from Open to Half-open
        Timeout: 7 * time.Second,
        // Function with check when to switch from Closed to Open
        ReadyToTrip: shouldBeSwitchedToOpen,
        // set Max Request in Half Open state to 5
        MaxRequests: 5,
        // On State change Handler Fn
        OnStateChange: func(_ string, from gobreaker.State, to gobreaker.State) {
            // Handler for every state change. We'll use for debugging purpose
            logger.Println("state changed from", from.String(), "to", to.String())
        },
    }

Send method in struct ClientCircuitBreakerProxy is a wrapper to client's Send method.

main.go

// main.go
package main

import (
    "log"
    "os"
    "time"
)

func main() {
    logger := log.New(os.Stdout, "Main\t", log.LstdFlags)
    server := NewExampleServer(":8080")

    go func() {
        _ = server.ListenAndServe()
    }()

    var client NotificationClient

    client = NewSmsClient("http://127.0.0.1:8080")

    client = NewClientCircuitBreakerProxy(client)

    for {
        err := client.Send()
        time.Sleep(1 * time.Second)
        if err != nil {
            logger.Println("caught an error", err)
        }
    }
}

create a logger with

logger := log.New(os.Stdout, "Main\t", log.LstdFlags)

start the simple go server with an run it concurrently with go routine

server := NewExampleServer(":8080")

    go func() {
        _ = server.ListenAndServe()
    }()

Initiate the Client with


    var client NotificationClient

    client = NewSmsClient("http://127.0.0.1:8080")

wrap it with Circuit Breaker proxy

    client = NewClientCircuitBreakerProxy(client)

run an infinity loop which makes API hits to out simple server

    for {
        err := client.Send()
        time.Sleep(1 * time.Second)
        if err != nil {
            logger.Println("caught an error", err)
        }
    }

Conclusion

As the Client makes the API hits in regular intervals to the Server
till an API hit /toggle Circuit will make the Circuit Breaker to be in open 🟢

Reference

Circuit Breaker Pattern in GO

Code

Sandy10247 / go-breaker-example

A Simple implementation of Circuit Breaker pattern.

go-breaker-example

A Simple implementation of Circuit Breaker pattern.

execution

go run .

output

View on GitHub

Why add Tailwind CSS Atomic Classes to project ❓

Sandilya Karavadi — Mon, 09 Dec 2024 17:12:21 +0000

Problem

When projects with many UI developers, start to code components in their own way, each declaring their own custom css classes, as per need.

Traditional way

When we consider a simple well know issue to center a "div" in a page, this is how we typically create a class, with all the necessary styling.

<template>
    <div class="center-div">
        Lorem ipsum dolor sit amet consectetur, adipisicing elit. Sint distinctio ratione
        corporis maiores beatae quasi veritatis iste consequuntur provident reiciendis
        quos molestias, quia ipsam laborum earum voluptatum quo numquam qui?
    </div>
</template>

<script>
export default {
    name: 'Playground'
};
</script>

<style lang="scss" scoped>
.center-div {
    box-sizing: border-box;
    position: absolute;
    display: flex;
    align-items: center;
    justify-content: center;
    top: 50%;
    left: 40%;
    max-width: 500px;
    background-color: black;
    color: white;
}
</style>

output :-

Pros :-

Developers can add any styling for the classes as they please.

Cons :-

As project grows, there won't be any uniformed styling for the project.
It becomes tedious to apply same styles for new modules, as develepoers need to apply them themselves.
Developer intent is not clear, i.e class name is "center-div" but inner styling can be anything they desire.

Tailwind philosophy

Building complex components from a constrained set of primitive utilities.

We need to break a component classes from group up with Atomic classes.

<template>
    <div
        class="box-border absolute flex justify-items-center top-1-2 left-40-p fill-gray-alpha color-fill max-w-sm"
    >
        Lorem ipsum dolor sit amet consectetur, adipisicing elit. Sint distinctio ratione
        corporis maiores beatae quasi veritatis iste consequuntur provident reiciendis
        quos molestias, quia ipsam laborum earum voluptatum quo numquam qui?
    </div>
</template>

<script>
export default {
    name: 'Playground'
};
</script>

Output

What Happened, where are the classes ⁉️

As you can see from the code above we have used quite a few classes in our "div"

class="box-border absolute flex justify-items-center top-1-2 left-1-2 fill-gray-alpha color-fill max-w-sm"

Each class is registered in the global application scope, which goes like this

.box-border {
    box-sizing: border-box;
}

.absolute {
    position: absolute;
}

.flex {
    display: flex;
}

.justify-items-center {
    justify-items: center;
}

.top-1-2 {
    top: 50%
}

.left-40-p {
    left: 40%;
}

.max-w-sm {
    max-width: 24rem; /* 384px */
}

Since all these classes are available in the global scope, any developer can use them freely.

Pros

Reduces CSS Bundle size significantly.
Ensures component styling to be consistent across the team.
Developers can rapidly prototype their ideas, with less effort on redoing the same style.

Cons

Learning curve, each developer needs to get familiar with classes that already existing.
Project needs to keep proper documentation, when adding these Global declared classes for others to consume.

Vue JS Pitfalls

:deep() / ::v-deep

the bain 😓 of Vue JS css targeting.

Traditional Classes

Targeting and Applying styling for the classes is very easy

div {
    ::v-deep .center-div {
        background-color: red;
    }
}

Taiwind Classes

Developers need to get very creative when targeting "div"

div {
    ::v-deep :first-of-type {
        background-color: red;
    }
}

How to Introduce Tailwind CSS Classes into your Application

Traditional way

we can easily install them with

Tailwind Installation

npm install -D tailwindcss
npx tailwindcss init

but this will install (i.e register) a plethorah of all the classes, in the global scope.

Unconventional 🤨 way

when your Application already has an existing css library, it would be ideal to cherry pick, the classes we need and add them in one css file and register it globally in the App.
Say your Application only wants flexibility in flexbox styling
-- Get a list of the classes you need from flex styles
cherry pick the classes you 🤞 assume 🤞 your application needs, and add them as per need.
with this way we can keep the CSS bundle significanlty small, but the development team needs to have tight control over css they apply 🤟.

/* FlexBox */
.flex {
    display: flex;
}

.flex-row {
    flex-direction: row;
}

.flex-row-reverse {
    flex-direction: row-reverse;
}

.flex-col {
    flex-direction: column;
}

.flex-col-reverse   {
    flex-direction: column-reverse;

}

.flex-wrap {
    flex-wrap: wrap;
}

.flex-nowrap {
    flex-wrap: nowrap;
}

.grow {
    flex-grow: 1;
}

.grow-0 {
    flex-grow: 0;
}

.shrink {
    flex-shrink: 1;
}
.shrink-0 {
    flex-shrink: 0;
}
.justify-normal {
    justify-content: normal;
}
.justify-start {
    justify-content: flex-start;
}
.justify-end {
    justify-content: flex-end;
}
.justify-center {
    justify-content: center;
}
.justify-between {
    justify-content: space-between;
}
.justify-around {
    justify-content: space-around;
}
.justify-evenly {
    justify-content: space-evenly;
}
.justify-stretch {
    justify-content: stretch;
}
.justify-items-start {
    justify-items: start;
}
.justify-items-end {
    justify-items: end;
}
.justify-items-center {
    justify-items: center;
}
.justify-items-stretch {
    justify-items: stretch;
}
.justify-self-auto {
    justify-self: auto;
}
.justify-self-start {
    justify-self: start;
}
.justify-self-end {
    justify-self: end;
}
.justify-self-center {
    justify-self: center;
}
.justify-self-stretch {
    justify-self: stretch
}
.content-noraml {
    align-content: normal;
}
.content-center {
    align-content: center;
}
.content-start {
    align-content: start;
}
.content-end {
    align-content: end;
}
.content-between {
    align-content: space-between;
}
.content-around {
    align-content: space-around;
}
.content-evenly {
    align-content: space-evenly;
}
.content-baseline {
    align-content: baseline;
}
.content-stretch {
    align-content: stretch;
}
.items-start {
    align-items: start;
}
.items-end {
    align-items: end;
}
.items-center {
    align-items: center;
}
.items-baseline {
    align-items: baseline;
}
.items-stretch {
    align-items: stretch;
}

// Align Self 
.self-auto {
    align-self: auto;
}

.self-start {
    align-self: flex-start;
}

.self-end {
    align-self: flex-end;
}

.self-center {
    align-self: center;
}

.self-stretch {
    align-self: stretch;
}

.self-baseline {
    align-self: baseline;
}

Conslusion

Using Atomic classes with Tailwind as reference can
Reduce a Project's CSS footprint.
Maintain Styling consistensy across the Application.
Increases Developer speed, with rapid prototyping. 🔥

Forem: Sandilya Karavadi

Processing File concurrently using Goroutines

Problem

Solution

Reading a File

Processing Channel

Sandy10247 / go-process-file

A Sample Repo, to demonstrate File Processing concurrently

go-process-file

Execution

Dev to Article

Circuit Breaker 🎛️ pattern with GO

Problem

Solution

Circuit Breaker proxy for Client

Closed 🟢

Open 🔴

Half Open 🟡

Implementation

Server

client.go

circuit_breaker.go

main.go

Conclusion

Reference

Code

Sandy10247 / go-breaker-example

A Simple implementation of Circuit Breaker pattern.

go-breaker-example

execution

output

Why add Tailwind CSS Atomic Classes to project ❓

Traditional way

Tailwind philosophy

Vue JS Pitfalls

Traditional Classes

Taiwind Classes

How to Introduce Tailwind CSS Classes into your Application

Traditional way

Unconventional 🤨 way

Processing `Channel`