# Programming Languages

> Core programming languages for game server development including C++, C#, Go, Rust

- Skill: `majiayu000/programming-languages` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add majiayu000/programming-languages`
- Raw SKILL.md: https://api.skillmd.com/api/skills/majiayu000/programming-languages/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: majiayu000 (https://skillmd.com/u/majiayu000)
- Updated: 2026-09-09
- Page: https://skillmd.com/skills/majiayu000/programming-languages

---


# Programming Languages for Game Servers

Master **high-performance languages** for real-time game server development.

## Language Comparison

| Language | Performance | Memory | Concurrency | Use Case |
|----------|-------------|--------|-------------|----------|
| C++ | Highest | Manual | Threads | AAA, FPS |
| Rust | High | Safe | Async | New projects |
| Go | High | GC | Goroutines | Microservices |
| C# | Medium | GC | Async | Unity, casual |
| Java | Medium | GC | Threads | MMO |

## C++ Game Server

```cpp
#include <boost/asio.hpp>

class GameServer {
public:
    GameServer(boost::asio::io_context& io, short port)
        : acceptor_(io, tcp::endpoint(tcp::v4(), port)) {
        start_accept();
    }

private:
    void start_accept() {
        auto socket = std::make_shared<tcp::socket>(acceptor_.get_executor());
        acceptor_.async_accept(*socket,
            [this, socket](boost::system::error_code ec) {
                if (!ec) handle_connection(socket);
                start_accept();
            });
    }

    tcp::acceptor acceptor_;
};
```

## Go Server

```go
type GameServer struct {
    players sync.Map
    tick    *time.Ticker
}

func (s *GameServer) handlePlayer(conn net.Conn) {
    defer conn.Close()
    for {
        msg := readMessage(conn)
        go s.processMessage(msg)
    }
}
```

## Rust Server

```rust
async fn handle_player(stream: TcpStream) -> Result<()> {
    let (reader, writer) = stream.split();
    loop {
        let msg = read_message(&mut reader).await?;
        let response = process_command(&msg).await;
        write_message(&mut writer, &response).await?;
    }
}
```

## Selection Criteria

| Factor | Best Choice |
|--------|-------------|
| Latency critical | C++, Rust |
| Rapid development | Go, C# |
| Team expertise | Match existing |
| Scalability | Go, Erlang |

## Troubleshooting

### Common Failure Modes

| Error | Root Cause | Solution |
|-------|------------|----------|
| Memory leak | Manual mgmt | Use RAII/smart ptrs |
| GC pauses | Allocation | Pool objects |
| Thread deadlock | Lock order | Lock hierarchy |
| Segfault | Pointer bug | Use Rust/sanitizers |

### Debug Checklist

```bash
# C++ memory check
valgrind --leak-check=full ./game-server

# Go profiling
go tool pprof http://localhost:6060/debug/pprof/heap

# Rust optimization
cargo build --release
```

## Unit Test Template

```cpp
TEST(GameServer, AcceptsConnections) {
    GameServer server(8080);
    TcpClient client;
    client.connect("localhost", 8080);
    EXPECT_TRUE(client.isConnected());
}
```

## Resources

- `assets/` - Language templates
- `references/` - Performance guides