Template Oriented Programming

[Adam via Digitalmars-d-learn]

I'm not sure if "Template Oriented Programming" seems to be the 
way to go in D, but I've got my head mainly stuck around OOP.

I'm a bit confused about how to dive into it.

With OOP, we create interfaces, which provide a contract that all 
implementers of the interface have to abide by. Delegation is 
done through the interfaces to maximize independence between 
those that use it. Essentially the contract/interface is the law, 
and nothing is above it.

Now, with TOP, we used templates which are self contained blocks 
of code that functions similar to generic classes(in fact, 
identical in some cases). Templates, though, because they can 
contain compile time logic checking, also can create contracts.

Right?

It sounds like TOP allows more generic contracts because the 
programmer has a more powerful constraint syntax than what 
interfaces define. Interface inclusion is very strict and mainly 
based off of inclusion(if you include a method in an interface 
then every implementation also has to include that method). TOP, 
OTH, allows more loosely based constraints that are up to the 
programmer(the static if part of a template).

Is this the basic idea?

Use templates when you want more power? That is, TOP can do 
everything OOP can do but more? Or are these ultimately two 
orthogonal concepts?