Object Orientation in templating
I like script-less templating approaches. They provide freedom to the programmer. Even though they look just simple, the approach provides a number of very powerful features. First it replaces a scripting language by a real programming language. Java in this case. The features I missed in most scripting languages: clear initialization with parameter support (aka constructor) and inheritance of course. And the tooling including refatorings, goto declaration and other helpers. The list is long. On the other hand the template wins, too. It can be directly previewed, provides fine grained reuse, is smaller. And the additional indirection adds completely new possibilities. Minimal template approaches, independent replacement. Again a long list. But it just looks minimal. No huge language documentation to read. No hundreds of constructs and functions. No parameter maps.
Two syntactical constructs, one java class with 200 lines of code. This can replace the huge technology XY?
Can't small things be powerful? Let's look at OOP. What is object orientation made of? An additional parameter and a method selector. Huge? No! Powerful? Yes!
Though, are passive templates the new object orientation? Say, there are at least similarities. It's slower and takes more memory. Development and even more maintenance is simpler and faster when things get complicated. Refactoring is better supported by additional encapsulation and clearer interfaces. And OOP was quite a while around before it got the attention it has today. Maybe passive templates are not the same big thing as OOP, but I'm pretty sure they don't get the attention they should.