<div class="image-550">
<img src="https://cdn.kahimyang.com/resources-24/go-sockets.avif" alt="Golang sockets" />
</div>
<h3>
Introduction to Sockets
</h3>
<p>
A socket is an endpoint for communication between two machines over a network. It allows data to be sent and received between a client and a server. Sockets can be used with various protocols, but the most common are TCP (Transmission Control Protocol) and UDP (User Datagram Protocol).
</p>
<ul class="k-list">
<li>
<b>TCP</b>: A connection-oriented protocol that ensures reliable, ordered, and error-checked delivery of data.
</li>
<li>
<b>UDP</b>: A connectionless protocol that is faster but does not guarantee delivery, order, or error checking.
</li>
</ul>
<p>
Go's standard library provides excellent support for socket programming through the <b>net</b> package, which includes functions for creating and managing network connections.
</p>

<h3>
TCP Socket Programming in Go
</h3>
<h4>
TCP Server
</h4>
<p>
A TCP server listens for incoming connections from clients and processes their requests. Below is an example of a simple TCP server in Go:
</p>

<pre style="font-size: 90%;">
<code class="language-go normalize-whitespace line-numbers" >
package main

import (
	"bufio"
	"fmt"
	"net"
	"strings"
)

func handleConnection(conn net.Conn) {
	defer conn.Close()

	// Read data from the connection
	reader := bufio.NewReader(conn)
	for {
		message, err := reader.ReadString('\n')
		if err != nil {
			fmt.Println("Error reading:", err)
			return
		}

		// Print the received message
		fmt.Print("Message received:", string(message))

		// Send a response back to the client
		response := strings.ToUpper(message)
		conn.Write([]byte(response + "\n"))
	}
}

func main() {
	// Start listening on port 8080
	listener, err := net.Listen("tcp", ":8080")
	if err != nil {
		fmt.Println("Error listening:", err)
		return
	}
	defer listener.Close()

	fmt.Println("TCP server is listening on port 8080...")

	for {
		// Accept incoming connections
		conn, err := listener.Accept()
		if err != nil {
			fmt.Println("Error accepting connection:", err)
			continue
		}

		// Handle the connection in a new goroutine
		go handleConnection(conn)
	}
}
</code>
</pre>

<p>
How it works:
</p>
<ol class="k-list">
<li>
The server listens on port <b>8080</b> using <b>net.Listen</b>.
</li>
<li>
It accepts incoming connections using <b>listener.Accept</b>.
</li>
<li>
Each connection is handled in a separate goroutine using <b>go handleConnection(conn)</b>.
</li>
<li>
The server reads data from the client, processes it (converts it to uppercase), and sends a response back.
</li>
</ol>


Socket Programming in Golang: The Complete Guide