Forem: Gaurav Saini

Help needed with subrouting in Go

Gaurav Saini — Sun, 21 Apr 2024 10:41:05 +0000

Hello 👋

I've started learning Go a couple days ago. Currently, I'm building Rest APIs using net/http package.

I have figured out most of the basic stuff, but struggling a bit with subrouting. When I add a subrouter using like this



var mux1 = http.NewServeMux()
mux1.HandleFunc(...)

var mux2 = http.NewServeMux()
mux2.HandleFunc(...)
mux1.Handle("/", middleware.IsAuthenticated(mux2))

I'm trying to add a protected set of routes to a router using a middleware. But, the routes defined in the subrouter are not accessible without adding a trailing slash in the URL when making the request. eg:

My Code



// cmd/main/main.go

package main

import (

    "fmt"

    "net/http"

<span class="s">"rest-api/internal/middleware"</span>
<span class="s">"rest-api/internal/routes"</span>
<span class="s">"rest-api/internal/utils"</span>



)

func main() {

    var middlewareStack = utils.CreateStack(middleware.LogRequest)

<span class="k">var</span> <span class="n">v1Router</span> <span class="o">=</span> <span class="n">http</span><span class="o">.</span><span class="n">NewServeMux</span><span class="p">()</span>
<span class="n">v1Router</span><span class="o">.</span><span class="n">Handle</span><span class="p">(</span><span class="s">"/v1/"</span><span class="p">,</span> <span class="n">http</span><span class="o">.</span><span class="n">StripPrefix</span><span class="p">(</span><span class="s">"/v1"</span><span class="p">,</span> <span class="n">routes</span><span class="o">.</span><span class="n">EchoRouter</span><span class="p">()))</span>

<span class="k">var</span> <span class="n">usersRouter</span> <span class="o">=</span> <span class="n">routes</span><span class="o">.</span><span class="n">UsersRouter</span><span class="p">()</span>
<span class="n">v1Router</span><span class="o">.</span><span class="n">Handle</span><span class="p">(</span><span class="s">"/users/"</span><span class="p">,</span> <span class="n">http</span><span class="o">.</span><span class="n">StripPrefix</span><span class="p">(</span><span class="s">"/users"</span><span class="p">,</span> <span class="n">usersRouter</span><span class="p">))</span>

<span class="k">var</span> <span class="n">server</span> <span class="o">=</span> <span class="o">&amp;</span><span class="n">http</span><span class="o">.</span><span class="n">Server</span><span class="p">{</span>
    <span class="n">Addr</span><span class="o">:</span>    <span class="s">":8080"</span><span class="p">,</span>
    <span class="n">Handler</span><span class="o">:</span> <span class="n">middlewareStack</span><span class="p">(</span><span class="n">v1Router</span><span class="p">),</span>
<span class="p">}</span>

<span class="n">fmt</span><span class="o">.</span><span class="n">Println</span><span class="p">(</span><span class="s">"starting server on port 8080"</span><span class="p">)</span>
<span class="n">server</span><span class="o">.</span><span class="n">ListenAndServe</span><span class="p">()</span>



}

// internal/routes/users.go

package routes

import (

    "encoding/json"

    "net/http"

<span class="s">"rest-api/internal/middleware"</span>



)

type User struct {

    Name  string

    Email string

}

func UsersRouter() http.Handler {

    var usersMux = http.NewServeMux()

    usersMux.HandleFunc("GET /", getUsers)

<span class="k">var</span> <span class="n">protectedMux</span> <span class="o">=</span> <span class="n">http</span><span class="o">.</span><span class="n">NewServeMux</span><span class="p">()</span>
<span class="n">protectedMux</span><span class="o">.</span><span class="n">HandleFunc</span><span class="p">(</span><span class="s">"POST /"</span><span class="p">,</span> <span class="n">createUser</span><span class="p">)</span>
<span class="n">usersMux</span><span class="o">.</span><span class="n">Handle</span><span class="p">(</span><span class="s">"/"</span><span class="p">,</span> <span class="n">middleware</span><span class="o">.</span><span class="n">IsAuthenticated</span><span class="p">(</span><span class="n">protectedMux</span><span class="p">))</span>

<span class="k">return</span> <span class="n">usersMux</span>



}

func getUsers(res http.ResponseWriter, _ *http.Request) {

    res.Write([]byte("users list"))

}

func createUser(res http.ResponseWriter, req *http.Request) {

    var newUser User

    var err = json.NewDecoder(req.Body).Decode(&newUser)

<span class="k">if</span> <span class="n">err</span> <span class="o">!=</span> <span class="no">nil</span> <span class="p">{</span>
    <span class="n">res</span><span class="o">.</span><span class="n">WriteHeader</span><span class="p">(</span><span class="n">http</span><span class="o">.</span><span class="n">StatusBadRequest</span><span class="p">)</span>
    <span class="n">res</span><span class="o">.</span><span class="n">Write</span><span class="p">([]</span><span class="kt">byte</span><span class="p">(</span><span class="n">err</span><span class="o">.</span><span class="n">Error</span><span class="p">()))</span>
    <span class="k">return</span>
<span class="p">}</span>
<span class="n">res</span><span class="o">.</span><span class="n">WriteHeader</span><span class="p">(</span><span class="n">http</span><span class="o">.</span><span class="n">StatusCreated</span><span class="p">)</span>
<span class="n">res</span><span class="o">.</span><span class="n">Write</span><span class="p">([]</span><span class="kt">byte</span><span class="p">(</span><span class="s">"new user created, name: "</span> <span class="o">+</span> <span class="n">newUser</span><span class="o">.</span><span class="n">Name</span> <span class="o">+</span> <span class="s">", email: "</span> <span class="o">+</span> <span class="n">newUser</span><span class="o">.</span><span class="n">Email</span><span class="p">))</span>



}

PS

I can achieve the desired behaviour by using the /users prefix in the users.go file instead of the main.go file, but I was wondering if it can be done this way too 🤔

Thanks!

Help - How to run npm builds using docker?

Gaurav Saini — Thu, 17 Aug 2023 18:41:15 +0000

Hello 👋

I want to run npm run build scripts using a Dockerfile/docker-compose.yml file and get the build output on my host file system. Is there any way I can achieve this?

Basically, what I'm looking for is to run a single command, like

docker-compose up

# OR

docker build -t my-builder . && docker run my-builder

# or maybe even a shell script

which would spin up a container, run the npm build script inside the container, and with the help of either a volume or bind mount (or some other concept I'm not aware of 😅) put the build output on a specified directory on the host file system.

Any help would be greatly appreciated 🙏.

Thanks!!

Help: How to watch for changes in local dependencies in monorepo?

Gaurav Saini — Thu, 13 Jul 2023 17:26:22 +0000

Hey folks,

I am currently setting up a monorepo project using pnpm, turborepo, typescript, and nestjs.

The folder structure is like this

└── my-ts-monorepo/
    ├── apps/
    │   └── server
    └── libs/
        └── utils

The utils library is added as a dependency in the server application.
utils is a simple typescript library with some math functions and server is a NestJS REST API.

Everything is working fine except for one thing. While running the dev server, if I make any code changes in the utils library, the changes are not picked up by the server application.

I tried running the tsc build for the utils library with the --watch flag, but no luck there also.

The dev scripts look like this

/* root package.json */
"dev": "turbo run dev"

/* apps/server/package.json */
"dev": "nest start --watch"

/* libs/utils/package.json */
"dev": "tsc --watch"

Please help me so that the NestJS dev server can pick up code changes in the utils dependency also.

Thanks!

How to build microservices with Docker - BONUS!!

Gaurav Saini — Wed, 28 Jun 2023 13:01:42 +0000

Hello there 👋

This is probably the last part in microservices basics series, but certainly not the least. Today we're going to look at how we can scale up individual services and apply load balancing. This will give a major performance boost in high traffic scenarios and increase the up-time of our application.

Without further ado, let's dive in

Spawning multiple containers

First things first, we have to create/spawn multiple containers of the service we want to apply load balancing to. Let's use the Products service for this experiment.

We can make changes to the products service definition in the docker-compose.services.yml file as follows

products:
  extends:
    file: products/docker-compose.yml
    service: app
  env_file: .env
  scale: 3    # new option "scale" to tell docker-compose to spawn 3 containers for this service

And now, when we bring up the services using the command

docker-compose --file docker-compose.services.yml up

we see the logs indicating there are 3 container running for the products service.

Awesome!! we're already halfway there.

Implementing Load Balancing

Remember when I talked about defining server groups in the nginx.conf file. Well, so far we only had one server in the group, so calling it a group didn't make much sense.

But now that we have multiple containers running, in other words, multiple servers running, we can use the server group to its fullest.

upstream products {
  server microservices-shop_products_1:4000;
  server microservices-shop_products_2:4000;
  server microservices-shop_products_3:4000;
}

It is as simple as that! we have achieved load balancing among our 3 products service containers.

And, we have the logs to verify that

These logs ☝️ are generated when we send multiple requests to any /products endpoint.

Since, we've only specified the names of the servers (container names and port numbers), the default algorithm used by Nginx is a Round Robin algorithm.

You can read more about the supported algorithms here.

Wanna see more

Also, if you have any suggestions, improvements, or anything more in general that you'd like to see in this series, please add a comment. I'll try my best to include it here.

Wrap up

I hope you enjoyed this series and learnt something new.

Feel free to post any questions you have in the comments below.

Cheers!

How to build microservices with Docker - The Orchestration

Gaurav Saini — Tue, 27 Jun 2023 16:47:58 +0000

Hello everyone!
So far in this series we have looked at the high level architecture of the app we're building and the code for the 4 services that are part of our simple shop application. And today, we'll look at the docker-compose files for running the full application and send in some requests to see if it goes boom 💥.

Again, the full code is in the Github repo if you want to jump straight to the code.

Let's get started

Before we begin

Okay, so before we start, I'll just quickly explain how I've organized my docker-compose files and why I did what I did.

I saw 2 approaches to writing the compose files:

Putting all the services in a single file.
Logically grouping the services in separate files based on their nature.

In the first approach, as the description suggests, we would have just one docker-compose.yml file and running the application would be super easy. Just do docker-compose up and that's it.
But, I found writing the services a bit cumbersome this way because I had to remember to add the depends_on option in many services definitions in order to avoid any breakdowns due to the services starting before the dependencies are running, or the Nginx Gateway looking for the services and finding nothing.

To avoid adding all the dependencies manually in the compose files, I decided to go with the second approach and execute each file one-by-one in a particular order. You'll see what I mean in a minute.

This way, we just have to ask ourselves one question before writing a service definition

Is the service an application dependency, a setup/pre-requisite thing, or a part of the application code (like the products service or the orders service)

and then, put the service definition in the corresponding docker-compose file.

I personally find this approach much better in the long term from a maintainability POV.

And with that out of the way, let's get started for real this time.

Setup and Pre-requisites

This file is dedicated to any items that we need to take care of even before we start with running the application. Such as setting up the networks, volumes, migrating and seeding databases, etc. I'm creating a network and a volume, like so:



version: '2'

networks:
  shop-intranet:
    driver: default

volumes:
  shop-data:

and then, to run this file



docker-compose --file docker-compose.setup.yml up

Application Dependencies

Any tools/applications that we need to run before starting our main application code should be placed in this file, eg: databases, cache, message brokers, etc.
I'm using this file to start the nats-broker used for relaying messages between the orders and the notifications services.



version: '2'

services:
  nats-broker:
    image: nats:2.9-alpine

and then, to run this file



docker-compose --file docker-compose.deps.yml up

Application Services

This file is for our backend services, that we've written. Here, we'll put all our services that make up the application. A single service definition will look like this:



auth:
  extends:
    file: auth/docker-compose.yml
    service: app
  env_file: .env

and we can also associate the services to the network and volume we created earlier, like this:



auth:
  extends:
    file: auth/docker-compose.yml
    service: app
  env_file: .env
  networks:
    - shop-intranet
  volumes:
    - shop-data:/app

and then, to run this file



docker-compose --file docker-compose.services.yml up

Nginx Gateway

This file contains our Nginx server, and will open up an entrypoint to our application backend from the outside internet.

First, let's look at the nginx.conf file where we put the configuration for our server. Most of the file is a pretty basic Nginx configuration. So, I'll explain the parts specific to our app.

This is how we define a server group.



upstream products {
  server microservices-shop_products_1:4000;
}

A server group is a way to name an address (IP/hostname and port number) so that we can use it later in our remaining configuration. We'll look at how we can use this in a moment.
Here the hostname is the name of the running container and 4000 is the port number inside that container.

We can definer the other server groups for Orders and Products services in the exact same manner.

Then we can define the routing for our services. For that we define a location block. Let's start with the simplest one.



location ^~ /products/ {
  proxy_pass http://products/;
}

Here, /products/ is the path prefix of the incoming requests and in the second line products is the name of the server group we defined earlier. So, this configuration piece means that whatever requests are coming in to /products/<anything>, forward them to the server group named products. The proxy_pass directive is used to forward requests is such a way.
One more thing, before forwarding the request, Nginx will strip the path prefix from the request, so an incoming /products/search request will reach the products service as only /search

Then, we have the orders service server group.



location ^~ /orders/ {
  auth_request /auth/verify;
  proxy_pass http://orders/;
}

The new thing here is auth_request /auth/verify;. This line means that before forwarding the request to the orders server group, check for user authentication using the /auth/verify endpoint. So, Nginx internally makes a request to the auth service, and if the response is 200 OK, then the request is forwarded to the orders service, and if the response is 401 Unauthorized, then Nginx sends also back a 401 to the requester.

Finally, the most difficult one for me was the auth server group



location ^~ /auth/ {
  internal;
  proxy_pass http://auth/;

  proxy_pass_request_body off;
  proxy_set_header Content-Length "";
  proxy_set_header X-Original_URI $request_uri;
  proxy_set_header Authorization $http_authorization;
}

The internal at the start means that this location is accessible by Nginx internally only. If we make any request to /auth/anything, we'll get back a 404 Not Found response.

Then, there's a bunch of gibberish looking stuff. Let's look at the meaning of each line one by one:

proxy_pass_request_body off; - Nginx will remove the request body before forwarding the request.
proxy_set_header Content-Length ""; - Setting the Content-Length header to blank. Since we've removed the request body, there's no point in having a non-zero content length.
proxy_set_header X-Original_URI $request_uri; - Set the X-Original_URI header to $request_uri, which is a variable provided by Nginx and the value is the current request URL. This is to let Nginx know where to forward the request once authentication is successful.
Authorization $http_authorization - Setting the Authorization header, because this is what we have to verify in the auth service.

This is it for the nginx.conf file. Now, moving on to the last piece of the puzzle.

Here's the service definition for the Nginx server.



version: '2'

services:
  nginx:
    image: nginx:1.25-alpine
    ports:
      - 80:80
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro

We're mapping the local port 80 to the port 80 in the Nginx container. And the volumes section is used to replace the /etc/nginx/nginx.conf inside the container with our local nginx.conf file, because that's where Nginx looks for the configuration by default.
The :ro at the end is to make it readonly to prevent any modifications to the local file from inside the container. Simply put, the container can read the file, but cannot make any changes to it.

and then, to run this file



docker-compose --file docker-compose.gateway.yml up

And Voila! 🤌, we have finally managed to run our microservices based application.

Let's make some requests

`GET /products/?ids=`

NOTE: We can skip the ids query parameter to get all the products.



curl http://localhost/products/?ids=2,5

Response:



[
    {
        "id": "2",
        "name": "Half Sleeve Shirt",
        "price": 15,
        "keywords": [
            "shirt",
            "topwear"
        ]
    },
    {
        "id": "5",
        "name": "Sunglasses",
        "price": 25,
        "keywords": [
            "accessories",
            "sunglasses"
        ]
    }
]

`POST /orders/`



curl http://localhost/orders/ \
    --header 'Authorization: secret-auth-token' \
    --header 'Content-Type: application/json' \
    --data '{
        "userId": "saini-g",
        "productIds": ["2", "4"]
    }'

Response:



{
    "productIds": [
        "2",
        "4"
    ],
    "totalAmount": 33,
    "userId": "saini-g",
    "id": 2487
}

Also, we get the logs in the console to verify that everything is running as expected:

That was all for today. It was a long one, so thanks a lot and congratulations to everyone who stuck till the very end.

But wait! I have a small bonus for all you good learners 🤩. But for that you'll have to wait for the next part 😛.

I hope you enjoyed this series and learnt something new.

Feel free to post any questions you have in the comments below.

Cheers!

How to build microservices with Docker - The Services

Gaurav Saini — Mon, 26 Jun 2023 14:01:14 +0000

Hello everyone and welcome back,
Today we'll cover the second part of the microservices application - the code for the individual services.
To quickly recall from the first part, the services we'll build today are:

Products: Used to list and search for products.
Orders: Used to place new orders. This is protected by the auth server so users can't place orders unless they're logged in.
Notifications: Used to notify users when a new order is placed.
Auth: Used to check user authentication before placing orders.

So, without any more delay, let's start

PS: The code here is incomplete, for the full code check out the Github repo

Products Service

This will be a simple Node, Express REST API. There's one GET endpoint to list all products. The code is like:

const express = require('express');
const app = express();

app.get('/', (req, res, next) => {
  const { ids } = req.query;
  let resultProducts = products;

  if (ids) {
    const productIds = ids.split(',');
    resultProducts = products.filter((p) => {
      return productIds.includes(p.id));
    }
  }
  res.status(200).json(resultProducts);
});

You'll notice we have a query parameter named ids. We'll use this to fetch a subset of all the products by their id.

Also, for simplicity, the complete list of products is coming from a local variable here.

Orders Service

This is also a Node, Express REST API, but not quite as simple as the products one. There's still only one POST endpoint, but since it does multiple things, let's look at the code in pieces.

First, we extract the userId and productIds from the request body and use the productIds to fetch more product details (mainly prices and names) from the products service:

const { productIds, userId } = req.body;

const { data: orderedProducts } = await axios.get(
  `${PRODUCTS_APP_HOST}/?ids=${productIds.join(',')}`
);

Then, we calculate the total amount for the order and a comma separated names list of the products:

let totalAmount = 0;
let orderedProductNames = '';

for (const product of orderedProducts) {
  totalAmount += product.price;
  orderedProductNames += orderedProductNames === '' ? product.name : `, ${product.name}`
}

Lastly, we publish a message for the nats-broker (we'll look at the notification service next) and send a response back to the API request. Similar to the products service, there's no database here also, so we just return a plain JSON object with a random id in the response.

natsClient.sendMessage(
  NEW_ORDER_MESSAGING_CHANNEL,
  `Hello ${userId}, your order is confirmed. Products: ${orderedProductNames}`
);

res.status(201).json({
  productIds,
  totalAmount,
  userId,
  id: Math.floor(Math.random() * 9999)
});

Notifications Service

This service is a Nats subscriber, listening for messages published to the "new order placed channel". For now, we just log the incoming messages to the console, but in a real world scenario we can notify users via SMS, Emails, etc.
The code consists of 2 functions, one is the handler for messages and another to start the subscriber.

function handleMessages(err, message) {
  if (err) {
    console.log(`Error while reading messages: ${err}`);
    return;
  }
  console.log(`Message received on channel "${NEW_ORDER_MESSAGING_CHANNEL}"`);
  console.log(message);
}

async function main() {
  await natsClient.startup();
  natsClient.subscribe(NEW_ORDER_MESSAGING_CHANNEL, handleMessages);
}

main().catch(console.log);

The `nats-client` code

This is a common file and can be used by any service who wants to talk to the Nats broker.

const { connect, StringCodec } = require('nats');

const NATS_BROKER_URL = process.env.NATS_BROKER_URL;

class NatsClient {
  #conn;
  #codec;

  constructor() {
    this.#codec = StringCodec();
  }

  async startup() {
    this.#conn = await connect({ servers: NATS_BROKER_URL });
    console.log(`Connected to nats broker on "${this.#conn.getServer()}"`);
  }

  sendMessage(channel, message) {
    this.#conn.publish(
      channel,
      this.#codec.encode(message)
    );
  }

  subscribe(channel, cb) {
    this.#conn.subscribe(channel, {
      callback: (err, payload) => {
        cb(err, this.#codec.decode(payload.data))
      }
    });
    console.log(`Subscribed to messaging channel "${channel}"`);
  }
}

Currently, the orders service uses the sendMessage method and the notifications service uses the subscribe method.

Auth Service

This is again a REST API. But, just to mix things up a bit, it's built in Python using the FastAPI framework. Currently, there's only one endpoint to verify the Authorization header, which checks for a hardcoded token value.

@app.get("/verify")
def verify_token(authorization: Annotated[str | None, Header()] = None):
    if authorization != "secret-auth-token":
        return JSONResponse(
            status_code=status.HTTP_401_UNAUTHORIZED,
            content=None
        )

    return JSONResponse(
        status_code=status.HTTP_200_OK,
        content=None
    )

Wrap up

That was all for the individual services code. In the next part we'll look at the root level docker-compose.yml files and the nginx.conf file to start all the components of the application and make things work.

I hope you'll enjoy this series and learn something new.

Feel free to post any questions you have in the comments below.

Cheers!

How to build microservices with Docker - Introduction

Gaurav Saini — Sun, 25 Jun 2023 09:07:59 +0000

Hello everyone,
Microservices are very popular these days, and rightly so. They offer a lot of flexibility and freedom to the developers. So, I decided to learn them and share my knowledge with you. I hope you know, in theory, what microservices are. If you're not familiar with the concept, this video is an excellent place to start.
I've decided to break my journey into a series of 3-4 posts, and this is the first part.
I'll add everything to Github, so you can check out the repo here.

Overview

Let's start with a brief summary of the entire project that we'll be building. We'll make a simple e-commerce application and the high level design will look like this:

As you can see, there are 4 main services:

Products: Used to list and search for products.
Orders: Used to place new orders. This is protected by the auth server so users can't place orders unless they're logged in.
Notifications: Used to notify users when a new order is placed.
Auth: Used to check user authentication before placing orders.

The other components in the architecture are:

NGINX server: Acts as the API gateway, reverse proxy, and load balancer.
NATS broker: Nats.io is a messaging platform used to build distributed systems. Here we'll use it to facilitate communication between different services by publishing messages.

I'll dive into each individual component in later parts of this series, but I've tried to keep the services as minimal and simple as possible and put the main focus on the organisation and orchestration part of the entire microservices application.
So, you'll notice that the functionality offered by each service is not very sophisticated, but it gets the idea across.

Tech Stack

Node.js
Python
Docker, docker-compose
Nginx

This is it for the introduction. The next part onwards we'll get our hands dirty with the code.
I hope you'll enjoy this series and learn something new.

Feel free to post any questions you have in the comments below.

Cheers!

Who is a good communicator?

Gaurav Saini — Tue, 19 Jul 2022 16:22:20 +0000

I'm sure everyone will agree that good communication skills are very important, and not just in professional life but in every aspect of life. But rarely do I see someone describing what it actually means by good, or even great, communication skills. Often I feel people misunderstand the true meaning of good communication skills.
So I thought maybe I'll share my take on this with you folks. Feel free to share your views in the comments, make corrections in the article, and add what you think I might have missed.

The myth!

Good grammar/vocabulary: Many people I've had the pleasure of dealing with or even work with think that people who have good grammar knowledge or who often use fancy multi-syllable words in their sentences are really good communicators. I always struggle to understand big words until I hear them quite a few times and do multiple google searches for meanings and usage examples. Sure, it's always good to have impeccable grammar and vocabulary if you're in a spelling bee, but not everyone can digest them easily. And to be honest, it's not even that important, as long as people get the point you're trying to make.

Quick responses: Let me say this straightaway - it is important to respond quickly to emails, messages, even if it is just an acknowledgement saying you'll get back to them with an answer. But the belief that people who respond quickly are good at communication is definitely not true. Some even try to show off this skill and enforce it on others around them. Such replies, in most cases, end up being educated guesses at best and don't tend to be very well informed.

Incorrect communication platform: This bothers me the most out of all the points mentioned here. People follow and endorse such bad practices of calling an in-person meeting for the most trivial tasks which could have easily been communicated in a written format. Or sometimes when people talk about a mission critical thing over a phone call, which should definitely have been an email to the whole team, or possibly even a meeting. Imagine going to JSConf and one of the presenters just refuses to talk and has big blocks of text on every slide, not very likeable, right?

I did many mistakes in the past, but I continuously had this feeling bothering me that even the simplest of my conversations (both written and verbal) were missing something. Somehow, I was repeating myself too many times, not getting my point across, or having too many calls to clear up little work items.
I slowly realised what I was doing wrong.

The truth!

While I agree not all points I mentioned above are bad to have if you want to improve your communication skills, but those points alone can never be sufficient. I'll share some points, habits, I think are super important if you want to be a good communicator. This is most definitely not an exhaustive list so feel free to add more points in the comments.

Simplify things. This should be the top priority if you want to convey your message effectively and avoid any misunderstandings or even worse, conflicts. If you can break down a complex concept into simpler terms then you're much more likely to convince make your message easy to understand and remember.
Consider this, if you can't convince a toddler to not put the lego man's head into their mouth for the millionth time, then you need to work on your communication skills. Okay, I get it, your task will not always be so close to impossible because in a professional setting you're not always talking to toddlers, so it's equally important to identify your audience and try to talk on their level, and make it easy for them to understand. Which brings me to the next skill...

Have Empathy. Many times I got frustrated at people for not getting what I was trying to tell or ask them, until I realised that not everyone has the same context as me, or is on the same level of intellect/experience as me. You can try to put yourself in their shoes to better understand why your point is not getting through to them. Who knows, you might even learn a thing or two by doing so. (has happened to me on multiple occasions)
Plus people are more likely to listen closely and be more willing to indulge once they feel you understand their side of things as well.

Being polite is one of those habits that's not easy to cultivate but goes a long way once you do so. If you're impolite or rude as a communicator then all the knowledge and skill in the world won't help your cause, because people won't even listen to you. On the flip side, one way of showing politeness is to listen and not interrupt when others are talking. Listening is a huge part of being a good communicator that many people miss.

Be transparent and proactive. This holds true mostly when you're dealing with someone in a more formal setting. The other person will always appreciate you more if you're transparent with them and let them know of any unforeseen circumstances without them reaching out to you and specifically asking you about it. For example, if you're working with a client on a project and due to some newfound information or an unanticipated issue you have to bump up the story points on a ticket. The clients will be much happier if you proactively inform them about the situation at hand.

These habits and tips have proved very valuable to me in my daily life. People find me easy to trust whenever I commit to something, and I no longer face the problems I mentioned earlier. So that's a win-win for everyone.

Would love to hear your take on this.

Cheers! 🤘

How to be better at new feature planning?

Gaurav Saini — Thu, 23 Jun 2022 14:06:46 +0000

Hey everyone,

TL;DR - Our team is struggling with good technical analysis and planning for new features added into the product, so we need some ideas to help refine our process.

Whenever there's a new feature or a big enhancement to be added into the product, many times we struggle with efficient analysis and planning. This in turn messes up the estimations, and we end up scrambling at the end of sprints either shuffling tickets around or stretching our work hours.

What I've suggested as a good starting point is to have a set of questions written down that cover the basic stuff common to most features or any new work in general. So, for any new feature request coming in from the clients, if we manage to get answers to these questions then at-least we have a good understanding of the LOE that's needed to get the work done, and also ease up the breakdown of big features into smaller tasks.

The clients thoroughly cover the business aspect of the requirements. We need some ideas to get better at the technical side of things. I've felt many times that during planning we are left wondering what should we do during planning, and it all ends up being a wild goose chase. This is the number one problem we want to address.

Also, how much time do you guys usually put into planning a new feature or a module. Eg: if at first glance, something looks like 3-4 days worth of work, than I think it's a good idea to put aside 2-3 hours where we can just brainstorm and think about all the teeny tiny details.

One last question, is it a good idea to have everyone on the team sit down during the planning meeting?

Thanks a lot in advance.

How to use custom express server with Botkit v4 (Slack bot)?

Gaurav Saini — Mon, 30 Nov 2020 11:02:56 +0000

https://stackoverflow.com/questions/65070227/how-to-use-botkit-v4-with-custom-express-server-for-slack-bot

Please help me with the above question

Help needed: Open source react component

Gaurav Saini — Sun, 19 Jul 2020 10:22:50 +0000

Hi fellow DEVs 👋,
A while ago, I created a basic react component, a wrapper for some multi step flows. This was my first ever react component that I wrote in an effort to learn and understand react better.

TL;DR

I ~~want~~ need some help with the functionality where user is allowed to call some custom method/actions (synchronous or asynchronous) before proceeding to the next step, and go to next step/show error based on the user method response.

What is the component about?

It is a dynamic, multi-step progress indicator with navigation buttons to move between steps. Optionally you could have some basic validation when proceeding to the next step.
It has nice little animations and ZERO dependencies (till now).
Excited? Go check it out

What I need help with?

I wanted to allow people to call their own custom methods, either synchronous or asynchronous, before proceeding to the next step. Right now, I have an optional prop to allow for custom validation to be performed, but that is very naive as the validation function must have a return type of boolean, and no error message is shown.
Ideally, I would like someone to help me achieve this but if you'd like to raise a PR that's fine too 😄, I can't seem to plan the whole thing very well

How to get started?

I already have an issue in the Github repo.
Hit me up in the DEV chat or Discord(username: saini-g#3132) if you want.

How else can I help?

Any suggestions, PRs, ideas, help with documentation would also be nice.

Thanks.

React Native android build failure

Gaurav Saini — Sat, 11 Jul 2020 07:03:47 +0000

Hey folks,
I'm struggling with building a react native project for android and need some help.
When I run the build command (./gradlew bundleRelease) from the <project_root>/android directory I get an error (as shown below) saying that I haven't accepted the licenses for the android SDK and I need to do so in order to build the project.

And when (after some googling) I ran the accept licenses command from the SDK root directory, I get another error (as shown below)

It might be worth pointing out that I'm essentially reviving a very old project that I had the source code for, so the Android Studio, Android SDK and everything else is freshly installed on my system.

Thanks in advance for all the help!

Forem: Gaurav Saini

Help needed with subrouting in Go

Hello 👋

My Code

PS

Help - How to run npm builds using docker?

Hello 👋

Help: How to watch for changes in local dependencies in monorepo?

How to build microservices with Docker - BONUS!!

Hello there 👋

Spawning multiple containers

Implementing Load Balancing

Wanna see more

Wrap up

How to build microservices with Docker - The Orchestration

Before we begin

Setup and Pre-requisites

Application Dependencies

Application Services

Nginx Gateway

Let's make some requests

GET /products/?ids=

POST /orders/

How to build microservices with Docker - The Services

Products Service

Orders Service

Notifications Service

The nats-client code

Auth Service

Wrap up

How to build microservices with Docker - Introduction

Overview

Tech Stack

Who is a good communicator?

The myth!

The truth!

How to be better at new feature planning?

How to use custom express server with Botkit v4 (Slack bot)?

Help needed: Open source react component

TL;DR

What is the component about?

What I need help with?

How to get started?

How else can I help?

React Native android build failure

`GET /products/?ids=`

`POST /orders/`

The `nats-client` code