DEV Community: Aabhas Sao

Stop Writing ../../../../../../ in Your Imports

Aabhas Sao — Thu, 12 Mar 2026 05:37:50 +0000

Something clicked for me recently when I was staring at this line in my codebase:

import Button from "../../../../../../components/Button.tsx"

Six levels deep. And honestly, what does that even tell you? You have to mentally trace backwards from wherever you currently are just to figure out where that file lives. The path is relative to this file, which means it looks different in every single file that imports the same component.

There is a cleaner way.

import Button from "@/components/Button.tsx"

Same component. But now the path is absolute, it reads clearly, and it looks identical no matter which file you paste it into. You immediately know where to find it in the project. No counting ../ hops.

Setting It Up

It takes about five minutes. In your tsconfig.json:

{
  "compilerOptions": {
    "baseUrl": ".",
    "paths": {
      "@/*": ["src/*"]
    }
  }
}

If you are using Vite:

// vite.config.ts
import { defineConfig } from "vite"
import path from "path"

export default defineConfig({
  resolve: {
    alias: {
      "@": path.resolve(__dirname, "src"),
    },
  },
})

Webpack has its own resolve.alias config, same idea.

The VSCode Thing

By default, VSCode still suggests relative imports even after you set up aliases. To fix that, add this to your settings:

"typescript.preferences.importModuleSpecifier": "non-relative"

After that, auto import suggestions will use @/ paths instead of ../ chains.

When Are Relative Imports Actually Fine?

Honestly, for files that are right next to each other. If you have utils.ts sitting right beside index.ts, doing import { helper } from "./utils" is totally fine. The problem starts when you cross multiple folders.

The rule I follow: if the import needs more than one ../, reach for the alias.

The One Upside of Relative Imports

Zero setup. They work out of the box in every project. That is their only real advantage, and it stops mattering the moment a project grows past a handful of files.

Most serious projects configure path aliases from day one now. If your current project does not have it set up, it is worth the five minutes. Future you, three months from now, deep in a nested feature folder, will appreciate it.

No JavaScript, it's a no. Quite funny how when I used JavaScript extensively. I used to hate Java's quirks, and today I'm picking on JavaScript.

Now off you go, clean up the imports.

Creating Nested Routes in Gin

Aabhas Sao — Mon, 23 Jun 2025 15:59:44 +0000

Do you place all your application API endpoints in main.go file. I'm pretty sure the main file has become messy with all those handler imports and endpoints at one place. Imagine getting to a situation like below and simple act of refactoring routes coming to rescue.

I have loved the idea of structuring the project based on features instead of layer based structure. Below two code snippets show comparison of feature based and layer based structure.

The benefit of feature based structure lies in the fact that we are trying to divide our project based on logical boundaries which can be independent modules/actors interacting with each other.

feature_first/
├── main.go
├── pizzas/
│   ├── handler.go
│   ├── service.go
│   ├── repository.go
│   └── model.go
├── noodles/
│   ├── handler.go
│   ├── service.go
│   ├── repository.go
│   └── model.go
└── utils/
    └── logger.go

layer_first/
├── main.go
├── handlers/
│   ├── pizzas.go
│   └── noodles.go
├── services/
│   ├── pizzas.go
│   └── noodles.go
├── repositories/
│   ├── pizzas.go
│   └── noodles.go
├── models/
│   ├── pizzas.go
│   └── noodles.go
└── utils/
    └── logger.go

Let's see how we can structure our routes so that we easily bake them into our feature-based project structure.

Create a sample project in a folder and initialize a go project using below command.

go mod init nested-routing

Let's install dependencies for gin using

go get -u github.com/gin-gonic/gin

Below is a sample main.go code running a simple server and on hitting localhost:8080/ping you will get pong as a message.

package main

import (
    "net/http"

    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()
    r.GET("/ping", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{"message": "pong"})
    })

    r.Run()
}

Modularizing Routes on Basis of features

Now let's create a router component in router/router.go which will register routes for all our nested routes.

package router

import (
    "nested-routing/noodles"
    "nested-routing/pizzas"

    "github.com/gin-gonic/gin"
)

func SetupRoutes(r *gin.Engine) {
    api := r.Group("/api/v1")

    pizzasGroup := api.Group("/pizzas")
    noddlesGroup := api.Group("/noodles")

    pizzas.SetupRoutes(pizzasGroup)
    noodles.SetupRoutes(noddlesGroup)
}

We can now place all the routes related to noodles in the noodles package noodles/handler.go.

package noodles

import (
    "net/http"

    "github.com/gin-gonic/gin"
)

func SetupRoutes(r *gin.RouterGroup) {
    r.GET("/", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{"message": "noodles"})
    })
}

below is pizza/handler.go.

package pizzas

import (
    "net/http"

    "github.com/gin-gonic/gin"
)

func SetupRoutes(r *gin.RouterGroup) {
    r.GET("/", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{"message": "pizzas"})
    })
}

Ping http://localhost:8080/api/v1/noodles to get a json response with message as noodles. Yay!, we have successfully nested our routes.

I would love to hear how you create routes in your projects. I love the little blue demon (go 🙈) and will be sharing interesting ideas and learnings regarding golang. Follow me on Dev, if you would like to join this ship to go for an adventure (pun intended).

Thank you for your time.

My Journey to Appreciating Java in 2025

Aabhas Sao — Sun, 09 Feb 2025 12:22:02 +0000

I always dreaded Java. I started my journey with JavaScript and was using it for backend with Node.js. I loved simplicity and versatility of javascript to use it to build anything from frontend, backend, ML, to crypto projects. Yet, despite Java's popularity, running on billions of devices from mobile phones to POS systems, I couldn’t bring myself to like it. Let me share my personal journey to liking Java and why my perception changed over time.

When eyes meet with Java

Remember the time before Android or iOS became popular? The early touch screen phones used to come with games with Java jar files. I have fond memories of playing so many games and they had size of under 1 MB only!

I started learning HTML, CSS, JavaScript to build website and then later learned Node.js. Why switch when you can build backend with JavaScript.

Occasionally, I tried exploring Java but avoided diving deeper. Writing System.out.println("Hello World") just to print a single line felt unnecessarily verbose. On top of that, there was widespread negativity toward Java from YouTube content creators. People were constantly talking about Rust, Go, Ruby on Rails, and Zig, leaving Java to feel like an outdated relic.

We Meet Again

During my first job, our backend application is written in Java. So I had no other option but to learn it.

Debugging Frustrations: Now the first pain point for me was the fact that to make any changes I had to compile the class file and replace it in an .ear file and restart Tomcat server, the whole process would take about 5 mins. It was frustrating. In NodeJS I just had to use nodemon to get the changes reflected.

Understanding OOP code: Getting used to read OOP (Object Oriented Programming) based code was new to me. It got confusing sometimes, classes extending, implementing and what not.

The Perception of Obsolescence: My overall perception was that no one is starting new projects in Java in 2024. The most of the resources I find online are pretty outdated, they might be relevant but in JavaScript, you'll always find the most fresh content out there.

Living with the Pain

The pain of Debugging

If you aren't familiar above is a sample image of how stack trace in Java looks like. Initially it was really scary to search in the log file of 50K lines and seeing a lot of caused by chains. The above image paints a nice picture of how debugging in Java can be sometimes. but with time I realised that the useful message is in the bottom most caused by chain mostly.

But sometimes the root cause might be wildly unrelated to the error thrown but this is not something specific to Java, I have faced issues like this javascript as well.
I learned patience and to analyse problems deeply before taking any action to avoid the tedious process of compiling class files and replacing them in the ear archives deployed on Tomcat.

Java has Evolved but has your organisation?

One major feature of Java is its excellent backward compatibility. While this ensures stability, it also means that organizations tend to avoid updating older systems. For instance:

Using XML-based configurations for Spring Beans.
Relying on Enterprise Java Beans (EJBs).
Employing Ant for complex build processes.

These older practices can make development unnecessarily complex. Modern tools like Spring Boot and Gradle are far more developer-friendly, yet many companies stick to the old ways. 🥲

Discovering Spring Boot & Lombok: Java has evolved a lot and modern Java helped me resolve some of the frustrating developer experience that I had. When using Spring Boot I no longer have to change class files inside a war file but the changes get reflected quickly as it uses an embedded tomcat server. Using Lombok annotations I no longer have define getter, setters, and a lot of things get shorter.

Final Thoughts

I have just started my journey and learning more about Java, Spring. Please let me know what are your thoughts on Java, whether you haven't started yet, want to or are a veteran.

But regardless, Java you're a pookie don't let anyone tell you, you're boring, old fashioned, tedious. You're reliable, and understanding you takes time but it's worth it 💖

Kubernetes Bedtime Stories

Aabhas Sao — Wed, 11 Jan 2023 18:11:24 +0000

Once upon a time there was a web app name App. App loved kids and to serve stories and videos to them was App's calling.

Once a dev named Bart did some changes to code but for another dev Joe things broke due to the changes. When Bart was asked about the issue he said that the code works on his machine. Paul and Andrew started fighting over this issue and then App stepped in.

App: I have to do something about this. What should I don't know whose fault is this but this trouble with people having different local environments is bringing flakiness.

App is very tensed and wants to relieve this burden of environment dependency from life. Who will help him.

Enter Docker.

Docker: Hey App I can help you. I know how it feels when stuff runs on one machine and does not work on another.

App: Thanks Docker now I feel good. I get updated quickly due to issues related to environment dependency have reduced. Even I have become easier to deploy. Come to my home I'll treat you with cookies. Bring linux and Go as well.

Usually the traffic for App was 100,000 concurrent users but kids found about the coolness of App and concurrent users started growing to 1 million+. The codebase started to get real complex and the developers started to face difficulty working on features.

One day a dev Paul was working on the Authentication system but Joe had made some changes in the Accounts system and the whole thing broke. Several such instances started taking place. Adding new feature was getting difficult without breaking things.

App: Hey Docker what should I do there are millions of kids sending me requests. We are not able to scale and our team is not able to co-ordinate well given the complexity of codebase. I feel bad if I will not be able to help them. How will they sleep at night without hearing lullabies and how will their moms' make them to eat without the videos.

Amidst this chaos a brilliant idea came to Docker's mind.

Docker: App don't worry let's contact Alice. She might be back from vacation in Hawaii.

With the suggestion of Docker, App contacted Alice who was the CTO of the company and mentioned the ongoing problems.

Alice (The CTO): Ohh, this seems like a serious trouble. Hey, App why don't we try shifting to a micro-services (break down the code base to several different services). Let's say a different service for Authentication, one for Accounts, etc. This would help teams work independently without conflicts. Also we will be having a lot containers, so we need someone very skilled to manage all those.

App: Alice, do you know someone who can do the job of managing containers.

Alice (The CTO): Yes, I just happen to know the right guy.

App: Who

Alice (The CTO): Kubernetes 🤩.

Through Alice's referral App called Kubernetes for help.

Enter Kubernetes.

Kubernetes: Hey folks I can help you out. I have some experience being a ship captain and I can sail the ships with containers (docker containers 😂). I can handle scaling of containers, logging, monitoring of containers, handle crashes and automatic failures.

App: How much does it cost the company.

Kubernetes: I believe in open source. My parents (Google) taught me the spirit of open source and the importance of open source community. I take inspiration from open source projects like linux and understand how crucial they are in the software world.

App: Ohh, thats gr8. Hey Kube guy I like you I have a cool nick name for you k8s.

Kubernetes: I love that name. I will gladly take it.

After a lot of effort and collaboration from the developers, Alice, Docker, k8s. App was again able to make the kids happy. Now Kids won't cry as they can watch their favourite videos on App.

Executing Shell Scripts with NodeJS

Aabhas Sao — Tue, 08 Mar 2022 19:29:51 +0000

You might have seen .sh files in many popular GitHub repositories. Even some of you might have used shell file to install node's latest version in Ubuntu. What the hell are those? Let's get started

What is Shell? 🐚

Shell is a command line tool through which you can interact with the kernel. Through shell commands many crucial things can be done like accessing the hardware resource, spawning child processes and many more.

What is NodeJS? ☊

Node is a javascript runtime, usually used to create a backend server. Initially JavaScript could only run on the browser. But the curiosity of one man named Ryan Dahl changed it. JavaScript is slower than statically typed languages. But V8 engine developed by Google improved the javascript performance.

Ways to execute shell scripts 🚴‍♂️

You can run shell script by creating a file with .sh extension. bash, zshrc, and more are modifications on top of shell. Unix like systems have bash shell as default. Windows has command shell and powershell.

Why execute shell scripts in Node? 🤔

Say you need to use a library or tool which is only available as CLI. You don't have any npm module to do that specific task. What you would do now? Don't worry I have a solution for you.

The first time I used it 🐣

In one of the projects I had to access a CLI tool installed on the docker container using Node server. I was using Cura engine a CLI tool installed in my docker container running ubuntu. The basic function of the CLI tool was to convert STL 3d object to G-code. For those of you who don't know what a G-code file is, it is a code which serves as instructions for a 3d printer to print a model. It contains instructions on how to move and how much material to drop, which material to choose etc.
So in my server I was taking a STL file as multipart data and returning a G-code file as response.

Let's try a fun example 🚀

First install Node.js if you don't have it already. Let's create a node project.

Install emoj globally so that we can call it via command line. Create a directory and then change your directory into that. Install nodemon globally as well so we don't have to reload the server manually.



npm i -g emoj nodemon

Initialise the node project with all default parameters.



npm i init -y

Create a server.js file. The main logic of our code will be in this file.



touch server.js

Add an npm script to run the server.



  "scripts": {
    "start": "nodemon server.js"
  }

Now let's create a node server. Add the code below in server.js file.



import express from 'express'
const app = express()

const PORT = 3000;

app.get('/', (req, res) => {
  res.send('hello world!');
});

app.listen(PORT, () => {
  console.log(`server running on port: ${PORT}`);
})

Run the server and try localhost:3000/ in your browser. You will see hello world! if there is no error.



  npm start

Now let's code the most fun part. We will use exec function that node.js provides.

The function of exec is beautifully described in node.js documentation. I would like to quote it here.

Spawns a shell then executes the command within that shell, buffering any generated output.

You can check out the node.js documentation to learn more about exec.



const { exec } = require("child_process");

Add the fun request in server.js before app.listen.



app.get('/fun', async (req, res) => {
  const { commandText } = req.query;
  console.log(req.query)
  await exec(`emoj ${commandText}`, (error, stdout, stderr) => {
    if (error) {
      console.error(`exec error: ${error}`);
      return res.send('some error happened: 😭');
    }

    return res.status(200).send(stdout);
  });
});

Now the final server.js file looks like below.



const express = require('express');
const app = express()
const { exec } = require("child_process");

const PORT = 3000;

// app.use(express.urlencoded());

app.get('/', (req, res) => {
  res.send('hello world!');
});

app.get('/fun', async (req, res) => {
  const { commandText } = req.query;
  console.log(req.query)
  await exec(`emoj ${commandText}`, (error, stdout, stderr) => {
    if (error) {
      console.error(`exec error: ${error}`);
      return res.send('some error happened: 😭');
    }

    return res.status(200).send(stdout);
  });
});

app.listen(PORT, () => {
  console.log(`server running on port: ${PORT}`);
});

To test our fun route send a get request via any tool like Postman or use browser itself. For postman create a parameter named commandText and pass some cool text.



localhost:3000/fun?commandText=winter is coming

Disclaimer

Passing input arguments taken from user directly to exec function can be dangerous. In a way it is similar to how SQL injection happens. Thanks @antongolub for the feedback.
Consider using following libraries to abstract out risks mentioned above.
github.com/google/zx
github.com/shelljs/shelljs

Outro 💚

Congratulations! You just executed shell command from node.js. I hope you found this article useful. Incase you want to connect with me and discuss about anything feel free to connect with me on LinkedIn💕

If you are an organisation and want a freelance tech content engineer feel free to connect with me