rather is defined implicitly, via duck typing, and must be documented separately and manually, in comments. The main idea is to use commonality-variability analysis to divide the type into the fixed implementation and interface, the policy-based class, and the different policies. The trick is to know what goes into the main class, and what policies should one create. The article mentioned above gives the following answer: wherever we would need to make a possible limiting design decision, we should postpone that decision, we should delegate it to an appropriately named policy. Policy classes can contain implementation, type definitions and so forth. Basically, the designer of the main template class will define what the policy classes should provide, what customization points they need to implement. It may be a delicate task to create a good set of policies, just the right number (e.g., the minimum necessary). The different customization points, which belong together, should go into one policy argument, such as storage policy, validation policy and so forth. Graphic designers are able to give a name to their policies, which represent concepts, and not those which represent operations or minor implementation details. Policy-based design may incorporate other useful techniques. For example, the template method pattern can be reinterpreted for compile time, so that a main class has a skeleton algorithm, whichat customization pointscalls the appropriate functions of some of the policies. This will be achieved dynamically by concepts in future versions of C++. Simple example Presented below is a simple (contrived) example of a C++ hello world program, where the text to be printed and the method of printing it are decomposed using policies. In this example, HelloWorld is a host class where it takes two policies, one for specifying how a message should be shown and the other for the actual message being printed. Note that the generic implementation is in Run and therefore the code is unable to be compiled unless both policies (Print and Message) are provided. #include <iostream> #include <string> template <typename OutputPolicy, typename LanguagePolicy> class HelloWorld : private OutputPolicy, private LanguagePolicy { public: // Behavior method. void Run() const { // Two policy methods. Print(Message()); } private: using LanguagePolicy::Message; using OutputPolicy::Print; }; class OutputPolicyWriteToCout { protected: template <typename MessageType> void Print(MessageType&& message) const { std::cout << message << std::endl; } }; class LanguagePolicyEnglish { protected: std::string Message() const { return "Hello, World!"; } }; class LanguagePolicyGerman