DEV Community: Amit Suthar

BrowserStack Software Engineering - FTE 2026 Graduate Assignment

Amit Suthar — Thu, 22 Jan 2026 16:28:52 +0000

I recently interviewed BrowserStack for the Backend Engineer role and I was asked to implement a remote log streamer service in the machine coding round.

Assignment: Implement a server-side program to monitor a log file and capable of streaming updates that happen in it.

The service will run on the same machine as the log file.
Build a web client that prints the updates in the file as and when they happen and NOT upon page refresh.
The page should be loaded once and it should keep getting updated in real-time.
The user sees the last 10 lines in the file when he lands on the page.

Link to Github Repositiry.

Implementation: (Golang)

// main.go
package main

import (
    "bytes"
    "fmt"
    "log"
    "net/http"
    "os"
    "strings"
    "sync"
    "time"

    "github.com/fsnotify/fsnotify"
    "github.com/gorilla/websocket"
)

const (
    linesToKeep   = 10
    chunkSize     = int64(1024)
    clientBufSize = 256
)

type Ring struct {
    mu    sync.RWMutex
    buf   []string
    size  int
    index int
    full  bool
}

func NewRing(n int) *Ring {
    return &Ring{buf: make([]string, n), size: n}
}

func (r *Ring) Push(line string) {
    r.mu.Lock()
    r.buf[r.index] = line
    r.index = (r.index + 1) % r.size
    if r.index == 0 {
        r.full = true
    }
    r.mu.Unlock()
}

func (r *Ring) Snapshot() []string {
    if !r.full {
        return append([]string{}, r.buf[:r.index]...)
    }
    res := make([]string, 0, r.size)
    res = append(res, r.buf[r.index:]...)
    res = append(res, r.buf[:r.index]...)
    return res
}

func ReadLastN(filepath string, linesToRead int, chunkSize int64) ([]string, error) {
    f, err := os.Open(filepath)
    if err != nil {
        return nil, err
    }
    defer f.Close()

    stat, err := f.Stat()
    if err != nil {
        return nil, err
    }
    size := stat.Size()
    if size == 0 {
        return nil, nil
    }

    var offset = size
    var data []byte

    for offset > 0 && bytes.Count(data, []byte{'\n'}) <= linesToRead {
        if offset < chunkSize {
            chunkSize = offset
        }
        offset -= chunkSize

        buf := make([]byte, chunkSize)
        n, _ := f.ReadAt(buf, offset)
        if n > 0 {
            data = append(buf[:n], data...)
        }
    }

    lines := bytes.Split(data, []byte{'\n'})

    res := make([]string, 0, linesToRead)
    for i := len(lines) - 1; i >= 0 && len(res) < linesToRead; i-- {
        line := strings.TrimSpace(string(lines[i]))
        if line == "" {
            continue
        }
        res = append(res, line)
    }
    // reverse
    for i, j := 0, len(res)-1; i < j; i, j = i+1, j-1 {
        res[i], res[j] = res[j], res[i]
    }
    return res, nil
}

type Client struct {
    conn       *websocket.Conn
    out        chan string
    unregister func(*Client)
    once       sync.Once
}

func (c *Client) Close() {
    c.once.Do(func() {
        c.unregister(c)
    })
}

var (
    registerCh   = make(chan *Client)
    unregisterCh = make(chan *Client)
    broadcastCh  = make(chan string, 1024)
)

func broadcaster(r *Ring) {
    clients := make(map[*Client]bool)
    for {
        select {
        case line := <-broadcastCh:
            for c := range clients {
                select {
                case c.out <- line:
                default:
                    go func(cl *Client) { cl.Close() }(c)
                }
            }
        case c := <-registerCh:
            snap := r.Snapshot()
            for _, s := range snap {
                select {
                case c.out <- s:
                default:
                    go func(cl *Client) { cl.Close() }(c)
                }
            }
            clients[c] = true
        case c := <-unregisterCh:
            if _, ok := clients[c]; ok {
                delete(clients, c)
                close(c.out)
            }
        }
    }
}

var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
    CheckOrigin:     func(r *http.Request) bool { return true },
}

func serveWS() http.HandlerFunc {
    return func(w http.ResponseWriter, req *http.Request) {
        wsConn, err := upgrader.Upgrade(w, req, nil)
        if err != nil {
            http.Error(w, "upgrade failed", http.StatusBadRequest)
            return
        }
        client := &Client{
            conn: wsConn,
            out:  make(chan string, clientBufSize),
            unregister: func(c *Client) {
                unregisterCh <- c
            },
        }

        go func(c *Client) {
            for {
                msg, _ := <-c.out
                if err := c.conn.WriteMessage(websocket.TextMessage, []byte(msg)); err != nil {
                    c.Close()
                    return
                }
            }
        }(client)

        // register with broadcaster (broadcaster will send snapshot then add)
        registerCh <- client
    }
}

func startWatcher(filepath string, ring *Ring) {
    stat, err := os.Stat(filepath)
    var offset int64 = 0
    if err == nil {
        offset = stat.Size()
    }

    partial := []byte{}

    // readNew reads appended bytes since offset, extracts complete lines,
    // pushes them to ring and broadcastCh.
    readNew := func() {
        f, err := os.Open(filepath)
        if err != nil {
            return
        }
        defer f.Close()

        st, err := f.Stat()
        if err != nil {
            return
        }
        newSize := st.Size()
        if newSize <= offset {
            return
        }

        n64 := newSize - offset
        buf := make([]byte, int(n64))
        nread, _ := f.ReadAt(buf, offset)
        offset += int64(nread)

        partial = append(partial, buf[:nread]...)
        parts := bytes.Split(partial, []byte{'\n'})

        for i := 0; i < len(parts)-1; i++ {
            line := strings.TrimSpace(string(parts[i]))
            if line == "" {
                continue
            }
            ring.Push(line)
            select {
            case broadcastCh <- line:
            default:
            }
        }

        incmp := strings.TrimSpace(string(parts[len(parts)-1]))
        if len(incmp) > 0 {
            ring.Push(incmp)
            select {
            case broadcastCh <- incmp:
            default:
            }
            partial = []byte{}
        }
    }

    // set up fsnotify
    watcher, err := fsnotify.NewWatcher()
    if err != nil {
        log.Println("fsnotify.NewWatcher error:", err)
        return
    }
    if err := watcher.Add(filepath); err != nil {
        _ = watcher.Add(".") // if filepath not found, scan the directory for it
    }

    go func() {
        readNew() // poll once at start to capture writes during startup

        for {
            select {
            case ev := <-watcher.Events:
                if ev.Op&fsnotify.Write == fsnotify.Write {
                    // small debounce so writes coalesced
                    time.Sleep(20 * time.Millisecond)
                    readNew()
                }
            case err := <-watcher.Errors:
                log.Println("watcher error:", err)
            }
        }
    }()
}

func serveLogPage(w http.ResponseWriter, r *http.Request) {
    http.ServeFile(w, r, "log.html")
}

func main() {
    filepath := "temp.log"
    if len(os.Args) > 1 {
        filepath = os.Args[1]
    }

    // bootstrap last N lines
    ring := NewRing(linesToKeep)
    if last, err := ReadLastN(filepath, linesToKeep, chunkSize); err == nil && len(last) > 0 {
        for _, l := range last {
            ring.Push(l)
        }
    }

    go broadcaster(ring)

    // watcher that pushes incoming lines to broadcastCh and ring
    startWatcher(filepath, ring)

    http.HandleFunc("/log", serveLogPage)
    http.HandleFunc("/ws", serveWS())

    addr := ":8080"
    fmt.Println("Listening on", addr, "serving /log and /ws — watching", filepath)
    if err := http.ListenAndServe(addr, nil); err != nil {
        log.Fatal(err)
    }
}

<!-- html webpage -->
<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8" />
    <title>Log Viewer</title>
  </head>
  <body style="font-family: monospace">
    <h2>Live Log Viewer</h2>
    <pre
      id="out"
      style="height: 70vh; overflow: auto; border: 1px solid #ddd; padding: 8px"
    ></pre>
    <script>
      let out = document.getElementById("out");
      let ws = new WebSocket(
        (location.protocol === "https:" ? "wss://" : "ws://") +
          location.host +
          "/ws"
      );
      ws.onmessage = function (evt) {
        let t = document.createTextNode(evt.data + "\n");
        out.appendChild(t);
        out.scrollTop = out.scrollHeight;
      };
      ws.onopen = function () {
        console.log("ws open");
      };
      ws.onclose = function () {
        console.log("ws close");
      };
      ws.onerror = function (e) {
        console.error("ws err", e);
      };
    </script>
  </body>
</html>

I got the job :)

Write you own LRU cache cause stdlib don't have any.

Amit Suthar — Sun, 02 Mar 2025 08:09:04 +0000

An efficient Least Recently Used (LRU) cache implementation with generics support, thread safety, and O(1) time complexity for operations.

Data Structures:

Hash Map (map[K]*list.Element)
- O(1) key lookups
- Stores pointers to linked list elements
Doubly Linked List (container/list)
- Maintains access order (MRU at front, LRU at back)
- O(1) insertions/moves/deletions

Eviction Policy:

When capacity is exceeded:

Remove last element from linked list (LRU)
Delete corresponding entry from hash map
Insert new item at list front (MRU)

// lrucache is an in-memory key-value cache
package lrucache

import (
    "container/list"
    "sync"
)

// A CacheItem represents a cached item with its key and value.
type CacheItem[K comparable, V any] struct {
    key   K
    value V
}

// LRUCache is an in-memory cache for key to value mappings.
//
// It uses a hash map with a doubly linked list for LRU eviction.
type LRUCache[K comparable, V any] struct {
    // a read-write mutex
    cacheLock *sync.RWMutex

    // a map of string to linked list element
    cache map[K]*list.Element

    // doubly linked list to implmenent LRU
    lruList *list.List

    // max cache size
    capacity int
}

// NewLRUMap creates a new LRUCache with the specified capacity.
func NewLRUCache[K comparable, V any](capacity int) *LRUCache[K, V] {
    return &LRUCache[K, V]{
        cacheLock: &sync.RWMutex{},
        cache:     make(map[K]*list.Element),
        lruList:   list.New(),
        capacity:  capacity,
    }
}

// Get returns the corresponding value for the given key.
//
// If the value exists, it moves the node to the front of the LRU list.
func (c *LRUCache[K, V]) Get(key K) (V, bool) {
    c.cacheLock.RLock()
    defer c.cacheLock.RUnlock()

    if val, exists := c.cache[key]; exists {
        c.lruList.MoveToFront(val)
        item := val.Value.(*CacheItem[K, V])
        return item.value, true
    }

    var zero V
    return zero, false
}

// Set adds or updates a key-value pair in the cache.
//
// If the cache is full, it evicts the (LRU) least recently used item.
func (c *LRUCache[K, V]) Set(key K, value V) {
    c.cacheLock.Lock()
    defer c.cacheLock.Unlock()

    // If value already exists, move it to front and update the value
    if val, exists := c.cache[key]; exists {
        c.lruList.MoveToFront(val)
        item := val.Value.(*CacheItem[K, V])
        item.value = value
        return
    }

    // If lru list is full, remove the last item (least recently used) from the list
    if c.lruList.Len() >= c.capacity {
        toEvict := c.lruList.Back()
        if toEvict != nil {
            delete(c.cache, toEvict.Value.(*CacheItem[K, V]).key)
            c.lruList.Remove(toEvict)
        }
    }

    // push the newly added item in front
    c.cache[key] = c.lruList.PushFront(&CacheItem[K, V]{key, value})
}

// Delete removes the item from cache.
func (c *LRUCache[K, V]) Delete(key K) {
    c.cacheLock.Lock()
    defer c.cacheLock.Unlock()

    if val, exists := c.cache[key]; exists {
        delete(c.cache, key)
        c.lruList.Remove(val)
    }
}

// Contains checks if key exists in the cache.
func (c *LRUCache[K, V]) Contains(key K) bool {
    _, exists := c.cache[key]
    return exists
}

// Returns the current number fo items in cache.
func (c *LRUCache[K, V]) Len() int {
    return c.lruList.Len()
}

Usage:

package main

import (
    "fmt"

    "github.com/amitsuthar69/libs/lrucache"
)

func LRU() {
    lc := lrucache.NewLRUCache[any, any](3)
    lc.Set("name", "amit")
    lc.Set("age", 20)
    lc.Set("height", 6)

    fmt.Println(lc.Get("name"))   // amit, true
    fmt.Println(lc.Get("age"))    // 20, true
    fmt.Println(lc.Get("height")) // 6, true

    fmt.Println("name", lc.Contains("name"))     // true
    fmt.Println("age", lc.Contains("age"))       // true
    fmt.Println("height", lc.Contains("height")) // true

    fmt.Println(lc.Len()) // 3

    lc.Set("package", 11)

    fmt.Println("name", lc.Contains("name"))       // false
    fmt.Println("age", lc.Contains("age"))         // true
    fmt.Println("height", lc.Contains("height"))   // true
    fmt.Println("package", lc.Contains("package")) // true
}

func main() {
    LRU()
}

How Portsicle works!

Amit Suthar — Sat, 22 Feb 2025 19:09:40 +0000

What is Portsicle?

Portsicle is a reverse tunneling service that creates a public ingress endpoint for local servers, allowing developers to showcase their locally running applications to clients, stakeholders or to test APIs without deploying.

And how does it work?

We all know that the most obvious way to allow an inbound traffic to a private network is through port forwarding, right? But we won't sit and configure our routers every time! we need a better solution.

But if we're not forwarding the port, then how can an external packet enter our private network without getting chocked by firewalls?

Here's where the concept of Reverse Tunneling comes into the picture. Reverse Tunneling is a technique used to establish a secure connection from a remote server back to a local machine. Portsicle beautifully manipulates this same technique to route traffic to local machine.

The idea is to have an intermediary remote (relay) server which will act as a bridge between local machine and the internet traffic. Anyone who wants to access someone's local server, will first visit to the remote server, which will then route the request to the local machine.

To achieve this, Portsicle provides a client CLI which connects to the remote server. The user can use the CLI command to initiate the tunnel. This means that the connection is now outbound (established by the local machine) and the firewall will just ignore it. This connection is then upgraded to a secure and persistent websocket tunnel.

Once a tunnel is established, the relay server provides a 'Public URL' for that session. Anyone on the internet can now access that particular local server with this public URL and the URL is only valid as long as the client is running along.

Steps to get the public url:

Run the client:

portsicle http -p 3000

note that 3000 has to be the port of the local server you wanted to expose.

You'll then receive the URL:

❯ ./portsicle http -p 3000
2025/02/23 00:26:33 Connected to remote server.
2025/02/23 00:26:33 Your public url: https://portsicle.koyeb.app/a355bf62-f7c4-46e9-9d9b-1125d6343b3d

Your local server is accessible with this link!

But how the traffic is "forwarded"??? Well, we simply convert the HTTP/HTTPS requests and responses into websocket messages and forward them between local client and the remote server.

We handle this forwarding for two cycles:

Request cycle:

Take plain HTTP request => Convert it to a message object => send it across wire => reconstruct an HTTP request => send it to local server.

Response cycle:

Client gets a response from local server => convert it to a response object => send it across wire => construct a response.

The GoTTH Stack

Amit Suthar — Sat, 28 Sep 2024 15:32:05 +0000

GoTTH is designed to quickly spin up a Full-Stack Golang Web Application with HTMX, Tailwindcss and Turso SQLite database support.

About the Stack

Includes following Languages and Technologies:

Golang with ServeMux.
TailwindCSS Standalone Executable.
Turso LibSQL (SQLite for Production).
HTMX with Templ as Templating Engine.

Basic Project Guide

GOTTH
│
├── /internal/                 # Private application and business logic
│   ├── /server/               # Server-specific logic
│   │   ├── server.go          # Core server logic
│   │   └── routes.go          # Route definitions
│   ├── /database/             # Database-related logic
│   |   └── database.go        # Database connection and queries
│   └── /middleware/           # Middlewares
│       └── logger.go          # Logger middleware
│
├── /static/                   # Static assets (CSS, JS, images, etc.)
│   ├── /css/                  # CSS files
│   │   ├── input.css          # Tailwind input file
│   │   └── style.css          # Generated CSS file
│   └── /scripts/              # JavaScript files
│       └── htmx.min.js        # HTMX JavaScript library
│
├── /web/                      # Web UI-related handlers
│       ├── hello.templ        # Templating file for the hello page
│       └── hello.go           # Hello handler logic
│
├── main.go                    # Application entry point
├── Makefile                   # Build automation scripts
├── .air.toml                  # Air live reloading config file
├── tailwind.config.js         # Tailwind CSS configuration
└── tailwindcss                # Tailwind CSS binary

Run the project

air

Installation Guide

Air for Live Reload

go install github.com/cosmtrek/air@latest

Templ

go install github.com/a-h/templ/cmd/templ@latest

You can add templ to your local bashrc or zshrc profile config to avoid absolute path while using templ command.

TailwindCSS

Install the executable binary for your platform from the latest release from GitHub in the root of project.
Make sure to give it executable permissions:

chmod +x ./tailwindcss

Turso

go get github.com/tursodatabase/libsql-client-go/libsql

Then Install the Turso CLI, create your database, generate the AuthToken & DB_URL and add them in the .env file.
You can refer this awesome Turso Quickstart Go Docs if you get stuck anywhere.

.env

PORT=8080
DB_URL=libsql://yourDBName-tursoUserName.turso.io?authToken=yourAuthToken

Session and Cookies with Express JS

Amit Suthar — Sun, 05 Nov 2023 10:08:15 +0000

Session and Cookies

1. Session

When a user visits a website, the server creates a unique session ID for the user. This session ID is then stored in a cookie on the user's browser.

On each subsequent request to the server, the browser sends back the session cookie, which allows the server to identify the user and track their session.

Sessions end when the user closes their browser or logs out of the website. The server then deletes the session data.

2. Cookie

A cookie is a small text file that is stored on the user's computer by a website.

Cookies store a variety of information, such as login status, shopping cart contents, and language preferences. Cookies can also be used to track the user's activity across multiple websites.

Cookies can be either persistent or session cookies. Persistent cookies are stored on the user's computer until they expire or are deleted by the user.

In short,

A session is some kind of data stored on the server by the client and is sent through a request and cookie on the other hand is the data stored on the client (browser) by the server and is sent as a response.

To Deal with sessions in express, we need to install the package express-session

Setting up the session :

To setup the session on server we can use the middleware app.use(session({...})), this session() function takes an object as a parameter.

This object takes values such as resave, saveUninitialized and a secret.

const express = require("express");
const app = express();
const session = require("express-session");

app.use(
  session({
    // avoid saving the value of session if its not changed
    resave: false,

    // avoid saving uninitialized data on server
    saveUninitialized: false,

    // a secret key to encrypt the data
    secret: "literallyAnythingYouCanType",
  })
);

app.listen(3000);

Creating a session :

To create a session and store some value in it, we can use the req.session.sessionName method inside any of our route.

As session is stored on our server, it is always requested from the browser.

// ...

app.get("/", (req, res) => {
  req.session.mySession = "this is my session";
  res.send("Hello World");
});

app.get("/newpage", (req, res) => {
  // can access the session on any route.
  console.log(req.session);
});

// ...

Hence, whenever you visit the '/' route, for your browser "mySession = this is my session" is saved on the server. But the repetition of saving this data on server is avoided as we've marked resave to false.

Once a session is created on the server, then it can be accessed through any route of your app.

console.log(req.session); will display an session object which looks like :

Session {
    cookie: {
        path: '/', _expires: null, originalMaxAge: null, httpOnly: true
    }
    mySession: "this is my session", // our saved value
}

During Development, restarting / reloading the server makes the session loose the value we've saved. So revisit the same route to create that session again.

Deleting a session :

To delete a session, we can use the req.session.destroy(() => {}) method which takes an optional callback function as an argument.

// ...

app.get("/deleteSession", (req, res) => {
  req.session.destroy((err) => {
    err && throw err;
    res.send("Session Removed");
  });
});

// ...

Now to Deal with cookies in express, we need to install the package cookie-parser

Setting up the cookies :

To setup the cookie on browser, require the package and then we can use the cookieParser() middleware to parse cookies.

const express = require("express");
const app = express();
const cookieParser = require("cookie-parser");

app.use(cookieParser());

app.listen(3000);

Creating a cookie :

To create a cookie, we can use the res.cookie("name", value) method which takes the cookie name and it's value as an argument.

As cookies are stored on the browser, they are always sent as a response by our server.

// ...

app.get("/", (req, res) => {
  res.cookie("myCookie", "this is my cookie");
  res.send("Hello World");
});

// to read the cookie, we need to find it inside the request body.
app.get("/read", (req, res) => {
  console.log(req.cookies);
});

// ...

console.log(req.cookies); will log out an cookie object which looks like :

{
    "connect.sid": "s:blablablablablablablabla",
    myCookie: "this is my cookie", // our saved value
}

Deleting the cookie :

To delete a cookie, we can us the res.clearCookie("cookieName") method which takes the cookie name to be deleted.

// ...

app.get("/delete", (req, res) => {
  res.clearCookie("myCookie");
});

// ...

My Hacktoberfest Journey

Amit Suthar — Thu, 05 Oct 2023 04:57:29 +0000

Intro

Hii, My name is Amit Suthar and I'm a Second Year Computer Science UnderGrad. This is my first Hacktoberfest and I'm ery excited to contribute to the community. Visit my Github account.

About this month

In this month, I made a plenty of contributions on Github and tried my best to make those contribution meaningful and worthy.

Growth

Before Hacktoberfest 2023, contributions I made were small and were made to local projects and mostly to unrecognized repositories. But during this Hacktoberfest23, I made contributions to repos which have actual use cases and is used actively by a lot of people.
One of the popular repository I contributed is TCET Open Source, Official Hacktoberfest website.

Direct Link to my PRs accepted for hacktoberfest'23

https://github.com/Rahilsiddique/next-blog/pull/14

https://github.com/Rahilsiddique/next-blog/pull/2

https://github.com/tcet-opensource/hacktober-fest/pull/52

https://github.com/tcet-opensource/hacktober-fest/pull/40

https://github.com/illacloud/illa-builder/pull/2482