Python template engines: What are the real benifits and drawbacks to XML vs custom syntax

Question

I'm interested in knowing what are the real difference (benefits and drawbacks) between the two types of python templating engines; XML (like Genshi or Kid) and a custom syntax (like Cheetah or Jinja2).

I'm not looking for which is better, or a recommendation. I understand that no one solution will be perfect, and that the best solution will depend on the problem. I do want to better understand the differences between the two types before I choose one for my problem.

This list may not apply to all templating solutions.

XML Benefits:

• Uses XML, it's mostly familial to developers. There are a few new (ifelse, flow logic) items to learn.
• It works with existing XML toolchains.
• It's more powerful as it is knowledgeable about the data being worked on. (Genshi is context aware)

XML Drawbacks:

• The XML based engines tend to be slower than the custom syntax engines.
• Some will argue that XML is more difficult to learn than custom syntax.

Custom Syntax Benefits:

• It's fast than XML based engines. (see earlier link)
• It's a simple powerful syntax that should be easier to learn.

Custom Syntax Drawbacks:

• It's another syntax to learn.
• It might not work smoothly with existing XML toolchains.

Answer 1

I think the consideration should probably be about how the templates are going to be written. The point of templates is to make sure that people are no longer hand coding (html, LaTeX, xml, whatever). This is why templating engines allow inheritance and other fancy features.

So, Daniel Roseman has a good point when he says that getting humans to write XML is evil. To some extent, you're using templates so you don't have to do that.

With that in mind, the largest difference I've seen between python templating engines is not, in fact, whether they use XML or some custom syntax. The large difference seems to be whether or not the templating engines allow arbitrary python code to be embedded into the template.

You mentioned both Cheetah and Jinja2. Both have special syntax but Cheeta allows pretty much arbitrary python to be embeded in the template, while Jinja2 places heavy restrictions on what can be done with the template. Now you're looking at a trade off between potentially mixing business and presentation logic, with making your template clear and concise.

In the end, the benefits are going to come from how easy it is to read, write, re-read, and re-write your code.

Answer 2

The one overriding principle: getting humans to write XML is evil.

Answer 3

I think, your Pros/Cons are problematic

XML: It's slow.

thats not neccessarily true. Like in Jinja, you could compile a XML-Template. Maybe genshi already does that.

XML: it's familial to developers

also not true. how to do a loop in XML? How to extend a base Template? Depends on the template, obviously. So, you still have to learn, and the XML-Syntax doesnt help.

Custom: It's another syntax to learn.

as said above, you have to learn a new syntax anyway, and with custom languages, the syntax may be a little more comforting, for example with 'else'-statements. also keep in mind that not only programmers, but designers with a less technical point of view may have to use the template.

Custom: It might not work smoothly with existing toolchains.

That may be true for XML as well: you probably want HTML as an output, which is (when you dont go for XHTML) no XML. But your point is true, and for me it's the answer: the different approaches fit different needs/toolchains.

The needs and toolchains are imho mostly determined by the expected output. If you have to output valid XML, use XML-Templating, if not, dont.