What is a Port Scanner?

A port scanner is a tool that probes a target machine for open ports. Each open port could represent a running service, like SSH (22), HTTP (80), or custom applications. Port scanning is essential for network diagnostics and is foundational in security assessments.

Why Go for Port Scanning?

Go (or Golang) offers unique advantages for this task:

• Goroutines enable lightweight concurrent execution.

• Channels and WaitGroups help coordinate parallel tasks with ease.

• Robust networking support built into the standard library.

These features allow us to write highly scalable port scanners with minimal code.

Breaking Down the Port Scanner

Let's examine the most important parts and why they matter.

1. Project Structure

• main.go: Entry point. Sets up flags, concurrency, and result reporting.

• scanner/scanner.go: Contains the scanning logic.

2. Command-Line Flags

The user can specify a target host via the -host flag (defaults to localhost). The scanner covers the entire range of possible TCP ports (1 to 65535), but you could easily extend this.

gohost := flag.String("host", "localhost", "Target host to scan")
flag.Parse()

3. Concurrency with Goroutines and WaitGroups

The heart of the scanner is a loop that kicks off a goroutine ("lightweight thread") for each port. All goroutines share a common WaitGroup for graceful shutdown and a channel to report results.

gofor port := startPort; port <= endPort; port++ {
    wg.Add(1)
    go func(p int) {
        ps.CheckPort(p, openPorts, &wg)
    }(port)
}

4. The Port Checking Logic

Under the hood, CheckPort tries to open a TCP connection to the target host and port.

goaddress := net.JoinHostPort(ps.Host, strconv.Itoa(port))
conn, err := net.DialTimeout("tcp", address, 1*time.Second)
if err == nil {
    conn.Close()
    ch <- port // Report open ports over the channel
}

A timeout ensures the scanner doesn’t hang on unresponsive ports.

5. Collecting Results Asynchronously

As each scanner goroutine discovers open ports, it sends the port number to the main goroutine via a channel. The main code reads from this channel and prints results as they come:

gofor port := range openPorts {
    fmt.Printf("Port %d is open\n", port)
}

The result: you see open ports displayed live as they’re found, even while other scans continue in the background.

Why This Pattern Rocks

• High Performance: Thanks to Go’s concurrency primitives, you can scan all 65,535 ports very quickly (although in practice, for network friendliness, you may want to limit concurrency in real-world use).

• Simplicity: The code is short, clear, and idiomatic; robust error handling and CLI parsing are easy to add.

• Extensible: You can easily add features like custom port ranges, configurable timeouts, or service banner grabbing.

Possible Enhancements

• Limit concurrent goroutines to avoid overwhelming the host or your own machine.

• Support for port ranges or port list input instead of always scanning all ports.

• Add result output in formats like JSON or CSV.

• Try UDP scanning by using "udp" with net.DialTimeout.

• Include verbose logging for closed/filtered ports, if desired.

Final Thoughts

This simple scanner highlights Go’s power for network programming. With just a couple dozen lines, we get a highly concurrent, responsive tool that’s a great starting point for anyone looking to learn about sockets, protocols, or Go’s concurrency story.

Try extending the code—experiment with new features, or run it against test servers in your environment!

Sample Usage:

bashgo run main.go -host example.com

You’ll see output like:

textPort 22 is open
Port 80 is open
Port 443 is open

Happy scanning—use responsibly

HTTP is stateless protocol runs on the top of TCP which is a connection-oriented protocol it guarantees the delivery of data packet transfer using the three-way handshaking methods and re-transmit the lost packets.

Consider a Situation, Where You want to implement a chat system Every time someone sends a message a Web Hook(A external or internal service which checks incoming requests and Pings the receiver about its existence ) is fired from sender and that makes Request to receiver to Render the whole component again to get a new message, What web sockets is achieving is Direct communication between two Parties, The issue in first approach is we are building connection every time we want to send a message by sent. And in the second one we just keeping connection alive and sending, receiving messages as we they are sent

Web Socket is bidirectional, a full-duplex protocol that is used in the same scenario of client-server communication, unlike HTTP it starts from ws:// or wss://. It is a stateful protocol, which means the connection between client and server will keep alive until it is terminated by either party (client or server). after closing the connection by either of the client and server, the connection is terminated from both the end.

So far you might think, The Problems is solved we are using Sockets, But that's not the case Sockets are a great concept in themselves, It turns out that sockets themselves are not enough to get things done. What we do instead is use a combination of Http Polling and Sockets to get best results, This approach is used in Sockets.io Which is a very popular library to achieve Realtime communication

Http Polling is a process where client sends a request and the server hangs on to the particular request until there is a new data to be sent

Socket.io needs a server side installation and a client side installation to work.

All events are defined in server side and client side sends and receives data from socket server as the communication happens

You can read more about socket.io works here

https://socket.io/docs/v4/how-it-works

You can follow these Blogs get yourself started in Sokets

https://socket.io/get-started/chat

https://medium.com/swlh/chat-rooms-with-socket-io-25e9d1a05947

Map

The map() method creates a new array populated with the results of calling a provided function on every element in the calling array.

Syntax

var new_array = arr.map(function callback(element, index, array) {
    // Return value for new_array
}[, thisArg])

In the above example, Element is the value of element at that particular Index, Element refers the postion in array, Array is the copy of original array which could be used as a conditional for the upcoming render or the returned array.

In the callback, only the array element is required. Usually some action is performed on the value and then a new value is returned.

Example In the following example, each number in an array is doubled.

const numbers = [1, 2, 3, 4];
const doubled = numbers.map(item => item * 2);
console.log(doubled); // [2, 4, 6, 8]

The below example involves uses of all the arguments for Better understanding.

const oldArray = [16, 9, 4, 1];

const newArray = oldArray.map((val, index, arr) => {
  let nextItem = index + 1 < arr.length ? arr[index + 1] : 0
  return val - nextItem;
});

// newArray = [7, 5, 3, 1]

Filter

The filter() method creates a new array with all elements that pass the test implemented by the provided function.

Syntax

var new_array = arr.filter(function callback(element, index, array) {
    // Return true or false
}[, thisArg])

The syntax for filter is similar to map, except the callback function should return true to keep the element, or false otherwise. In the callback, only the element is required.

Examples In the following example, odd numbers are "filtered" out, leaving only even numbers.

const numbers = [1, 2, 3, 4];
const evens = numbers.filter(item => item % 2 === 0);
console.log(evens); // [2, 4]
In the next example, filter() is used to get all the students whose grades are greater than or equal to 90.

const students = [
  { name: 'Quincy', grade: 96 },
  { name: 'Jason', grade: 84 },
  { name: 'Alexis', grade: 100 },
  { name: 'Sam', grade: 65 },
  { name: 'Katie', grade: 90 }
];
const studentGrades = students.filter(student => student.grade >= 90);
return studentGrades; // [ { name: 'Quincy', grade: 96 }, { name: 'Alexis', grade: 100 }, { name: 'Katie', grade: 90 } ]

Reduce

The reduce() method executes a user-supplied “reducer” callback function on each element of the array, passing in the return value from the calculation on the preceding element. The final result of running the reducer across all elements of the array is a single value.

The reduce() method reduces an array of values down to just one value. To get the output value, it runs a reducer function on each element of the array.

Syntax

arr.reduce(callback, [initialValue])

function callbackFn(previousValue, currentValue, currentIndex, array){ ... }

The callback argument is a function that will be called once for every item in the array. This function takes four arguments, but often only the first two are used.

accumulator - the returned value of the previous iteration currentValue - the current item in the array index - the index of the current item array - the original array on which reduce was called The initialValue argument is optional. If provided, it will be used as the initial accumulator value in the first call to the callback function. Examples The following example adds every number together in an array of numbers.

const numbers = [1, 2, 3, 4];
const sum = numbers.reduce(function (result, item) {
  return result + item;
}, 0);
console.log(sum); // 10

In the next example, reduce() is used to transform an array of strings into a single object that shows how many times each string appears in the array. Notice this call to reduce passes an empty object {} as the initialValue parameter. This will be used as the initial value of the accumulator (the first argument) passed to the callback function.

var pets = ['dog', 'chicken', 'cat', 'dog', 'chicken', 'duck', 'rabbit'];

var petCounts = pets.reduce(function(obj, pet){
    if (!obj[pet]) {
        obj[pet] = 1;
    } else {
        obj[pet]++;
    }
    return obj;
}, {});

console.log(petCounts); 

/*
Output:
 { 
    dog: 2, 
    chicken: 2, 
    cat: 1,
    duck: 1, 
    rabbit: 1 
 }
 */

Refrences:

https://developer.mozilla.org/

https://www.freecodecamp.org/

https://www.youtube.com/watch?v=zdp0zrpKzIE

Thanks for Reading!

##According to definition

Git merge will combine multiple sequences of commits into one unified history. In the most frequent use cases, git merge is used to combine two branches. The following examples in this document will focus on this branch merging pattern. In these scenarios, git merge takes two commit pointers, usually the branch tips, and will find a common base commit between them. Once Git finds a common base commit it will create a new "merge commit" that combines the changes of each queued merge commit sequence.

In the above image we can see that there is a Common base between the Two Points we want to Merge, What happens here is Git Diffs Both the Branches Against there Common Ancestor and Calculates Changes based on it.

Types Of Merges

1. Fast Forward Merge.

   It occurs when there's a direct path between the current branch tip and the Current Tip. It Basically merges the history of Both the Tips.

   

2. 3 way merge

   This Happens when there's no direct path between the Main and Current Branch. The Name comes from the Fact that git uses three commits to get make the merge commit it combines the source, feature and common base to come to a new merged commit .

In a three way there could conflicts to files changes in the both the Tips

Conflict Resolution

To resolve them what we need to do is change the files and Use the Command

Git Add

and then

GIt Commit -m "SomeThing here"

To get the Tips Merges

and it will create the Merged Branch.

Various Commands that can help in resolution of conflicts.

git log —merge

It helps in producing the list of command that are causing the conflicts

git Diff

It helps in finding the difference between files between two States

Git merge —abort

It helps by ending the merge process returns the repo into the original state as it was before merging happened.

That Sums up how merging Works Across Branches.

Credits