Para trabalhar com a rede, utilizou bibliotecas…

Utilizei tanto bibliotecas padrão como soluções próprias, dependendo do projeto e dos requisitos.

Bibliotecas padrão:

Sockets API (BSD Sockets): API de baixo nível para trabalhar com TCP/IP. Utilizada para criar sockets, estabelecer conexões, enviar e receber dados.
Boost.Asio: Biblioteca multiplataforma para entrada/saída assíncrona, frequentemente usada para trabalho em rede graças ao suporte de sockets, temporizadores e outras primitivas de rede.
libcurl: Biblioteca cliente para transferência de dados através de diversos protocolos (HTTP, HTTPS, FTP, etc.).

Soluções próprias:

Desenvolvi bibliotecas e componentes próprios em casos onde as soluções padrão não satisfaziam requisitos específicos do projeto, tais como:

Alto desempenho e baixas latências.
Necessidade de implementar protocolos não padrão.
Integração estreita com outros componentes do sistema.
Requisitos de tolerância a falhas e escalabilidade que excedem os cenários de uso típicos de bibliotecas padrão.

Exemplo de uso de uma solução própria para um servidor TCP assíncrono:

// Exemplo simplificado de um servidor TCP assíncrono próprio
#include <iostream>
#include <vector>
#include <asio.hpp> // Frequentemente usado como base para pools de threads ou operações assíncronas

class TcpServer {
public:
    TcpServer(asio::io_context& io_context, short port)
        : acceptor_(io_context, asio::ip::tcp::endpoint(asio::ip::tcp::v4(), port)) {
        start_accept();
    }

private:
    void start_accept() {
        // Aguardar nova conexão
        auto new_connection = std::make_shared<TcpConnection>(acceptor_.get_executor());
        acceptor_.async_accept(new_connection->socket(),
            [this, new_connection](const asio::error_code& error) {
            if (!error) {
                new_connection->start();
            }
            start_accept(); // Continuar aceitando conexões
        });
    }

    asio::ip::tcp::acceptor acceptor_;
};

class TcpConnection : public std::enable_shared_from_this<TcpConnection> {
public:
    TcpConnection(asio::executor ex) : socket_(ex) {}

    asio::ip::tcp::socket& socket() { return socket_; }

    void start() {
        do_read();
    }

private:
    void do_read() {
        auto self(shared_from_this());
        socket_.async_read_some(asio::buffer(data_, max_length),
            [self](const asio::error_code& error, size_t bytes_transferred) {
            if (!error) {
                // Processar dados recebidos
                self->do_write(bytes_transferred);
            }
        });
    }

    void do_write(size_t length) {
        auto self(shared_from_this());
        asio::async_write(socket_, asio::buffer(data_, length),
            [self](const asio::error_code& error, size_t /*bytes_transferred*/) {
            if (!error) {
                self->do_read();
            }
        });
    }

    asio::ip::tcp::socket socket_;
    enum { max_length = 1024 };
    char data_[max_length];
};
// int main() {
//     try {
//         asio::io_context io_context;
//         TcpServer server(io_context, 8080);
//         io_context.run();
//     } catch (std::exception& e) {
//         std::cerr << "Exceção: " << e.what() << "\n";
//     }
//     return 0;
// }

Comparativo de abordagens:

Abordagem	Vantagens	Desvantagens	Aplicação
Bibliotecas padrão	Desenvolvimento rápido, comprovado, boa documentação, suporte da comunidade.	Flexibilidade limitada, possível overhead.	A maioria das tarefas de rede típicas.
Soluções próprias	Controle total, alta flexibilidade, otimização para tarefas específicas.	Alto custo de desenvolvimento e manutenção, risco de erros, necessidade de testes.	Requisitos específicos de desempenho, protocolos não padrão, integração estreita.

De modo geral, a escolha dependia do projeto, seus objetivos e restrições. Buscava encontrar um equilíbrio ótimo entre usar soluções prontas e desenvolver próprias, quando justificado.

Para trabalhar com a rede, utilizou bibliotecas padrão ou desenvolveu soluções próprias?