DEV Community: Mahich123

My system Design Learning

Mahich123 — Wed, 15 Apr 2026 08:09:16 +0000

Poll & Push Strategy: Poll means when client request server for updates (long polling / short polling) . Push means when server sends messages to client (SSE (Server-Sent Events) , WS (Web Sockets) ) .

short polling: short polling is when client periodically sents request to server for updates

Long Polling: It is a technique in which clients http request is held by server until new data becomes available.

Vertical Scaling: Vertical scaling means adding more resources (CPU, RAM, storage, etc.) to a single server or machine to handle increased load.

Example

We start with a server that has 2 CPUs & 4 GB RAM.
When traffic grows, instead of adding more servers, we upgrade it to 8 CPUs & 32 GB RAM.
Same machine, just more powerful.

Horizontal Scaling: Horizontal scaling means adding more servers/machines to our system and distributing the load among them. Instead of making one server stronger (vertical scaling), we add more servers.

Load Balancer: A load balancer is a service which distributes incoming traffic across multiple servers to prevent any single server from becoming overloaded

Cache eviction policies: It is a set of rule that decides which data to remove when cache is full. As cache storage is small we can't keep everything we want .

Proxy: proxy or a forward proxy stays in front of client. when we request a website it goes through proxy first. The proxy then asks the website for data on behalf.

Reverse Proxy: reverse proxy stays in front of our web server. when we visit a site we are not talking to actual database server, we are talking to a reverse proxy that decides which backend server should handle our request

Websocket: Websocket provides bidirectional connection between client & server over single TCP connection.

TCP (Transmission Control Protocol) is way for two devices on a network to talk to each other

In traditional http connction when we sent a request to the server , server reads it and sends back response. After response is delivered the connection gets closed. But in websocket connection we send request to server only once . As long as the line is open both client & server can talk to each other .

Api Gateway: Api gateway is a single entry point that sits between client and backend services.

Idempotency: It means performing the same operation multiple times gives the same result as doing it once.

In API HTTP explicitly defines which methods should be idempotent. For example, GET requests are designed not to modify server state, making them naturally idempotent, no matter how many times we send the same request, the outcome remains the same. That’s why we can refresh a webpage repeatedly without causing unintended side effects.

Middleware & Project structure.

Mahich123 — Thu, 22 Dec 2022 19:09:34 +0000

Middleware:
Middleware is a handler or we can say controller function . We sent request to server and server gives a response. Middleware are thoose functions which appears in the middle of request and response bellow shown the structure of a middleware :

The middleware function looks like ,

(req, res, next) => {
  ....
}

It has access to request and response object also it has next function . When client sents request to server that server sents that request to middleware then middleware gives back that response to client . Middleware runs it functionality to give response. We can write custom middlewares :

const myLogger = function (req, res, next) {
  console.log('LOGGED')
  next()
}

created a middleware called myLogger which just prints LOGGED . We can see there's a next function it basically passes myLogger response to next middleware . In a server it can has multiple middlewares or could be have single . So now we know what is middleware but why we use it.

Why to use middleware:
Middleware are used to add logging and authentication functionality. If we want to record the number request we get we can use middleware.

Project Structure:
When we create projects most of the time we don't look at the structure of project. We just create the project but after some day when we get back to that same projects we may ran into bugs and any other errors at that time it becomes difficult to solve that issue because our project remains unorganized . If we organize our project it becomes easier to get to know that files . Sharing a project structure which feels organized for me you may keep your files in your own way ,

app
config
controller
db
error
lgos
middleware
routes
test
util

.env
.gitignore
server.js

for particular work created separated directory which helps to know the workflow and it becomes easier to debug error.

That's all for today . Thank you for reading !!

Image Search

Mahich123 — Sat, 22 Oct 2022 14:06:13 +0000

Hey Everyone 👋

I'm Mahi.

I'm working on an open-source project called Image Search.
A web-app created by myself and my team to explore and find images for your needs, as well as to offer free downloads with no restrictions and to upload your creativity. This web app is currently being updated, Also not yet finished. We are looking for collaborators on GitHub. You can help us to improve it and make it grow . If you want to contribute, you can look into the repo link given below.

GitHub Repository: https://github.com/Mahich123/Image_Search
Preview Link: https://image-search-tan.vercel.app/

Your small contribution matters .

Java OOP Concepts

Mahich123 — Sat, 20 Nov 2021 09:50:34 +0000

Class in Java

A class is a group of objects which have common properties. It is a template or blueprint from which objects are created.

//Creating Student class.  
class Student{  
 int id;  
 String name;  
}

Static in Java

Static is a keyword. If this keyword is prefixed before the function name, the function is static function. If a method / function is static than it can be access from anywhere.

But if method is not static than it can't be run or accessible. Like below:

public static void main(String[] args) { 
}

here main method is static so it is static method
but in this bellow method :

void calling() { 
}

this one is not static it's a non-static method. So we can't run it. If we want to run a program we have to run through main method and the main method is always static if we remove static from main method than our main method won't run. And as it is static we can't call a non-static method inside a static method like bellow:

public static void main(String[] args) { 
      calling();
}

But we can call or access a static method inside a non-static method like bellow:

static void fun() {

}
void calling() { 
  fun();
}

SO there's a way of calling it inside static method.
By creating object. So we have to create object than we can access no-static method through object like bellow:

public static void main(String[] args) { 
    Main obj = new Main(); // so here i'm creating object for my class .
    obj.calling();        // Here calling it through the object.
} 

void calling() { 

}

So this way we can use non-static method or function.

Function/method Overloading

If I have multiple function/method with same name then it's called method/function overloading , and it should have different arguments a b d.... or type of arguments, and should be different means int or string .... Like bellow:

static void fun(int a) {
      System.out.println();
  }

    static void fun(String a) {
        System.out.println();        
  }

Constructors

In Java, a constructor is a block of codes similar to the method. It is called when an instance of the class is created. Like below:

Public class MyClass {
   Int num;
   MyClass() {
      num = 100;
   }
}

public class ConsDemo {
   public static void main(String args[]) {
      MyClass t1 = new MyClass();
      MyClass t2 = new MyClass();
      System.out.println(t1.num + " " + t2.num);
   }
}

Inheritance

Inheritance in Java is a mechanism in which one object acquires all the properties and behaviors of a parent object. Inheritance represents the IS-A relationship which is also known as a parent-child relationship.

class Employee{  
 float salary=40000;  
} 

class Programmer extends Employee{  
 int bonus=10000;  
 public static void main(String args[]){  
   Programmer p=new Programmer();  
   System.out.println("Programmer salary is:"+p.salary);  
   System.out.println("Bonus of Programmer is:"+p.bonus);  
   }  
}

Here for accessing the value of Employee class we have to use extends keyword in main class or destination class

Types of Inheritance

Single Inheritance :

One class extends another class

Multilevel Inheritance:

One class can inherit from derived class and derived class will become parent for another new class

Multiple Inheritance :

Once class extends more than one class then it's called multiple inheritance. Java does not support multiple inheritance. We can do this in interfaces.

Hierarchical Inheritance:

One class is inherited by multiple classes.

Hybrid Inheritance:

Combination of single and multiple inheritance. Java don't have hybrid inheritance.

Polymorphism

Polymorphism means many ways to represent single entity or item.
Types of Polymorphism :

Compiled time or static.
Runtime or Dynamic.

Overriding

Overriding is a feature that allows a subclass or child class to provide a specific implementation of a method that is already provided by one of its super-classes or parent classes. When a method in a subclass has the same name, same parameters or signature, and same return type(or sub-type) as a method in its super-class, then the method in the subclass is said to override the method in the super-class.

Static methods can't override
Because static method will be called and it doesn't depends on objects so it can't be override
Overriding depends on objects.

Instance Variable

The variables that are declared inside the class but outside the scope of any method are called instance variables in Java.
The instance variable is initialized at the time of the class loading or when an object of the class is created.
An instance variable can be declared using different access modifiers available in Java like default, private, public, and protected.
Overloading and Overriding doesn't applies to instance variables.

Encapsulation

Encapsulation is a process of wrapping code and data together into a single unit.

Advantage of Encapsulation in Java

By providing only a setter or getter method, you can make the class read-only or write-only. In other words, you can skip the getter or setter methods.
It is a way to achieve data hiding in Java because other class will not be able to access the data through the private data members.

//A Java class which is a fully encapsulated class.  
//It has a private data member and getter and setter methods.  
package com.javatpoint;  
public class Student{  
//private data member  
private String name;  
//getter method for name  
public String getName(){  
return name;  
}  
//setter method for name  
public void setName(String name){  
this.name=name  
}  
}

//A Java class to test the encapsulated class.  
package com.javatpoint;  
class Test{  
public static void main(String[] args){  
//creating instance of the encapsulated class  
Student s=new Student();  
//setting value in the name member  
s.setName("hi");  
//getting value of the name member  
System.out.println(s.getName());  
}  
}

Abstraction

Data abstraction is the process of hiding certain details and showing only essential information to the user. Abstraction can be achieved with either abstract classes or interfaces.

Abstract class: is a restricted class that cannot be used to create objects (to access it, it must be inherited from another class).

Abstract method: can only be used in an abstract class, and it does not have a body.

abstract class Animal {
  public abstract void animalSound();
  public void sleep() {
    System.out.println("Zzz");
  }
}

Private

The private keyword is an access modifier used for attributes, methods and constructors, making them only accessible within the declared class.

If we make any class constructor private, we cannot create the instance of that class from outside the class.

Public

The public keyword is an access modifier used for classes, attributes, methods and constructors, making them accessible by any other class.

Protected

The protected keyword is an access modifier used for attributes, methods and constructors, making them accessible in the same package and subclasses.

Rules of modifiers

Here '+' means accessible & 'blank' means not accessible.

Java packages

lang.
io.
util.
applet.
awt.
net.

hashCode()

The hashCode() method is a Java Integer class method which returns the hash code for the given inputs. It basically gives a random number .

Some points of abstract method

In abstract method we can't create static constructor.
We can't create abstract static method.
We can create static method inside abstract class.
If one of the method is abstract then class also needs to be abstract as well. ___

Interface

An interface is a reference type in Java. It is similar to class. It is a collection of abstract methods. A class implements an interface.

Final

The final keyword in java is used to restrict the user.
If you make any variable as final, you cannot change the value of final variable.

Some points for static interface method

Static interface method should always have body.

public interface A {

    static void greeting(){
        System.out.println("I am in A");

    }
}

We have to call it via interface name.

public class Main {
    public static void main(String[] args) {
         // Here we created a object
         Main obj = new Main();
                 // Here we called it via interface name
         A.greeting();
    }
}

Nested Interface

An interface, i.e., declared within another interface or class, is known as a nested interface.

A nested interface declared within an interface must be public.

public class A {
    public interface NestedInterface {
        boolean isodd(int num);
    }
}


class B implements A.NestedInterface {

    @Override
    public boolean isodd(int num) {
        return (num & 1) == 1;
    }

}

A nested interface declared within a class can have any access modifier

These are some OOP concepts. 😀

My Experience at HackNitr 3.0 😄

Mahich123 — Sun, 31 Oct 2021 06:30:30 +0000

First of all if you don't know what is HackNIR 3.0 you can check my other blog bellow:

https://dev.to/mahich123/what-is-hacknitr-30-2enf

So, I attended this hackathon as a beginner. So it started with workshops they conducted live sessions. Through sessions they provided various kinds of things new tech solved issues and many more. Then conducted min-event we played games from there got to know many peoples communicated with them learned from them. We did Bob Ross painting also and my painting was 😅.

So this hackathon was really beginner friendly. Hackathons are fun we get chance to meet new people. Get to know what to they do , And lot's of new thigs.

So at the end it was really amazing day 😀 .

What is HackNitr 3.0 🤔

Mahich123 — Sat, 30 Oct 2021 04:57:41 +0000

HackNITR 3.0 is a hackathon event it's a 3 day event. From 29 to 31 October. It's came with a lot's of things, like many workshops, challenges and mini-events. In workshops they talked about Machine learnings, SAWO SDK, Koii Network, Next.js, Storyblok, UI/UX and lot's of other things. Besides workshops they conducted games ceremony like Smash Karts, type racer, Scribble and other games.

So it's a short summary of this hackathon they have lot's of other challenges.

If you want to know more about them check below:

https://hacknitr.tech/

Vscode in browser 🔥

Mahich123 — Thu, 21 Oct 2021 17:17:42 +0000

All of we used VsCode IDE. And we love it their interface and all other features are awesome. To use it we need to install there application . But not now if you want you can is it in your lovely browser also 😮

So how to do that or how to use it in browser :

just goto : https://vscode.dev/

After opening the link you can see a window as it showing below

For more details you can go through the link below:
https://code.visualstudio.com/blogs/2021/10/20/vscode-dev

so now you can use your IDE in your browser Happy coding 😀