From a2018556cd8f6fc7fb321dbb9309adf4fbbd27d7 Mon Sep 17 00:00:00 2001 From: Jawher Kl Date: Wed, 26 Mar 2025 16:15:30 +0100 Subject: [PATCH] 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 --- .../content/channel@SXOEMkcVYBsRza6BPmmwy.md | 17 +++++++++++++++++ ...ongestion-control@1GML0Jsfdb1Fn-0PNryiQ.md | 15 +++++++++++++++ .../coroutine@o0Y_hM0KXUApfsXG4PvOY.md | 13 +++++++++++++ .../error-detection@vFM311xSa5OqNVove2f6j.md | 14 ++++++++++++++ .../flow-control@lDVD-3i64Mk7-KPJrXmFH.md | 17 +++++++++++++++++ .../max-segment-size@w6ysmcsBn9jJ8xMvg7hcD.md | 19 ++++++++++++++++++- ...able-transmission@X2KHWgQZDHSVDsTRMUwSj.md | 15 +++++++++++++++ 7 files changed, 109 insertions(+), 1 deletion(-) diff --git a/src/data/roadmaps/server-side-game-developer/content/channel@SXOEMkcVYBsRza6BPmmwy.md b/src/data/roadmaps/server-side-game-developer/content/channel@SXOEMkcVYBsRza6BPmmwy.md index e69de29bb..c545b59e1 100644 --- a/src/data/roadmaps/server-side-game-developer/content/channel@SXOEMkcVYBsRza6BPmmwy.md +++ b/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) \ No newline at end of file diff --git a/src/data/roadmaps/server-side-game-developer/content/congestion-control@1GML0Jsfdb1Fn-0PNryiQ.md b/src/data/roadmaps/server-side-game-developer/content/congestion-control@1GML0Jsfdb1Fn-0PNryiQ.md index e69de29bb..447c6cf62 100644 --- a/src/data/roadmaps/server-side-game-developer/content/congestion-control@1GML0Jsfdb1Fn-0PNryiQ.md +++ b/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) \ No newline at end of file diff --git a/src/data/roadmaps/server-side-game-developer/content/coroutine@o0Y_hM0KXUApfsXG4PvOY.md b/src/data/roadmaps/server-side-game-developer/content/coroutine@o0Y_hM0KXUApfsXG4PvOY.md index e69de29bb..0070eef8b 100644 --- a/src/data/roadmaps/server-side-game-developer/content/coroutine@o0Y_hM0KXUApfsXG4PvOY.md +++ b/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) diff --git a/src/data/roadmaps/server-side-game-developer/content/error-detection@vFM311xSa5OqNVove2f6j.md b/src/data/roadmaps/server-side-game-developer/content/error-detection@vFM311xSa5OqNVove2f6j.md index e69de29bb..8fe6bb808 100644 --- a/src/data/roadmaps/server-side-game-developer/content/error-detection@vFM311xSa5OqNVove2f6j.md +++ b/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) \ No newline at end of file diff --git a/src/data/roadmaps/server-side-game-developer/content/flow-control@lDVD-3i64Mk7-KPJrXmFH.md b/src/data/roadmaps/server-side-game-developer/content/flow-control@lDVD-3i64Mk7-KPJrXmFH.md index e69de29bb..31183611a 100644 --- a/src/data/roadmaps/server-side-game-developer/content/flow-control@lDVD-3i64Mk7-KPJrXmFH.md +++ b/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/) \ No newline at end of file diff --git a/src/data/roadmaps/server-side-game-developer/content/max-segment-size@w6ysmcsBn9jJ8xMvg7hcD.md b/src/data/roadmaps/server-side-game-developer/content/max-segment-size@w6ysmcsBn9jJ8xMvg7hcD.md index d938409cd..51aacccd3 100644 --- a/src/data/roadmaps/server-side-game-developer/content/max-segment-size@w6ysmcsBn9jJ8xMvg7hcD.md +++ b/src/data/roadmaps/server-side-game-developer/content/max-segment-size@w6ysmcsBn9jJ8xMvg7hcD.md @@ -1 +1,18 @@ -# Max Segment Size \ No newline at end of file +# 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) \ No newline at end of file diff --git a/src/data/roadmaps/server-side-game-developer/content/reliable-transmission@X2KHWgQZDHSVDsTRMUwSj.md b/src/data/roadmaps/server-side-game-developer/content/reliable-transmission@X2KHWgQZDHSVDsTRMUwSj.md index e69de29bb..64ea3172a 100644 --- a/src/data/roadmaps/server-side-game-developer/content/reliable-transmission@X2KHWgQZDHSVDsTRMUwSj.md +++ b/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) \ No newline at end of file