¿Utilizó bibliotecas estándar o desarrolló soluciones…

Utilicé tanto bibliotecas estándar como soluciones propias, dependiendo del proyecto y los requisitos.

Bibliotecas estándar:

Sockets API (BSD Sockets): API de bajo nivel para trabajar con TCP/IP. Se usa para crear sockets, establecer conexiones, enviar y recibir datos.
Boost.Asio: Biblioteca multiplataforma para entrada/salida asíncrona, frecuentemente utilizada para trabajo en red gracias a soporte de sockets, temporizadores y otros primitivas de red.
libcurl: Biblioteca cliente para transferencia de datos a través de diversos protocolos (HTTP, HTTPS, FTP, etc.).

Soluciones propias:

Desarrollé bibliotecas y componentes propios en casos donde las soluciones estándar no satisfacían requisitos específicos del proyecto, como:

Alto rendimiento y bajas latencias.
Necesidad de implementar protocolos no estándar.
Integración estrecha con otros componentes del sistema.
Requisitos de tolerancia a fallos y escalabilidad que exceden los escenarios típicos de uso de bibliotecas estándar.

Ejemplo de uso de una solución propia para un servidor TCP asíncrono:

// Ejemplo simplificado de un servidor TCP asíncrono propio
#include <iostream>
#include <vector>
#include <asio.hpp> // Frecuentemente usado como base para pools de hilos u operaciones así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() {
        // Esperando una nueva conexión
        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 aceptando conexiones
        });
    }

    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) {
                // Procesar datos recibidos
                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 << "Excepción: " << e.what() << "\n";
//     }
//     return 0;
// }

Tabla comparativa de enfoques:

Enfoque	Ventajas	Desventajas	Aplicación
Bibliotecas estándar	Desarrollo rápido, comprobado, buena documentación, soporte comunitario.	Flexibilidad limitada, posible overhead.	La mayoría de tareas de red típicas.
Soluciones propias	Control total, alta flexibilidad, optimización para tareas específicas.	Alto costo de desarrollo y mantenimiento, riesgo de errores, necesidad de pruebas.	Requisitos específicos de rendimiento, protocolos no estándar, integración estrecha.

En general, la elección dependía del proyecto, sus objetivos y restricciones. Buscaba encontrar un equilibrio óptimo entre usar soluciones existentes y desarrollar propias cuando era justificado.

¿Utilizó bibliotecas estándar o desarrolló soluciones propias para trabajar con la red?