Socket Programming in Java: IP Address, Port Number and Socket

In simple words, networking is usually a way for communication between two processes running in computers. As an example, consider browsing Facebook in Google Chrome. When we run Chrome, it runs as a process in our computer. Similarly, a process keeps running in Facebook's server computer. 

When we type 'Facebook.com' in the browser and press Enter, Chrome sends a message to Facebook's server (via the Internet) asking for the webpage. Facebook's server process responds by sending a webpage back to Chrome and Chrome displays the webpage. 

In this article, we will learn the basic terminology in computer networking. 

IP Address: the Address of a Computer
In real life, if you want to send a message via post office to one of your friends, you must know his address. This address will uniquely identify your friend's location. 

Similarly, for sending to another computer (in this case from Chrome to Facebook's server), we also need the address of the computer that will uniquely identify the computer. This address of a computer is called IP Address of that computer. 

Every computer in a network is assigned a unique number that identifies the computer. This number is called IP Address of that computer. 

An example of IP Address is 157.240.7.35. 

Note that though IP address is a single number, it is expressed as 4 numbers separated by dots so that we can remember easily. Each number represents 1 byte of the actual number. 

(You can see the IP address of your computer. For macOS follow: https://www.wikihow.com/Find-Your-IP-Address-on-a-Mac. For Windows follow: https://support.microsoft.com/en-us/help/15291/windows-find-pc-ip-address )

Port Number: the Address of an End Point
Back to the previous example: there can be many people living in the same address. For example: Miss W Foster and her husband Mr Jonh and their kids may live in the same address. You may want to send the mail to Miss W Foster, not her husband. In this case, we need to specify the name of the recipient Miss W Foster along with the address. 

Similarly, a single computer can run multiple processes. For example: our computer may run both Chrome and Firefox at the same time. So, we need a way to identify Chrome and Firefox in the same computer. 

To solve this problem, the processes in a single computer creates an end point before starting any messaging. Each end point is identified by a number. This number is called port number of that end point. 

Port number is a number that identifies an end point in a single computer. 

An example of port number is 443. 

Socket
As I mentioned previously, before starting messaging, a process have to create a network end point. All the communication is done through these end points. These end points are called sockets. Sockets are like electric sockets: electric sockets are end points of electric network, network sockets are end points of networks. 

Back to the messaging between Chrome and Facebook server, before sending a message to the server, Chrome need to create an end point through which messaging with the server will be done. Similarly, Facebook server process also needs to create an end point before starting any messaging. 

An end point in a network is called a socket. 

Socket is expressed in the following format:

IP-Address:port-number

For example: Facebooks server's socket can be expressed as

157.240.7.35:443

How a Software System Becomes a Mess

We Are Followers

One of my observations is that most of the people in this world are followers. Following others is our innate nature. Children learn to speak following their parents and people around them. People follow their religions blindly only because their ancestors followed them, without raising any question. (I am not against religion. Just mentioned this to justify my observation]

Probably this feature came to us from our ancestors as a result of evolution.  When we do something new, follow a new path, there is always possibility that we will make mistakes, choose a wrong path (that's why whenever I do something new, I know that this might bring something bad to me). Our ancestors probably followed others, because following others is usually the safer than doing something new. So, following others would keep them safe, that's why they developed this nature.

Note that nothing is wrong with following others. Why shouldn't we follow if it keeps us safe?

We programmers are also people. So, most of us are also followers. Following existing code is usually safer option for us and saves much of the effort. Then why not to follow?

How Following Might Lead to Mess?

For a moment let's imagine we can measure the amount of the messiness of a software system. Suppose initially the amount of messiness of our system is 100 units.

Now a new feature comes in. As we love to follow, we usually look at the current system and try to find some similar feature and follow its implementation. For example, suppose in our new we feature we need to display some data in a table and users will be able to change the order of the rows using drag and drop. So, we might look for any existing table that supports drag-dropping and follow it -- we might copy, paste and edit the existing code and add some new code.

As the existing code is also part of the messy system, it might also be messy. Suppose, the messiness of this existing code is 10 units. The newly added code might also be messy. Suppose the messiness of the new code is 5 units. So, after implementing the feature, total amount of messiness added to the system is 10 + 5 = 15 and the total messiness of the system becomes 100 + 15 = 115.

Features keep coming and the system keep getting messier and messier over time. So, the messiness fo the system increases exponentially over time.

How to Prevent Mess?

Let's get back to the previous example. Ideally, we want the messiness of the system to be always zero, that is not mess in the system (I know it's almost impossible, but nothing is wrong if we just use our imagination. This imagination will help understand the real world case). Always means the initial messiness of our system should also be 0.

Suppose, we could somehow make the initial messiness of our system zero. Now a new feature comes in. As usual we will look for  some similar feature and try to follow it (=copy, paste and edit), assuming there is already a similar feature. As the messiness of our system is 0, the messiness of this similar feature should also be 0. Now we add some new code (or edit it). Let's say the messiness of this newly added code is x. So, the total messiness of the system is 0 + (0+x) = x. To make total messiness 0 even after adding the new feature, x must be 0. That means the new code must also be a mess, otherwise the messiness of the whole system will increase.The similar is true if we need to write the feature from scratch.

Note that programmers will learn seeing the code of the system. So, if the initial messiness is 0, there is high probability that x will also be zero as the programmer will learn to write clean code seeing the current code base.

If we can maintain x to be 0, we can ensure that the messiness of the system is always 0. That means the system will always be clean.

Lessons learnt:

• Initial condition of a software system is very important. If we can make the initial system clean, there is higher probability that the software system will remain clean for a long period of time. So, we should try our best to design a clean system. A clean
• We need to teach our programmers to clean code, so that the new code written becomes also clean. We can also review code to ensure that the new code is clean.

[Clean code: I am talking about writing clean code. So, what is meant by "clean code"? which code is clean? In short, clean code means code that can easily be understood just by seeing the code. This term is probably introduced by Robert Martin. So, we should write code that can be understood easily. There are many benefits of writing clean code.

Clean design: roughly speaking, a clean design is a design that can be understood and changed easily. Our requirements are ever changing. So, it's wise to design a system that expects changes.]

What if My System is Already a Mess

If a system is messy, it's not feasible to make the system clean in one sitting, we need time to gradually clean it up. We can follow Boy Scout Rule:

Leave your code better than you found it.

That means when we write new code we will try to make the related old code a little bit cleaner.

Let's go back to our previous example. Suppose, the messiness of our initial system is 1000. Now a new feature comes in. In stead of blindly following previous similar features, we write clean code for this new feature, as a result the messiness of the new code is 0. Then following the rule, we try to make related previous code cleaner. Say this cleaning process reduces the messiness by 20 units. So, the total messiness after implementing the feature = 1000 + 0 - 20 = 980 which is less than what we found before implementing the feature. In this way, the messiness of a feature will reduce over time.