DEV Community: Rahul Dwivedi

What is a network socket?

Rahul Dwivedi — Sat, 16 May 2020 07:44:59 +0000

This article explains the network socket in an easy way

Definition

A socket is one endpoint of a two-way communication link between two programs running on the network. A socket is bound to a port number so that the TCP layer can identify the application that data is destined to be sent to. An endpoint is a combination of an IP address and a port number.

The definition explains socket in basic terms but to get a crystal clear picture of it, let's understand this with the help of an analogy.

Think you are in your house due to lock down and you are prohibited to go out of your house, Let's build on this. one day since you were super bored you decided to have a chat with your neighbor, we will assume your house has a window. ( No! you don't jump from it).
In order to have a chit chat with your neighbor you go to the window and wave hello. Luckily, your neighbor is standing right on the window and he has his window open. he waves back and you guys start communication.

Let's compare it with our definition of network sockets

Here, House is analogous to a computer.
The window we are talking about is like a socket, an endpoint from where you can send messages or receive one
the conversation you are having is data.

A socket is one endpoint of a two-way communication link between two programs running on the network.

Like in our example windows are endpoints. if we close the windows or don't have windows, then we won't be able to transfer our messages. (oh please! you are not allowed to call.)

So I think this gives us a pretty clear picture of what a network socket is. Let's move on to the other parts.

A socket is bound to a port number so that the Network layer can identify the application that data is destined to.

Let's also assume that the house has 6 rooms and there are 6 family members one in each room. All the rooms have a window and a number (1 to 6). Now if a neighbor wants to talk to one of the family members they will have to specify room number as well.

Similarly, on a computer, there can be many applications running. Each socket must be attached to a port ( which will represent the application ). This way Network layer knows where to send incoming data to.

An endpoint is a combination of an IP address and a port number.

With the help of port, we only know which application to send data to, but in a network, there could be many computers hence we need an address to uniquely identify the host we want to talk to.

In our analogy, there could be many houses. In order to talk to someone, you need their house address and the window number you want to talk to.

What is an IP Address?

An IP address is an address assigned to each device within a network to be able to uniquely identify it. It can be of the form 172.16.254.1 in IPv4, and 2001:db8:0:1234:0:567:8:1 in IPv6. you can read more here

What is IP?

IP refers to internet protocol. It is a set of rules that dictates how the communications should happen in a network.

Let's look at the whole flow step by step.

Your application can listen to the messages or send messages to or from the network by creating a socket.
In order to create a socket, we need to bind it to a port.
Someone in a network wants to communicate. They need an IP address ( to uniquely identify our device) and a port number( the port we have bound our socket to or basically where the application is listening ).
They send a message to us. The network first recognizes the IP and tries to find the device from it. it sends the message to the device.
The device has a network layer that looks at the incoming messages from the internet. It receives the messages and parses the port number and passes it to that socket.
The socket receives the message and the application which created the socket, now has access to the message and everyone is happy.

The flow depicted here is an ideal flow. There are many other protocols involved like how the message will be packed and how they will be routed. How will the sender know if the package is received or is lost somewhere in between? For now, let's look at TCP or UDP.

TCP and UDP

Once we receive messages there has to be a way to pass them to the application. We have another layer that sits in between the application and the network layer which is called the transport layer. It is referred to as the transport layer because it handles how the packages will be sent to the application from the network layer and vice versa. This is required because at a point there could be multiple sockets open and a lot of data that the device must be receiving. Its job is to collect all the packets meant for sockets and transfer them respectively.

There are two basic protocols for this:

TCP: Transmission Control Protocol is a connection-oriented protocol i.e it ensures that a proper connection exists before the communication can begin. Think of it as you want to talk to the neighbor but you will only start a conversation once you are sure they are able to listen.

UDP: User Datagram Protocol is a connectionless protocol that does not care for a proper connection which makes it fast but less reliable. For example, you might have experienced game lags that because some of the messages were lost. Most Real-time communication and VoIP are done through UDP.

Now since there are two types of protocols you also must specify which protocol you want to use that why the socket you will create will either be a UDP socket or a TCP socket ( I am lying there are more!!). basically a listening socket looks like

(Please do not try to hack my pc).

Here we can see the protocol in the first column and the port along with IP in the 4th column.

I think by now you would have got a clear idea about network sockets and other basic concepts. we have just scratched the surface there is a lot you can know. I would encourage you to read more about the TCP/IP model and the OSI model. Learning about TCP and IP in detail once.

Feel free to ask any questions or in case you want to have any discussion do comment below.

Dependency Injection an Introduction

Rahul Dwivedi — Tue, 05 May 2020 18:44:57 +0000

In this article, we are going to discuss Dependency injection. We will also learn what are the benefits of using dependency injection.

Introduction

Dependency injection a type of design pattern that allows classes to receive dependencies rather than creating them on their own.

What is a Dependency?

A Dependency refers to any object that a class needs in order to be fully functional. An example would be, suppose a car manufacturer produces a car. For this example, suppose the car manufacturer produces everything needed to manufacture car other than the tyres. For tyres, It depends on some other company. Without tyres, the car is incomplete. Tyres here are a dependency for the car.

We have now a clear idea of what dependency is. Let's look at this through some code.

Suppose you have class that depends on some other object for its execution. Lets looks at the following example

class ChocolateCone{
    GetCone(): string {
        return "Chocolate cone";
    }    
}

class IceCreamParlour{
    cone: ChocolateCone;
    constructor(){
        this.cone = new ChocolateCone();
    }    
    Buy(flavour: string){
        return  `Icecream with a scoop of ${flavour} and ${this.cone.getCone()}` ;
    }
}

const icecreamParlour = new IceCreamParlour();
icecreamParlour.buy("strawberry"); //Icecream with a scoop of strawberry and Chocolate cone.

Let's look at the above code.

We have a class ChocolateCone that gives us Chocolate cone.
We have an ice cream parlour that gives icecreams 😋. Here you can see it Depends on the ChocolateCone class for providing cones for the ice cream.
In order to buy ice cream, we create an IceCreamParlor object and then call the Buy method on it and we get our Strawberry ice cream with a chocolate cone.

This class works well for this specific scenario but let's suppose, we don't want chocolate cones, we want waffle cones, we realize that there is a problem. IceCreamParlour is tightly coupled with ChocolateCone. To get a waffle cone, we will have to change the constructor and create a waffle cone instead of Chocolate Cone.

    ...
        constructor(){
            this.cone = new WaffleCone();
        }
    ...

As we can see this won't be ideal scenario to start modifying the code everytime dependency requirement changes.

This is where Dependency injection comes into play.

Dependency Injection

Since we have understood the problem, let's look at how we can use Dependency injection to solve this.
Dependency Injection states
If we change the constructor of our parlour class and supply the dependencies to it rather than letting it create itself, we can overcome this problem.

interface ICone {
    GetCone():string;
}
class IceCreamParlour{
    cone: ICone;
    constructor(cone:ICone){
        this.cone = cone;
    }    
    Buy(flavour: string){
        return  `Icecream with a scoop of ${flavour} and ${this.cone.GetCone()}` ;
    }
}

Here, the IceCreamParlour expects a cone and does not creates it itself. This is how we have resolved the problem. Whatever cone we want we can supply it to IceCreamParlour at the time of object creation.

class ChocolateCone implements ICone{
    GetCone():string{
        return "Chocolate cone";
    }
}
class WaffleCone implements ICone { 
    GetCone():string{
        return "Waffle cone";
    }
}

const waffleParlour = new IceCreamParlour( new WaffleCone() );
waffleParlour.buy("strawberry"); // Icecream with a scoop of strawberry and Waffle cone;

const chocolateParlour = new IcecreamParlour(new ChocolateCone())
chocolateParlour.Buy("vanilla") // Icecream with a scoop of Chocolate Cone.

When we are creating an object of the class, we are injecting the dependencies into the object. The class does not have to worry about it. If you observe, we have taken control of creating dependency from the class. This is also called Inversion of Control. The class does not have control over the creation of the object. It just specifies in constructor its dependencies and at the time of creating class instance dependency is created and served to it.

Some Benefits of using DI

Helps in reusability and readability.
Solves the problem of tight coupling, produces loosely coupled code.
Helps in writing Unit tests or mocking behaviours.

With this, you have a clear idea of what Dependency injection and how you can use it to create decoupled and reusable classes. It is also mentioned in S.O.L.I.D principles, the D stands for DIP - Dependency inversion Principle.

Most of the time you will end up using a DI container. You can easily find a dependency injection container according to your language preference if you want to use this principle in your projects. One such DI container is tsyringe for Typescript projects.