Did anyone create and use Boost.Asio mixins and can share his experience? I especially wonder if there is a benefit or if it's just an exercise in templates. The reason I started to think about Boost.Asio mixins is that I see the very same code in various classes which all use Boost.Asio objects. I would assume that this is not only true in my projects but also in others. Here's an example. Let's say we create a client class to connect to another host. We could come up with something like this: class client { public: void resolve(std::string host, std::string service); void connect(boost::asio::ip::tcp::resolver::iterator endpoint_iterator); void send(std::string msg); void receive(); private: boost::asio::ip::tcp::resolver r; boost::asio::ip::tcp::socket s; }; If we create another class to encapsulate a POSIX file descriptor we don't need resolve() and connect() but send() and receive(): class posix_fd { public: void send(std::string msg); void receive(); private: boost::asio::posix::stream_descriptor fd; }; While the two classes are based on different I/O objects the implementation of send() and receive() could be the same. That lead me to create mixins with which I can define client and posix_fd like this: class client : public resolver, public connector, public sender, public receiver { // Inherited from parent classes: // void resolve(std::string host, std::string service); // void connect(boost::asio::ip::tcp::resolver::iterator endpoint_iterator); // void send(std::string msg); // void receive(); }; class posix_fd : public sender, public receiver { // Inherited from parent classes: // void send(std::string msg); // void receive(); }; Sending and receiving data asynchronously has been implemented now once and for all in the sender and receiver template classes. As the implementation doesn't differ for Boost.Asio I/O objects they can be reused. And if we had concepts already in C++ the mixins could be based on them. It all seems to fit nicely together. While there are some problems, too, I haven't made my mind yet if these Boost.Asio mixins are an improvement or make code more complicated. I'm not asking about mixins in general but wonder if anyone had a good or bad experience using them with Boost.Asio? Or are all Boost.Asio users simply calling the very same async_write() and async_read() functions again and again, creating yet another buffer, checking again the error code in the handlers etc.? Boris