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
pull/8419/head
Jawher Kl 2 weeks ago committed by GitHub
parent e0589284ef
commit a2018556cd
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
  1. 17
      src/data/roadmaps/server-side-game-developer/content/channel@SXOEMkcVYBsRza6BPmmwy.md
  2. 15
      src/data/roadmaps/server-side-game-developer/content/congestion-control@1GML0Jsfdb1Fn-0PNryiQ.md
  3. 13
      src/data/roadmaps/server-side-game-developer/content/coroutine@o0Y_hM0KXUApfsXG4PvOY.md
  4. 14
      src/data/roadmaps/server-side-game-developer/content/error-detection@vFM311xSa5OqNVove2f6j.md
  5. 17
      src/data/roadmaps/server-side-game-developer/content/flow-control@lDVD-3i64Mk7-KPJrXmFH.md
  6. 19
      src/data/roadmaps/server-side-game-developer/content/max-segment-size@w6ysmcsBn9jJ8xMvg7hcD.md
  7. 15
      src/data/roadmaps/server-side-game-developer/content/reliable-transmission@X2KHWgQZDHSVDsTRMUwSj.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)

@ -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)

@ -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)

@ -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)

@ -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/)

@ -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)

@ -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)
Loading…
Cancel
Save