Add content to game developer roadmap (#8415)

* Improve coroutine content with resources

* Improve flow-control content with resources

* Improve congestion control content with resources

* Improve reliable transmission content with resources

* Improve error detection content with resources

* Improve channel content with resources

* Improve max-segment-size content with resources

* Improve max-segment-size content with resources

src/data/roadmaps/server-side-game-developer/content/channel@SXOEMkcVYBsRza6BPmmwy.md

@@ -0,0 +1,17 @@
+# Channel 
+
+A **channel** is a synchronization primitive used to communicate between concurrent tasks or 
+threads, particularly in asynchronous programming. In server-side game development, channels 
+are frequently used to manage data flow between different components, such as game logic, 
+network communication, and I/O operations. `Channels` provide a thread-safe way to pass messages 
+or data between coroutines or threads without the need for complex locks, reducing the chances 
+of race conditions. This makes them ideal for handling tasks like event propagation, message 
+passing, or coordinating actions in multiplayer game servers. `Channels` often work in 
+conjunction with futures and promises to efficiently manage concurrency and improve overall 
+game performance.
+
+Visit the following resources to learn more:
+
+- [@documentation@Go Channel Documentation](https://golang.org/doc/effective_go.html#channels)  
+- [@documentation@Rust Channels for Concurrency](https://doc.rust-lang.org/book/ch16-02-message-passing.html)
+- [@article@Comprehensive Guide to Channel](https://elixir-lang.org/getting-started/processes.html#using-processes-and-messages)  

src/data/roadmaps/server-side-game-developer/content/congestion-control@1GML0Jsfdb1Fn-0PNryiQ.md

@@ -0,0 +1,15 @@
+# Congestion Control  
+
+**Congestion control** is a fundamental mechanism in `TCP` that prevents excessive data 
+transmission from overwhelming the network, ensuring stable and efficient communication. 
+In server-side game development, congestion control helps maintain smooth gameplay by 
+dynamically adjusting the data flow based on network conditions. `TCP` employs various 
+congestion control algorithms, such as `Reno`, `CUBIC`, and `BBR`, to detect congestion and 
+reduce packet loss. These algorithms regulate the senders transmission rate using strategies 
+like slow start, congestion avoidance, and fast recovery. Proper tuning of congestion control 
+mechanisms is critical for minimizing lag, preventing packet drops, and optimizing multiplayer
+game performance, especially in high-traffic scenarios.  
+
+Visit the following resources to learn more:
+
+- [@article@Congestion Control in Linux TCP](https://www.usenix.org/conference/2002-usenix-annual-technical-conference/congestion-control-linux-tcp)

src/data/roadmaps/server-side-game-developer/content/coroutine@o0Y_hM0KXUApfsXG4PvOY.md

@@ -0,0 +1,13 @@
+# Coroutine  
+
+**Coroutines** are lightweight, cooperative multitasking constructs that enable efficient asynchronous programming in server-side game 
+development. Unlike traditional threads, coroutines allow functions to be paused and resumed without blocking the entire execution 
+thread, making them ideal for handling game logic, networking, and AI behavior with minimal overhead. They work seamlessly with 
+future & promise mechanisms, simplifying concurrency management by avoiding callback hell and reducing synchronization complexity. 
+Coroutines are widely supported in modern languages like C++ (via `std::coroutine`), Python (`asyncio`), and Kotlin, offering game 
+developers an efficient way to write non-blocking code while maintaining readability and performance.  
+
+Visit the following resources to learn more:
+
+- [@documentation@C++ Coroutines (cppreference)](https://en.cppreference.com/w/cpp/language/coroutines)
+- [@documentation@Python Coroutines and Tasks](https://docs.python.org/3/library/asyncio-task.html)

src/data/roadmaps/server-side-game-developer/content/error-detection@vFM311xSa5OqNVove2f6j.md

@@ -0,0 +1,14 @@
+# Error Detection  
+
+**Error detection** ensures data integrity in `TCP-based` communication, preventing corrupted 
+or altered packets from disrupting server-side game interactions. `TCP` uses checksums to verify
+data integrity, detecting bit errors during transmission. If an error is found, the corrupted 
+packet is discarded, and retransmission is requested via acknowledgments (ACKs). Additional 
+mechanisms such as cyclic redundancy check (CRC) and parity checks may be used in lower 
+network layers to enhance reliability. Effective error detection minimizes data corruption 
+in multiplayer games, ensuring smooth gameplay and synchronization across players.
+
+Visit the following resources to learn more:
+
+- [@article@Error Detection Code – Checksum](https://www.geeksforgeeks.org/error-detection-code-checksum/)  
+- [@article@Error Control in TCP](https://www.cisco.com/c/en/us/support/docs/ip/tcp/13733-40.html)

src/data/roadmaps/server-side-game-developer/content/flow-control@lDVD-3i64Mk7-KPJrXmFH.md

@@ -0,0 +1,17 @@
+# Flow Control
+
+**Flow control** is a crucial mechanism in `TCP` that regulates data transmission between a sender 
+and a receiver to prevent network congestion and packet loss. In server-side game development,
+effective flow control ensures smooth data transfer, reducing latency and improving real-time 
+responsiveness for multiplayer games. `TCP` uses techniques like sliding window protocols, where 
+the receiver dictates how much data it can handle at a time, preventing buffer overflows. 
+Additionally, congestion control algorithms like `TCP Reno` and `CUBIC` help dynamically adjust 
+transmission rates based on network conditions. Proper flow control tuning is essential for 
+maintaining stable connections, minimizing lag, and optimizing server performance in 
+high-traffic gaming environments.  
+
+Visit the following resources to learn more:
+
+- [@article@How Flow Control is Achieved in TCP?](https://datatracker.ietf.org/doc/html/rfc5681)  
+- [@article@Flow Control vs. Congestion Control in TCP](https://www.baeldung.com/cs/tcp-flow-control-vs-congestion-control)
+- [@article@TCP Flow Control](https://www.sanfoundry.com/computer-network-tcp-flow-control/)

src/data/roadmaps/server-side-game-developer/content/max-segment-size@w6ysmcsBn9jJ8xMvg7hcD.md

@@ -1 +1,18 @@
-# Max Segment Size
+# Max Segment Size (MSS)  
+
+**Max Segment Size (MSS)** is a crucial concept in `TCP` networking, representing the largest 
+amount of data that can be sent in a single `TCP` segment, excluding the `TCP` header. `MSS` is 
+vital for optimizing performance in server-side game development, as it helps to avoid 
+fragmentation and ensures that data is transmitted efficiently over the network. By adjusting 
+the `MSS`, game servers can minimize packet fragmentation, which can lead to increased latency 
+and reduced throughput. Typically, `MSS` is determined during the `TCP` handshake based on the 
+maximum transmission unit (MTU) of the network, and it can be configured to suit the needs of 
+specific applications or networks. Optimizing `MSS` can improve the overall reliability and 
+performance of data transfers, especially in multiplayer games where real-time communication 
+and high throughput are essential.
+
+Visit the following resources to learn more:
+
+- [@article@RFC 879 - Maximum Segment Size](https://tools.ietf.org/html/rfc879)  
+- [@article@What is MSS (maximum segment size)?](https://www.cloudflare.com/learning/network-layer/what-is-mss/)  
+- [@documentation@TCP Maximum Segment Size tuning](https://www.ibm.com/docs/en/aix/7.2?topic=tuning-tcp-maximum-segment-size)

src/data/roadmaps/server-side-game-developer/content/reliable-transmission@X2KHWgQZDHSVDsTRMUwSj.md

@@ -0,0 +1,15 @@
+# Reliable Transmission  
+
+**Reliable transmission** ensures that data sent over a network reaches its destination 
+accurately and in the correct order, a critical requirement for server-side game development. 
+`TCP` achieves this through mechanisms like acknowledgments (ACKs), sequence numbers, and 
+retransmission strategies. When a packet is lost or corrupted, `TCP` retransmits it using 
+algorithms such as automatic repeat request (ARQ) and fast retransmit. Additionally, flow 
+control and congestion control work together to prevent data loss due to network congestion. 
+Reliable transmission is essential for maintaining synchronization in multiplayer games, 
+preventing desynchronization issues, and ensuring a smooth gaming experience.  
+
+Visit the following resources to learn more:
+
+- [@article@Reliable Transmission](https://book.systemsapproach.org/direct/reliable.html)
+- [@article@TCP Reliable Transmission (IETF RFC 793)](https://datatracker.ietf.org/doc/html/rfc793)